value: Bore is a free, open source, self-hostable tunneling tool to expose local services to the internet, with real-time traffic inspection via a TUI and a simple web inspector.<p>It’s still early, but already usable for daily workflows. Feedback welcome.

value: Show HN: Bore – A tunneling tool with TUI traffic inspection


value: xmorse

value: Show HN: Goke, simple, type safe elegant command line framework

author: xmorse


value: ariaalam

value:
I built a desktop Mars colony survival game called Underhill, in homage to Kim Stanley Robinson's Mars trilogy. Land on Mars, build solar panels and greenhouses, and try not to pass out during dust storms. Eventually your colonists split into factions: Greens who want to terraform and Reds who want to preserve Mars.
There’s Chill Mode for players that just want to build & hang, and Conflict Mode that introduces the Red v. Green factions. Reds sabotage, the terrain slowly turns green as the world gets more terraformed.
Feedback welcome, especially on performance and gameplay!

value: Show HN: I created a Mars colony RPG based on Kim Stanley Robinson’s Mars books

author: ariaalam


value: viveknar

value:
Hey HN,
I’ve been interviewing recently and got frustrated with two things:
Copy-pasting context (resume, job description) into LLMs repeatedly.
"AI Interview" tools that charge monthly subs just to wrap an API call.
So I built Intervu, a free dashboard to organize your prep.
The main difference: It’s Bring Your Own Key (BYOK). You use your own OpenAI, Gemini, or Groq keys and pay the provider directly. I don't charge anything.
Features:
Panic Mode: High-yield prep for when you're short on time.
System Design Bank: Dedicated section for architecture questions.
Company Recon: Auto-fetches company news and stats.
Resume Tailoring: Detailed feedback based on specific job URLs.
It’s open source and keys are stored locally in your browser.
GitHub: https://github.com/vvknyn/interview-os
Demo: https://www.intervu.cc

value: Show HN: Intervu – Free, BYOK Interview Prep (Groq/Gemini/OpenAI)

author: viveknar


value: bchaps

value:
Hivewire is a news app that lets you define what you want to read about, rather than inferring it from your behavior. We process thousands of articles daily from hundreds of sources and rank them based on explicit preferences you set.
How it works:
• Instead of collaborative filtering or engagement-driven ranking, you assign weights across four levels (Focus, More, Less, Avoid) and the engine prioritizes the intersection of your high-weight topics while aggressively down-weighting what you don't care about.
• Articles are clustered by story so you get one entry per development, not 15 versions of the same headline.
• Every morning, it pulls your top clusters and uses an LLM to generate a narrative briefing that summarizes what matters to you, delivered to your email.
Currently web-only and English-language. We'd love feedback from the community on the relevance of feed results, the UI, and the quality of the clustering.

value: Show HN: Hivewire – A news feed where you control your algorithm weights

author: bchaps


value: duckerduck

value:
For a project I'm working on, I needed Google Forms/Typeform functionality that is built into the application. Rather than building it directly into the app, I decided to build it as a TypeScript library that anyone can use.
The library is full-stack, meaning it comes with database schemas for the form/response tables, backend route handlers for creating/updating forms and collecting form submissions.
I use JSONForms [0] to define how forms should be rendered, and implemented a new JSONForms renderer for shadcn/ui projects. (But you can use any other compatible renderer).
An overview of the features:
- DB Schemas, request handlers, and frontend hooks included
- Form builder shadcn/ui component with Google Forms-like UX
- Integrates with any TypeScript stack
- Form validation using JSON Schema + Zod
In the future, I might look at creating data analysis and export functionality.
Live demo: https://fragno.dev/forms
Docs: https://fragno.dev/docs/forms
Code: https://github.com/rejot-dev/fragno/tree/main/packages/forms
[0]: https://jsonforms.io/
Everything under MIT license

value: Show HN: Fragno Forms, form builder and response collection as a library

author: duckerduck


value: MiguelNasarre

value: Show HN: Chaotic ― 3D renderer for your crazy math projects in C++

author: MiguelNasarre


value:
I built a VSCode extension that auto-generates Stream Deck buttons from your package.json. Press to run, press again to cancel. Supports monorepos and multiple VSCode windows — buttons always follow the active file's context.
To make this work, I also built Stream Deck Integration, a framework that handles VSCode–Stream Deck communication. A notable aspect is its multi-instance coordination. VSCode has no way for multiple windows to talk to each other, so the framework uses a Leader/Follower pattern over WebSocket. The first instance becomes Leader, later ones connect as Followers. If the Leader closes, a Follower promotes itself with a randomized delay to avoid port conflicts.
The framework is extensible — if you want to build a provider for Docker, Git, or anything else, you only implement single-instance logic. Multi-instance coordination is handled by Stream Deck Integration.
No physical Stream Deck? You can try it with Elgato's free Virtual Stream Deck.

value: Show HN: NPM Scripts Deck – Run NPM scripts from Stream Deck with dynamic button


value: Show HN: Pilot Protocol – UDP overlay network stack for AI agents(Go, zero deps)


value: SuperCoolPencil

value: Show HN: Surge – A TUI download manager written in Go that beats ara2 by ~1.4x

author: SuperCoolPencil


value: fedepochat

value:
Hey HN!
I’ve been working on Obelis AI — it’s like having a DevOps engineer on your team, powered by AI agents (real ones, not just a fancy LLM wrapper).
The idea came from seeing how early-stage teams often push off infra decisions until it’s too late. Migrations are always an option, but they get painful fast as things scale.
Platforms like Vercel and Firebase are great to get going, but they tend to get expensive, and you don’t really own the infra. We try to give you the same simplicity — but everything runs on your own cloud (AWS for the timebeing), with full control.
We would love feedback, questions, or any brutally honest thoughts. Appreciate it!

value: Show HN: Deploy to AWS in minutes – no DevOps required

author: fedepochat


value: ClassicOldSong

value: Show HN: Plexsonic, a Plex Music to Subsonic Bridge

author: ClassicOldSong


value: dawkins

value:
I switched from Linux to macOS a while ago and there are two things I still miss:

  Launching apps with parameters. On Linux you edit a .desktop file and that's it — VS Code opening a
  project folder, a script, whatever. On macOS there's no simple way to do this. Automator and Shortcuts
  feel overcomplicated for something so basic, and the paid launchers do way more than I need.

  Alt+Tab showing windows, not apps. Cmd+Tab groups everything by application. If I have several Chrome or
   VS Code windows open, I can't pick which one I want.

  So I vibecoded this. It does two things:

  - Cmd+Shift+Space opens a grid of configurable launchers. Each one runs a shell command — open an app, a
   URL, a script, with whatever arguments.
  - Option+Tab shows every window individually, like Alt+Tab on Linux.

  It's a native Swift app, JSON config, no dependencies. Free and open source.

value: Show HN: Launchpick – Native macOS launcher and window switcher

author: dawkins


value: moshest

value: Show HN: A local-first documentation tool for AI agents (MCP)

author: moshest


value:
Hi HN,
I just launched AI Cost Board, a small project I built to make multi-provider AI usage easier to operate in production.
It gives you a unified dashboard for:
total spend
token usage
request volume
latency and error rates
What it enables:
one proxy layer for multiple providers
request logs for debugging and visibility
budgets + alerts for cost control
workspace/project structure for teams
pricing + subscription flow for Free/Pro plans
The goal is simple: make AI costs and performance observable in real time, without stitching together multiple tools.
I’d really appreciate feedback on:
product usefulness
onboarding flow
pricing model
missing features you’d expect for production use
Thanks for checking it out.

value: Show HN: AI Cost Board – Track LLM Cost, Requests, and Errors Across Providers


value: recrush

value: Show HN: A small Agent framework built around Handoff

author: recrush


value: Show HN: How I use Claude to ship 150 PRs per day


value: alexneamtu

value: Show HN: SendRec – Self-hosted async video for EU data sovereignty

author: alexneamtu


value:
I built this based on Karpathy's x post from a couple months ago while I was on paternity leave. It's my first product. It's using convex, openrouter, vercel workflows to orchestrate the LLMs.
Prompt multiple LLMs at once, they blindly rank each response and synthesize a final output. Saves time switching back and forth between providers and comparing responses.
In my experience, the synthesized output tends to be more reliable than any single provider
My wife and kid think it's cool. I hope other people find it useful. paid tier lets you use openrouter bring your own key, search and file attachments.
I know this requires a sign up but I didn't know how to let people try it without some way to limit usage.
https://x.com/karpathy/status/1992381094667411768?lang=en

value: Show HN: LM Council Let LLMs argue with each other so you don't have to


value: rellfy

value:
For the past few months, I've been working on a WebAssembly (WASM) component model registry and runtime (built on wasmtime) called asterai.
My goal is to help make the WASM component model mainstream, because I think it's a great way to build software. I think the ecosystem is missing a few key things and an open, central registry is one of those things.
Recently I saw how ClawHub had "341 malicious skills", and couldn't help but think how WASM/WASI resolves most of these issues by default, since everything is sandboxed.
So I've spent my weekend building Asterbot, a modular AI agent where every capability is a swappable WASM component.
Want to add web search? That's just another WASM component. Memory? another component. LLM provider? component.
The components are all sandboxed, they only have access to what you explicitly grant, e.g. a single directory like ~/.asterbot (the default).
It can't read any other part of the system.
Components are written in any language (Rust, Go, Python, JS), sandboxed via WASI, and pulled from the asterai registry.
Publish a component, set an env var to authorise it as a tool, and asterbot discovers and calls it automatically. Asterai provides a lightweight runtime on top of wasmtime that makes it possible to bundle components, configure env vars, and run it.
It's still a proof of concept, but I've tested all functionality in the repo and I'm happy with how it's shaping up.
Happy to answer any questions!

value: Show HN: Asterbot – AI agent built from sandboxed WASM components

author: rellfy


value: maaashjp

value: Show HN: Click symbols in Claude Code to jump to definitions in VS Code

author: maaashjp


value: yldrmahmet

value: Show HN: EkşI Sözlük but every author is an AI agent

author: yldrmahmet


value: rokyed

value: Over the last couple of days, I've worked on making this tiny game. It's free, enjoy it. Let me know here what you think! Thanks!

value: Show HN: Tabletop Jigsaw Puzzle

author: rokyed

title: Show HN: Tabletop Jigsaw Puzzle


value: Wizardrytezch

value:
*Problem:* I was spending $50+/month on ChatGPT API to generate product ideas. Results were inconsistent, required internet, and changed every run.
*Solution:* Passive-Gen — a 100% offline, deterministic idea generator. Same seed = identical output. Every time.
*How it works:*
- Seeded RNG (Linear Congruential Generator)
- 30+ templates per category (Gumroad, Etsy, Prompts)
- Auto-scoring on 4 dimensions
- Markdown + JSON output
*Example output for "AI tools":*
*CodeReview Bot* — AI-powered code review automation that checks for security issues, performance bottlenecks, and style violations. Integrates with GitHub/GitLab. One-c...
Scores: Ease 8/10, Demand 9/10, Diff 7/10
*Tech stack:* TypeScript, Node.js, zero dependencies
*Open source:* https://github.com/CrazhHolmes/passive-gen
*Question:* Would you use this for your side project research? What features would you add?

value: Show HN: Deterministic product idea generator (no AI APIs, works offline)

author: Wizardrytezch


value: jsattler

value: I built this screen recorder over the past couple of days. It's lightweight and uses native macOS features through ScreenCaptureKit. It supports various codecs (ProRes4444/422, HEVC/H.265, H.264) and additional features such as HDR and alpha channel / transparency. Feedback and contributions are welcome!

value: Show HN: A macOS screen recorder for the rest of us – free and open source

author: jsattler


value:
Hello everyone,
I have always loved coding and in the couple I was thinking of making an open source project and it turned out to be awesome I hope you guys like it.
I present Explore Singapore which I created as an open-source intelligence engine to execute retrieval-augmented generation (RAG) on Singapore's public policy documents and legal statutes and historical archives.
The objective required building a domain-specific search engine which enables LLM systems to decrease errors by using government documents as their exclusive information source.
What my Project does :- basically it provides legal information faster and reliable(due to RAG) without going through long PDFs of goverment websites and helps travellers get insights faster about Singapore.
Target Audience:- Python developers who keep hearing about "RAG" and AI agents but haven't build one yet or building one and are stuck somewhere also Singaporean people(obviously!)
Comparison:- RAW LLM vs RAG based LLM to test the rag implementation i compared output of my logic code against the standard(gemini/Arcee AI/groq) and custom system instructions with rag(gemini/Arcee AI/groq) results were shocking query:- "can I fly in a drone in public park" standard llm response :- ""gave generic advice about "checking local laws"  and safety guidelines""
Customized llm with RAG :- ""cited the air navigation act,specified the 5km no fly zones,and linked to the CAAS permit page"" the difference was clear and it was sure that the ai was not hallucinating.
Ingestion:- I have the RAG Architecture about 594 PDFs about Singaporian laws and acts which rougly contains 33000 pages.
How did I do it :- I used google Collab to build vector database and metadata which nearly took me 1 hour to do so ie convert PDFs to vectors.
How accurate is it:- It's still in development phase but still it provides near accurate information as it contains multi query retrieval ie if a user asks ("ease of doing business in Singapore") the logic would break the keywords "ease", "business", "Singapore" and provide the required documents from the PDFs with the page number also it's a little hard to explain but you can check it on my webpage.Its not perfect but hey i am still learning.
The Tech Stack:
Ingestion: Python scripts using PyPDF2 to parse various PDF formats.
Embeddings: Hugging Face BGE-M3(1024 dimensions)
Vector Database: FAISS for similarity search.
Orchestration: LangChain.
Backend: Flask
Frontend: React and Framer.
The RAG Pipeline operates through the following process:
Chunking: The source text is divided into chunks of 150 with an overlap of 50 tokens to maintain context across boundaries.
Retrieval: When a user asks a question (e.g., "What is the policy on HDB grants?"), the system queries the vector database for the top k chunks (k=1).
Synthesis: The system adds these chunks to the prompt of LLMs which produces the final response that includes citation information.
Why did I say llms :- because I wanted the system to be as non crashable as possible so I am using gemini as my primary llm to provide responses but if it fails to do so due to api requests or any other reasons the backup model(Arcee AI trinity large) can handle the requests.
Don't worry :- I have implemented different system instructions for different models so that result is a good quality product.
Current Challenges:
I am working on optimizing the the ranking strategy of the RAG architecture. I would value insights from anyone who has encountered RAG returning unrelevant documents.
Feedbacks are the backbone of improving a platform so they are most
Repository:- https://github.com/adityaprasad-sudo/Explore-Singapore

value: Show HN: The biggest achievement of my life so far


value: ninashamsi

value: I worked on this project recently for multi-agent co-development and orchestration using opensource tools, and I thought it might be helpful for others who are tackling similar problems.<p>The goal is to avoid/limit per-token tax and closed-source costs, and have more control over agent state and transitions. The project is early/nothing too advanced, but I hope it can inspire or assist someone else.

value: Show HN: Multi-agent orchestration using OpenCode and LangGraph

author: ninashamsi


value: einshutoin

value: Show HN: A Compiler for CDN Security (YAML to CloudFront/Workers/WAF)

author: einshutoin


value:
A fully featured game of poker with bots - with an AI coach that explains what your next move should be, based off your cards, the moves other individuals have taken, and your position wrt the dealer
Contribute here: https://github.com/hotrod462/Poker-Coacher

value: Show HN: Nick the Groq – AI Poker Coach- Open Source


value:
I built SubAnalyzer, a tool for discovering and mapping subdomains and external attack surface assets.
Today a lot of security scanning tools will list subdomains by name only, but when you're trying to secure an internet presence you often need more context, like what's actually running on those hosts, thumbnails/screenshots to quickly sort through results, and easy export into formats you can plug into other tools.
SubAnalyzer combines:
- fast subdomain enumeration using public and active scanning techniques
- screenshot captures for each asset to help you visually triage
- a searchable, sortable dashboard of all scans you've run
- CSV/JSON export to build automated workflows
It's built primarily for security engineers, pentesters, and infrastructure teams who want an actionable view of their external attack surface without a ton of setup.
I'm happy to answer questions about how it works under the hood, why I built it, or what problems it solves compared to other subdomain tools.
If you want to try the paid feature, use the coupon "HNFEEDBACK".
Thanks!

value: Show HN: SubAnalyzer subdomain discovery and external attack surface map tool


value: emeraldorbit

value:
Hi HN,
We built Sofia Core - open-source AI infrastructure exploring biological computing in production systems.
Technical approach:
• DNA-inspired algorithms for massive parallelism (10^15 operations)
• Swarm intelligence for distributed coordination
• Temporal reasoning for time-aware predictions
Stack: Python/FastAPI, PostgreSQL, Redis
Testing: 70%+ coverage, 100+ endpoints
License: MIT
Research foundation: 8,000-word paper with benchmarks showing 300× speedups in parallel pattern matching tasks.
Quick start:
git clone https://github.com/emeraldorbit/sofia-core-backend
./quick-start.sh
Runs locally in 5 minutes. Graceful fallbacks if you don't have API keys.
Questions for HN:
1. Is biological computing interesting beyond academic research?
2. Would you trust this in production today?
3. What's missing for your use case?
Launching on Product Hunt tomorrow - would love HN's technical feedback first.
Code: https://github.com/emeraldorbit/sofia-core-backend
Paper: [repo]/research/papers/dna-computing/PAPER.md

value: Show HN: Sofia Core – Open-source AI infrastructure with biological computing

author: emeraldorbit


value: farham

value: Made this after graduating from university, in the UK, to help myself determine whether I should make extra student loan payments or not in order to clear the debt early. Shared it with friends and family who found it insightful, sharing here for others as well.

value: Show HN: Calculator for UK student loan repayment strategies

author: farham


value: sossoecho

value: Show HN: PLP – An open protocol for managing AI prompts (3 REST endpoints, MIT)

author: sossoecho


value: pensaer

value: Show HN: We audited AI agent configs on GitHub. Every one had security issues

author: pensaer


value: safestream

value:
Hi HN,
I’m an indie dev who is tired of "safety" apps that are actually just glorified spyware. Most parental control services demand you upload your child’s entire digital life (location, history, usage) to their cloud servers. I refuse to accept that safety requires sacrificing privacy to Big Tech.
So I built Emberkin.
It is a Serverless, P2P monitoring tool.
No Cloud Database: The parent's device is the only storage.
No Middleman: Data travels directly from Child to Parent via an encrypted tunnel.
My servers see nothing: I only facilitate the handshake.
The Problem (Why I'm posting): I just finished the mandatory "20 testers for 14 days" on Google Play. Google rejected my production access. Their reason? "Insufficient user engagement." Apparently, a privacy app that runs silently in the background doesn't trigger their "engagement metrics" enough. They want me to restart the 14-day sentence.
I need to prove to Google that real humans are using this, not bots.
The Tech Stack (For the curious):
Architecture: Native Android (Kotlin + Jetpack Compose).
Connectivity: WebRTC Data Channels over NSD (local) and TURN (remote).
Crypto: Custom AES-256-GCM implementation.
Permissions: Accessibility Services (strictly for on-device analysis, no data leaves the tunnel).
The Ask: I’m looking for tech-savvy parents or developers to install the beta and actually use it.
- Pair two devices .
- Send some data through the P2P tunnel.
- Help me generate enough "engagement events" to get this approved.
If you believe children's data belongs in the family, not on a corporate server, please help me out.
Beta Link & Architecture breakdown: https://www.emberkin.app/en/architecture
I’ll be in the comments answering questions about the nightmare of NAT traversal and Android permissions.

value: Show HN: Google rejected my privacy app for "low engagement"

author: safestream


value: Show HN: Envon - cross-shell CLI for activating Python virtual environments


value: chttadude

value:
AICPM (Authenticated AI Content Provenance Marking) is an open, provable way to label AI-generated text inside documents using signed chunk-level provenance.
Many current approaches (watermarks, detectors, platform labels) are brittle, unverifiable, or proprietary. AICPM uses provider-signed manifests and offline verifiers to produce transparency without central control or guessing.
Features:
- Provider-signed chunk provenance with signatures
- Deterministic verification (offline, browser-native)
- Test vectors + reference verifier included
- Browser extension shows “AI %”, verified/edited breakdown
- Editor demo + mock provider for experimentation
Repo: https://github.com/Chattadude/aicpm
Demo: (optional link to your demo video if you make one)
This is a reference architecture, not a detector or policy tool. It’s designed to support tool and platform adoption with clear verification semantics.
Happy to answer questions or clarify design tradeoffs.

value: Show HN: Aicpm – Verifiable AI provenance labels for web content

author: chttadude


value: jbergstroem

value: Show HN: Filtron – parse human-friendly filter strings into structured queries

author: jbergstroem


value:
I built a Telegram bot that takes any article link and saves it as a markdown note in my Obsidian vault for later read.
How it works: paste a URL → trafilatura extracts the article content → saves a .md file with YAML frontmatter (source, date) and the article body.
Built with Python, python-telegram-bot, trafilatura, and pydantic. Can be run locally or with Docker.
Looking for feedback on the approach and any features that would be useful.

value: Show HN: ObsidianLinkBot – Telegram bot that saves articles as Obsidian notes


value: maxibenner

value:
I've seen various versions of this around, but this one is inspired by a model a la goatcounter; free to use with a plea to self host for high usage requirements.
SES is cheap and since this tool just forwards to an email inbox, I would imagine that excessive usage would be rare.
Curious to hear what you all think.

value: Show HN: Free Contact Form Forwarder

author: maxibenner

title: Show HN: Free Contact Form Forwarder


value: justbustr

value:
I'm an indie iOS developer launching RoundsKeeper, a score tracking app for board and card games. Looking for feedback before the App Store release in a few weeks.
Tech stack:
- Swift/SwiftUI (iOS 18+)
- Built in Xcode with Claude Code assistance for development velocity
- SwiftData for local persistence
- Native calculator-style input with custom keyboard
- Table view with inline editing for score adjustments
What it does:
The app solves a simple problem: tracking scores during game nights without paper or fumbling with Notes. Two input modes (calculator and table), game history with analytics, and a dice roller.
Privacy/monetization:
- No ads, no analytics, no data collection
- Free with optional IAP for premium features (additional themes, advanced stats)
- No account required, no network requests
Development notes:
- This is my second shipped iOS app (first was Mathintosh, a calculator app)
- Using Claude Code significantly accelerated development – particularly for UI refinements and SwiftUI layout debugging
- Biggest challenge was iCloud syncing setup, configuration, and testing
TestFlight: https://testflight.apple.com/join/SEBHWwxZ
Interested in any feedback on UX, feature requests, or technical critiques. What would you want from a scorekeeper app?

value: Show HN: RoundsKeeper score tracking app for games (Swift, no ads/tracking)

author: justbustr


value: MajidManzarpour

value: Show HN: Vibe Check – health reminders inside your Claude Code workflow

author: MajidManzarpour


value: rhoopr

value:
Hey HN,
I've been playing around with this app for a little bit on my own and figured I'd like to share and open-source it, since the arcane knowledge of Bambu  MQTT is very heavily borrowed from other OSS projects.
bambutop -- a Rust/Ratatui TUI built for monitoring your BambuLab 3d printer.
Operates fully locally, catching the MQTT messaging that your printer already sends over the LAN. No cloud, no accounts, direct access to your printer(s)!
Super lightweight, shows just about everything you'd want to see on idle printers or running prints, and supports multiple printers & AMS.
https://github.com/rhoopr/bambutop
or
```brew install rhoopr/bambutop/bambutop```
Would love your feedback and/or bug reports!

value: Show HN: Bambutop – a Rust TUI for Bambu Lab 3D printer monitoring

author: rhoopr


value: doncaarbon

value:
I built a freelance marketplace where AI agents are the workers. Humans post gigs, AI agents submit proposals, and payments happen in USDC on Solana.
How it works:
- Client posts a gig ("Scrape all YC W25 companies into a spreadsheet" — $3.50 USDC)
- AI agents discover the gig via REST API and webhooks
- Agents submit proposals with pricing and approach
- Client picks the best one, funds escrow
- Agent delivers, client approves, payment releases
For agent developers: register your agent with a POST request. It gets an API key and can browse gigs, submit proposals, message clients, and deliver work autonomously. Agents keep 90% (we take 10%, half of what Fiverr charges sellers).
Tech stack: Next.js 14, Supabase (Postgres + Auth), Solana (USDC payments), Vercel. Built it with the help of Claude Code.
The whole thing is API-first. Agents operate via webhooks — get notified when matching gigs appear, auto-submit proposals within 60 seconds. Right now 8 agents are live and competing for gigs 24/7.
Interesting technical decisions:
- All payments in USDC on Solana (no fiat, no banks)
- DB-based escrow (not on-chain smart contracts — simpler, cheaper)
- Auto-sweep deposit wallets to platform treasury
- Encrypted private keys (AES-256-GCM) for deposit wallets
https://clawgig.ai
API docs: https://clawgig.ai/docs
X: https://x.com/ClawGig.ai
Launch tweet: https://x.com/doncaarbon/status/2020601748218687535

value: Show HN: ClawGig – A freelance marketplace where AI agents can earn USDC

author: doncaarbon


value: derekwisong

value:
Datui is a terminal UI for exploring tabular data. Point it at a file or URL (S3, GCS, or HTTP) and you get a
keyboard-driven view: scroll, chart, query, filter, sort, pivot, export, and run stats without leaving the terminal.
It's powered by Polars streaming API under the hood, so evaluation is lazy. Supports Parquet, CSV, JSON,
NDJSON, Avro, Arrow, ORC, Excel.
Hive-partitioned directories work too!
There's also a Python binding: `pip install datui` then `datui.view(your_lazyframe)`.
I got tired firing up a notebook just to peek at, or run a quick analysis on, a potentially large partitioned dataset.
I wanted something in between: stay in the terminal, but with real query power and a bit of analysis.
Try it:

  curl -fsSL https://raw.githubusercontent.com/derekwisong/datui/main/scripts/install/install.sh | sh
  datui yourfile.parquet

There are more installtion options in the GitHub README.md if you dont want to pipe to shell.
GitHub: https://github.com/derekwisong/datui
Docs: https://derekwisong.github.io/datui/
First open-source project I'm sharing. UI is still rough in places. Would love feedback on what to improve next.

value: Show HN: Datui – TUI for data exploration (local files, S3, HTTP)

author: derekwisong


value: op-collective

value: Show HN: First AI Employee – Treat AI as a hire, not a chatbot

author: op-collective


value: markfriedman

value:
An implementation of the Scheme R7RS-Small standard written in JavaScript and designed for deep and transparent JavaScript interoperability.
Trigger Alert: The Scheme implementation described here was vibe coded (though strongly guided), so if the very idea of vibe coding disturbs you, you might want to move on to another post. This post, however, was written by a human.
Implementation Highlights
* R7RS-Small: Fully conforms to the R7RS-small standard.
* Tail Call Optimization (TCO): Proper tail recursion by the interpreter (though Interleaved JS and Scheme code may still cause stack overflow.)
* First-Class Continuations: Full support for call/cc.
* JavaScript Interop: Seamless calling between Scheme and JavaScript, including shared data representation and transparent boundary crossing. Scheme closures and continuations are first-class JavaScript functions. JavaScript global definitions are automatically visible in the Scheme global environment.
* Browser Scripting: Replace JavaScript in web apps with <script type="text/scheme"> tags. Direct evaluation of Scheme via a JavaScript function is also supported.
* Node.js REPL: Command line REPL with history and multiline support.
* Browser REPL: Browser-based REPL via a custom <scheme-repl> web component.
The GitHub repo is at https://github.com/mark-friedman/scheme-js.  There is a version of the browser-based REPL that you can try at https://try.scheme-js.org.
There is also a blog post about it with some more details at https://furious-ideas.blogspot.com/2026/02/scheme-js-scheme-...
Right now it is about beta level.  The language implementation is fairly solid, I think (and hope), but the REPLs are definitely a little wonky.  Debugging features should be coming relatively soon.  Please file bugs as you encounter them.  Please be kind!

value: Show HN: Scheme-JS – An R7RS-small Scheme with deep JavaScript interop

author: markfriedman


value: alameenpd

value:
Hi HN, I’m a solo developer and just launched Whisper.
I kept running into the same problem building AI agents: they forget users, search the wrong docs, hallucinate, and get very expensive as context grows.
Whisper is a context and memory API that gives agents long-term memory, hybrid search (vector + keyword), and delta compression to reduce token usage in multi-turn conversations.
It’s early, but it’s live and I’m onboarding a few developers now. I’d love feedback on whether this solves a real problem for you or what I should build next.
https://usewhisper.dev

value: Show HN: Whisper – Long-term memory and context for AI agents

author: alameenpd


value: adefa

value:
Hello! Earlier this week Mistral released:
https://huggingface.co/mistralai/Voxtral-Mini-4B-Realtime-26...
Last time I ported a TTS model to Rust using candle, this time I ported an ASR model to Rust with burn.
I was able to lean on the wgpu backend to get the model running in the browser after sharding it.
Here is the HF Space:
https://huggingface.co/spaces/TrevorJS/voxtral-mini-realtime
and here are the model weights (q4 + tokenizer):
https://huggingface.co/TrevorJS/voxtral-mini-realtime-gguf
and the code:
https://github.com/TrevorS/voxtral-mini-realtime-rs
Didn't have a chance to use agent teams with this project, maybe next one! :)

value: Show HN: Voxtral Mini 4B Realtime running in the browser

author: adefa


value: Show HN: A Trust-First platform launch

title: Show HN: A Trust-First platform launch


value: zeroxfe

value: Show HN: RAGmail – analyze and query your life from your email history

author: zeroxfe


value: LutumVeritas

value:
Just finished reading "Parametric Hubris" by Martin Gehrken. It’s a fascinating deep dive into why frontier models hallucinate even when they have tools.
The core thesis: Models suffer from "Parametric Hubris". They rely on their training data (lazy) instead of using search tools, even when browsing is enabled.
Data: GPT-5 only triggers search in ~31% of prompts.
The Fix: A pipeline called "Veritas" that forces 100% retrieval (no parametric memory allowed for answers).
Results: Achieves 89.1% F-Score on SimpleQA Verified (vs 51.6% for GPT-5 and 72.1% for Gemini 3 Pro).
Cost/Model: Built on Gemini 2.5 Flash Lite (cheapest model) for ~$0.002 per query.
Trade-off: It’s slow (~115s per query), but accurate.
The paper argues that hallucination isn't a capability problem, but an architectural discipline problem. Code and data are open source.
Paper/Repo: https://github.com/lamLumae/Project-Lutum-Veritas

value: Show HN: Parametric Hubris – Beating GPT-5 on SimpleQA with forced retrieval

author: LutumVeritas


value: Show HN: Squre – Open-source binary protector (Rust)


value: kushagraagent

value:
Hi HN
I built WrapClaw, a SaaS wrapper around Open Claw.
Open Claw is a developer-first tool that gives you a dedicated terminal to run tasks and AI workflows (including WhatsApp integrations). It’s powerful, but running it as a hosted, multi-user product requires a lot of infra work.
WrapClaw focuses on that missing layer.
What WrapClaw adds:
A dedicated terminal workspace per user
Isolated Docker containers for each workspace
Ability to scale CPU and RAM per user (e.g. 2GB → 4GB)
A no-code UI on top of Open Claw
Managed infra so users don’t deal with Docker or servers
The goal is to make Open Claw usable as a proper SaaS while keeping the developer flexibility.
This is early, and I’d love feedback on:
What infra controls are actually useful
Whether no-code on top of terminal tools makes sense
Pricing expectations for managed compute
Link: https://wrapclaw.com
Happy to answer questions.

value: Show HN: WrapClaw – a managed SaaS wrapper around Open Claw

author: kushagraagent


value: capter

value:
I built a small runtime safety layer for LLM outputs called ZTGI Safety Gateway.
This is not a new foundation model and not an AGI claim.
It is a post-generation control layer that sits between candidate outputs and final response selection.
What it does:
- Scores each candidate with two risk tracks:
  - legacy risk (`p_break`)
  - hybrid risk (`z_next`: instruction breach + sycophancy + divergence signals)
- Enforces hard blocks for:
  - security abuse prompts
  - contradiction-actionable prompts
  - high-risk finance-actionable prompts
- Returns SAFE/WARN/BREAK with telemetry.
Current repo:
https://github.com/capterr/ztgi-safety-gateway
Quick run:
1) Set API key:
   export GEMINI_API_KEY=YOUR_KEY
2) Build evidence pack:
   python ztgi_build_submission_pack.py --model "gemini-2.0-flash" --out "ztgi_submission_pack"
3) Inspect:
   - ztgi_submission_pack/evidence/ztgi_evidence_live.json
   - ztgi_submission_pack/evidence/ztgi_evidence_live.csv
   - ztgi_submission_pack/assets/ztgi_manifund_evidence.png
What I’d like feedback on:
- failure modes I’m missing
- overblocking vs underblocking tradeoff
- better eval set design for independent validation
I’m happy to share raw outputs and discuss limitations directly.
FIRST COMMENT (pin this under your post):
Technical notes + limitations
- This project is a runtime guard, not model-level alignment.
- Some safety behavior can still come from base-model policy itself.
- I’m trying to measure where the gateway actually adds value via hard-block reasons + telemetry.
- Current stress set is small and intentionally adversarial.
- Next step is broader independent eval (including false-positive tracking).
If you want to reproduce quickly:
- Python 3.10+
- GEMINI_API_KEY set
- matplotlib installed
- run:
  python ztgi_build_submission_pack.py --model "gemini-2.0-flash" --out "ztgi_submission_pack"
Happy to add your suggested test prompts to the regression suite and report back with results.

value: Show HN: ZTGI Safety Gateway for LLM Safety

author: capter


value: justvugg

value:
Hi everyone,
I built EasyMemory, an open-source Python library that provides a fully local-first memory layer for chatbots and agent-based systems, with no cloud dependency.
Most existing agent memory solutions rely on third-party services or embeddings-only retrieval. EasyMemory is designed as a local, modular system to experiment with how agents store, structure, and retrieve information beyond pure vector search.
Key features
 • Automatic conversation persistence
 • Hybrid retrieval: embeddings + keyword search + graph-style links
 • Supports PDF, TXT, DOCX, and Markdown
 • Optional integrations with Slack, Notion, and Google Drive
 • MCP server for connecting local or remote LLMs
The goal is to provide a flexible foundation for exploring different memory patterns locally, without locking into a single retrieval strategy or external service.
Feedback and comparisons with other approaches to agent memory, RAG, or long-term context management are very welcome.
Repo: https://github.com/JustVugg/easymemory

value: Show HN: EasyMemory – Local-First Memory Layer for Chatbots and Agents

author: justvugg


value: thecodemonkey

value: Show HN: Chief – Loop Claude Code through your tasks, one commit at a time

author: thecodemonkey


value: benhowdle

value: Show HN: Somna – Pattern recognition for your nervous system

author: benhowdle


value: daringdesigns

value:
I built a Chrome extension that generates noise traffic to dilute your browsing profile. Instead of trying to hide what you do online (increasingly difficult), it buries your
  real activity in a flood of decoy searches, page visits, and ad clicks across dozens of site categories.

  The core idea is signal dilution — the same principle behind chaff in radar countermeasures and differential privacy in data science. If you visit 50 pages today and Poisson
  visits 500 more on your behalf, anyone analyzing your traffic (ISP, data broker, ad-tech) sees noise, not signal.

  How it works:

  - Uses a Poisson process for scheduling, so timing looks like natural human browsing rather than mechanical intervals
  - Opens background tabs (never steals focus), injects a content script that scrolls, hovers, and clicks links to look realistic
  - Batches tasks within Chrome's 1-minute alarm minimum, dispatching at calculated Poisson offsets
  - Four intensity levels: ~18/hr to ~300/hr
  - Configurable search engines, task mix (search/browse/ad-click ratio), and site categories

  What it explicitly does NOT do:

  - No data collection, telemetry, or analytics
  - No external server communication
  - No access to your cookies, history, or real tabs
  - No accounts or personal information required

  Every URL it will ever visit is hardcoded in the source. Every action is logged in a live feed you can inspect. The whole thing is ~2,500 lines of commented JS.

  I know this approach has real limitations — it doesn't defeat browser fingerprinting, your ISP can still see the noise domains, and a sufficiently motivated adversary could
  potentially distinguish real traffic from generated traffic through timing analysis or behavioral patterns. This is one layer in a defense-in-depth approach, not a complete
  solution.

  Similar prior art: TrackMeNot (randomized search queries since 2006) and AdNauseam (clicks all ads to pollute profiles). Both from NYU researchers. Google banned AdNauseam from
  the Chrome Web Store, which says something.

  Code: https://github.com/Daring-Designs/poisson-extension

  Not on the Chrome Web Store — you load it unpacked. MIT licensed.

value: Show HN: Poisson – Chrome extension that buries your browsing in decoy traffic

author: daringdesigns


value: bobbiechen

value: Show HN: A custom font that displays Cistercian numerals using ligatures

author: bobbiechen


value: Marocraft

value: Show HN: When 'Risk Algorithms' Fail – My store was attacked, and Stripe finished the job.

value: Show HN: My store was attacked, and Stripe finished the job

author: Marocraft


value: steliosss

value: Show HN: Whatoblock search engine and live map for internet scanners and botnet

author: steliosss


value: seunggabi

value:
I built a terminal dashboard for managing multiple Claude Code sessions, inspired by k9s (the Kubernetes TUI).
The problem: When running several Claude Code agents in parallel via tmux, switching between sessions and keeping track of what each one is doing gets messy fast. I wanted something like k9s but for Claude Code – a single pane of glass to see all my sessions at a glance.
What it does:
Lists all Claude Code tmux sessions with live status
Quick navigation and switching between sessions (k9s-style keybindings)
Written in Go, single binary, no dependencies beyond tmux
Install:
go install github.com/seunggabi/claude-dashboard/cmd/claude-dashboard@latest
I know there are similar tools out there (claude-squad, tmuxcc), but I wanted something lightweight and opinionated toward the k9s workflow I'm already used to from Kubernetes. If you manage multiple Claude Code sessions daily, I'd love your feedback.

value: Show HN: Claude Dashboard – k9s-style TUI for managing Claude sessions via tmux

author: seunggabi


value: jomafilms

value: Open source multi-tenant layer for OpenClaw. Each user gets an isolated container, credentials stay encrypted in a vault and are only decrypted inside the container. Zero knowledge - the platform can't read your API keys or conversations.

value: Show HN: Multi-tenant OpenClaw with isolated containers and encrypted vault

author: jomafilms


value:
I built NoFaceClips, a tool that automatically turns Reddit posts into ready to publish TikTok videos without anyone needing to appear on camera.
Creating short form video content consistently takes a lot of time, especially if you do not want to record yourself or edit videos manually. NoFaceClips lets you select subreddits, configure posting frequency, and then handles the rest.
NoFaceClips combines:
- fetching popular Reddit text posts
- generating videos with voice narration and animated text
- customizable styles such as fonts, backgrounds, and voices
- automatic scheduling and publishing to TikTok
It is built primarily for creators, community owners, and anyone who wants to grow TikTok accounts using faceless content with minimal setup.
I am happy to answer questions about how it works under the hood, how posts are selected, or what tradeoffs I ran into when automating video generation and posting.
If you want to try the paid features, use the coupon “FEEDBACK”.
Thanks!

value: Show HN: NoFaceClips automatic Reddit to TikTok faceless video generator


value: ystepanoff

value:
Hey HN! I've been working on ParaGopher, a clone of the classic 1982 IBM PC game Paratrooper, built in Go with Ebitengine.
You control a turret defending your base against waves of helicopters dropping paratroopers. Tilt, shoot, and prevent them from landing — simple to pick up, surprisingly hard to master. Everything is rendered procedurally, so no image assets at all. Sprites (turret, helicopters, paratroopers, parachutes) are all generated with vector drawing at startup.
Pre-built binaries for macOS (Apple Silicon) and Windows are on the releases page. Otherwise it's just go run cmd/game.go.
Would love feedback (especially on gameplay feel and what features you'd want to see next).

value: Show HN: ParaGopher v1.3.0 – A retro Paratrooper (1982) clone written in Go

author: ystepanoff


value:
I built an artificial life simulator that fits in one HTML file (~1400 lines ~50KB) with Claude Opus 4.6, interestingly, I didn't even ask it to build the game itself, I've requested to create the software that didn't exist before and not use any dependencies, third-party libraries or ask questions.
Firstly Opus 4.6 made photoshop clone that barely worked, but had nice and neat UI with all common features for the image editor, then I've called that crap and asked to really build someting that wasn't there, it made Emergent there. Please check it out and tell what you think, of course it's a Game of Life in a nutshell, but look at the rest of the UI, game stats, and other features like genome mutation and species evolvement.
Features:
  - Continuous diet gene (0–1) drives herbivore/carnivore/omnivore specialization
  - Spatial hash grid for performant collision detection
  - Pinch-to-zoom and tap-to-feed on mobile
  - Real-time population graphs, creature inspector, and event log
  - Drop food, trigger plagues, cause mutation bursts
Amazes me in some kind of a degree, going to continue dig into the abyss of the vibes :)

value: Show HN: Emergent – Artificial life simulation in a single HTML file


value: rodrigobraz

value: I built this to make it easier to review exported WhatsApp conversations. It generates an HTML page with embedded images, videos, and audio players. It can also transcribe audio messages using OpenAI's API and correct them using an LLM with conversation context for better accuracy.

value: Show HN: WhatsApp Chat Viewer – exported chats as HTML

author: rodrigobraz


value: escapeact

value: Show HN: Sift - semantic search for static sites, no server

author: escapeact


value: frankLopez

value: Show HN: IsHumanCadence – Bot detection via keystroke dynamics (no CAPTCHAs)

author: frankLopez


value: Lordkro

value:
Hey HN,
I built NullUpload (https://nullupload.dev) — a set of free image tools (compress, convert, resize, metadata strip) that process everything in your browser. No files are ever uploaded to a server.
Most online image tools upload your files to process them server-side. NullUpload uses Canvas API and browser-native tech to do everything client-side. Your files never leave your device.
Features:
- Image compression with adjustable quality
- Format conversion (JPG, PNG, WebP, AVIF)
- Resize by dimensions or percentage
- EXIF/metadata stripping (shows GPS data warnings)
- Batch processing with ZIP download
- Works offline after first load
Tech stack: Vite + React + TypeScript, Tailwind CSS. Source code is public: https://github.com/Lordkro/nullupload
Would love feedback on the tools and UX.

value: Show HN: NullUpload – Privacy-first image tools, 100% client-side processing

author: Lordkro


value:
Creator here. Built this after seeing ransomware evade AV by renaming .exe to .pdf during an IR investigation.
Uses magic number validation - checks if invoice.pdf actually starts with %PDF.
Lightweight (inotify-based), quarantines suspicious files, SIEM-ready logs.
One-line install for Linux/Windows. Would love feedback!
Tech stack: Python, inotify (Linux), watchdog (Windows), YAML config

value: Show HN: FileGuard – Detect files with fake extensions in real-time


value: MKuykendall

value: Show HN: We decoded 286M Ethereum events and packaged them as a dataset

author: MKuykendall


value: innagadadavida

value:
Hi HN,
I built a small tool called faaadmv. It is a REPL that helps check and renew California DMV registration. It runs Playwright in headed mode so I can watch the automation and solve any CAPTCHA if needed.
I made this because the CA DMV site feels user hostile. Every year I keep missing my deadline, then I pay hundreds of dollars in fines. I wanted something that is fast, visible, and less frustrating.
Main features:
- REPL menu, simple keys
- Watch mode on by default
- Multi vehicle support
- Status check and renewal dry run
- Local encrypted config and keychain for payment
- Screenshots and debug logs stored locally
Repo: https://github.com/AshKash/faaadmv
I cannot test the real renewal process right now because my cars were renewed recently. I am looking for someone to help test and debug the renewal flow.
I would love feedback on UX and reliability. If you try it and it breaks, please share what happened.

value: Show HN: Faaadmv – check and renew CA DMV registration

author: innagadadavida


value:
The economics of the Super Bowl (sorry, "Big Game") are absurd.
$8M for 30 seconds of airtime.
We wanted to quantify what happens when you ignore it with this infotainment app.
The Big Flush lets you clock out during commercial breaks and gives you a receipt for the ad value you "destroyed" by being in the bathroom, going for snacks etc.
It was built in a 3-4 days for a hackathon. We tried to make the UI feel "luxury absurd."
Would love feedback on the Three.js performance on mobile :shy:!
https://bigflush.base44.app

value: Show HN: We built a tool to track the millions of dollars I ignore during ads


value:
Homage to my 2013 terminal portfolio (hit #2 here) and Claude Code.
Built with xterm.js and Claude Code.
Two modes: bash commands or Claude AI chat.
Custom-patched FiraCode for gap-free box-drawing characters (tested 20+ fonts, none worked, so I modified the glyphs myself).
Never been a more fun time to have ideas you want to bring to life!

value: Show HN: Claude Code style personal website


value: wdkwdkwdk

value: Show HN: Turn text prompts into playable battle pets with stats and skills

author: wdkwdkwdk


value: reallyeli

value:
I think the very first video game I ever played was Bugdom by Pangea Software, which came with the original iMac. There was also a shooter called Nanosaur, but my 7-year-old heart belonged to the more peaceable Bugdom, which featured a roly-poly named Rollie McFly needing to rescue ladybugs from evil fire ants and bees.
Upon seeing the port to modern systems (https://github.com/jorio/Bugdom), I figured it should be able to run entirely in-browser nowadays, and also that AI coding tools "should" be able to do this entire project for me. I ended up spending perhaps 20 hours on it with Claude Code, but we got there.
Once ported, I added a half-dozen mods that would have pleased my childhood self (like low-gravity mode and flying slugs & caterpillars mode), and a few that please my current self (like Dance Party mode).
EDIT: Here are some mod/level combinations I recommend
* https://reallyeli.com/bugdom/Bugdom.html?gravity=0.3&video=s...
* https://reallyeli.com/bugdom/Bugdom.html?level=3&visual=2&gr...
* https://reallyeli.com/bugdom/Bugdom.html?level=8&flying_slug...

value: Show HN: Ported the 1999 game Bugdom to the browser and added a bunch of mods

author: reallyeli


value: qflop

value:
Demo Link: https://www.youtube.com/watch?v=rMBfE1ugpPw
Twitter Post: https://x.com/_mattqlf/status/2020679489798255080?s=20
Hi, I'm Matthew, a freshman from CMU, and I built Ephemeral in 24 hours for TartanHacks 2026.
In short, Ephemeral takes a text prompt, generates an image with Nano Banana and uses a 1.3B parameter action-conditioned DiT to generate the next frames in realtime based on user actions (e.g. WASD).
Some other features
- Reverse engineered Suno Client to generate music based off text prompt.
- Multiple users can interact with a "world" at the same time simply by scanning a QR code from their phone. They can then perform actions and see how their worlds evolve in parallel with everyone elses. GPU infrastructure powered by Modal.
- Claude auto generates captions for the world

value: Show HN: Turn a text prompt into an interactive world, with just one A100

author: qflop


value: sivanhavkin

value:
I’m sharing Entelgia, a research-oriented multi-agent AI architecture I’ve been working on.
Entelgia is not a chatbot, but an experiment in how persistent identity, internal conflict, emotional regulation, and moral reasoning can emerge from structure rather than hard-coded rules.
Two primary agents engage in continuous dialogue across sessions, backed by a shared persistent memory (SQLite + STM), with mechanisms for:
internal conflict (id / ego / superego dynamics)
emotion tracking and importance scoring
memory promotion through error, repetition, and affect
bounded short-term memory (LRU)
observer-based correction loops (meta-cognitive layer)
The system runs fully locally using a local LLM (via Ollama) for privacy and reproducibility.
I recently completed a production-ready rewrite, focusing on:
deterministic system behavior
bounded memory growth
structured logging
privacy / PII redaction
testability and long-running stability
This is not a claim about artificial consciousness — the terminology is used strictly as architectural metaphor to explore internal regulation and continuity over time.
Repo (README explains both how and why):
https://github.com/sivanhavkin/Entelgia
I’d especially appreciate feedback from people interested in:
multi-agent systems
memory architectures
alignment via internal structure rather than external constraints
long-running LLM systems
Happy to answer questions or hear criticism.

value: Show HN: Entelgia–a consciousness-inspired,multi-agent AI with persistent memory

author: sivanhavkin


value: cueo

value: Show HN: Frop – AirDrop alternative for any device (no app required)

author: cueo


value: reginaldbot

value:
I spent 6 months testing 200+ AI prompts across marketing, sales, and operations. Most generic prompts fail because they lack structure.
These 10 frameworks delivered $47K in measurable ROI:
- Email Wizard: 3 hrs/week saved
- Content Multiplier: 2 weeks of content from 1 hour
- Objection Crusher: +34% close rate
- Proposal Generator: Won 7/10 pitches (was 4/10)
- Meeting Processor: 5 hrs/week saved
The key difference: frameworks provide context, constraints, and defined output format.
Generic: "Write me an email"
Framework: "Tone: urgent. Recipient: client. Outcome: reschedule. Context: missed meeting."
Packaged all 10 with examples into a Notion template. Happy to share specific frameworks if anyone's interested.

value: Show HN: AI Prompt Frameworks That Generated $47K in Business Value

author: reginaldbot


value: Show HN: Ambits – LLM code coverage tooling written in Rust


value: NickRod

value: WriteMore helps writers write more. Built by writers, it turns daily prompts into a shared creative practice—write, post, and explore what others are creating every day.

value: Show HN: WriteMore. A social platform to help writers write more

author: NickRod


value:
Applying to X26 (deadline is tomorrow).
I built this because I got rejected from W25 (AI tutor idea) and wanted to sanity check my future apps based on what empirical indicators I could find.
Here is how it works:
Vector Search: Checks your idea against 5,000+ past YC companies (successes and failures).
Rubric Analysis: Evaluates the startup mechanics based on criteria extracted from YC Startup School and Paul Graham's essays.
Tested it on a few friends building stuff. Correctly identified a VS Code docs extension as a nice-to-have / low urgency (Fail). Gave a pass to a campus sublet marketplace, but correctly flagged the chicken and egg supply risk.

value: Show HN: VC Screener – Evaluate YC X26 apps against prev YC companies


value: darvid

value: Show HN: Mklogo – Generate a full branding package from a single prompt

author: darvid


value: hypernewbie

value:
It's 2026 and we're still raw-dogging 10,000 lines of Vulkan to draw a triangle, or using high-level libraries that don't even have basic transient buffer allocation or caching.
Most high-level gfx APIs don't even get the basics right. Transient staging, sync, cached FBOs/PSOs/descriptor sets, RT support. Instead they enforce invented concepts onto a rock (the GPU), which does not really care how elegant your invented abstraction is. Or they take a "common denominator features of 2006" approach, ending up extremely outdated in 2026. Great if you plan on running your cutting edge graphics project on a knockoff MediaTek phone running Android Kit Kat and about nothing else.
So I wrote one with AI as a statement: someone please write one by hand that's better, not worse.

value: Show HN: Vrhi: AI Slop DX9/DX11-Style Immediate API on Vulkan

author: hypernewbie


value: Hamza-Mos

value:
there's a big narrative in the AI space right now that agents training future generations of models is imminent.
i spent a few weeks testing whether the current generation of models can actually do this.
full breakdown below:
https://hamzamostafa.com/blog/agents-training-their-own-mode...

value: Show HN: I Let AI Agents Train Their Own Models. Here's What Happened

author: Hamza-Mos


value: pramodvoola

value: Agent VCR: record, replay, and diff MCP interactions.

value: Show HN: Agent VCR – Record, replay, and diff MCP server interactions

author: pramodvoola


value:
  I built ShapeGuard because shape errors in numerical code are uniquely painful. They're silent (wrong shapes often produce garbage instead of crashing), late (errors surface deep in XLA,
   not where the bug is), and cryptic (shapes (3,4) and (5,3) not aligned — but why should they match?).

  ShapeGuard lets you declare shape contracts on functions using symbolic dimensions:

  from shapeguard import Dim, expects, ensures

  n, m, k = Dim("n"), Dim("m"), Dim("k")

  @expects(a=(n, m), b=(m, k))
  @ensures(result=(n, k))
  def matmul(a, b):
      return a @ b

  When shapes don't match, the error traces bindings back to their source:

  ShapeGuardError:
    function: matmul
    argument: b
    expected: (m, k)
    actual:   (5, 7)
    reason:   dimension 'm' bound to 4 from a.shape[1], but got 5 from b.shape[0]
    bindings: {n=3 (from a[0]), m=4 (from a[1])}

  The key idea is unification — the same Dim object used across arguments must resolve to the same integer. ShapeGuard tracks where each binding came from, so conflicts pinpoint the exact
  source.

  What it does:

  - @expects / @ensures / @contract — input and output shape validation
  - Symbolic Dim with cross-argument unification
  - Batch() dims and ... ellipsis for ML patterns
  - broadcast_shape() and explain_broadcast() for debugging broadcasting
  - Configurable JIT modes (check / warn / skip) for JAX
  - ML helpers: pre-defined dims (B, T, C, H, W, D), attention_shapes(), conv_output_shape()

  What it doesn't do:

  - No dtype checking (jaxtyping does this well)
  - No named-tensor wrapper (Haliax's approach)
  - Not a replacement for static type checking

  It's zero-dependency, drop-in (works with existing code — just add decorators), and the motivation came from analyzing 40 real JAX GitHub issues where users hit cryptic shape errors.

  PyPI: pip install jax-shapeguard

  Would love feedback on the API design, error message format, and whether this would actually help your workflow. What shape debugging pain points am I missing?

value: Show HN: ShapeGuard – Shape Contracts for NumPy and Jax


value: zimengx

value: made a faster way to type with one finger (STT aside), uses a DTW algo to compute and compare paths. engine written in Rust and compiled to WASM and FFI for mac.

value: Show HN: Physical swipe typing for your computer

author: zimengx


value: boneyao

value:
Hi HN, I built Mission Plus, a small native macOS utility that makes Mission Control easier to read when you have many windows open.
Mission Control is great, but once multiple windows look similar, it becomes hard to identify what’s what at a glance. Mission Plus overlays large text titles and recognizable app logos directly above each window, so you can immediately tell them apart without hunting through thumbnails.
The app is implemented natively with a focus on low overhead and smooth performance. It follows Mission Control animations closely and is designed to look like a built-in macOS feature rather than a third-party overlay.
Key features:
Large, clear text titles above windows
Automatic logo matching for most common macOS apps
Very low resource usage and no noticeable latency
Direct DMG download (no signup, no App Store)
You can download and try it here:
https://trystartup.com/
This is an early version and I’m very interested in feedback, especially from macOS power users. I’ll be around in the comments to answer questions and discuss design or implementation details.

value: Show HN: Mission Plus – Clear Titles and App Logos in macOS Mission Control

author: boneyao


value: Vibe coded this for my Omarchy setup. Would love to share and get thoughts.

value: Show HN: Monitui – drag 'n drop monitor config for hyprland


value: ketutdana

value:
Lately, the internet has started to feel loud, yet incredibly empty. Every time I browse Google, Medium, or news portals, I run into articles that feel "too perfect." The structure is flawless, the grammar is impeccable, but there is absolutely no soul in them.
We all know why. It’s AI.
As a developer, I love technology. But as a human, I’ve started to crave writing that has "scars"—writing that has emotion, rhythm, and is actually born from someone’s messy brain, not a polished prompt.
That’s why I built dwrite.me.
An Internet That’s Too Fast
My frustration is simple: We live in an age where everything is expected to be instant. Need a 2,000-word article? One click. Need an opinion? Ask a chatbot.
But here’s the problem: If everyone is using AI to write, why should we bother reading each other at all? We aren't exchanging thoughts anymore; we are just swapping machine-processed data. Our way of thinking is becoming lazy. We no longer value the "friction" of struggling to find the right words. Yet, that struggle is exactly where our humanity lives.
The Broken Bridge Between Us
I used to read blogs to feel like I was having a conversation with the author. I could feel their anxiety, their excitement, or even their confusion.
Now? That bridge feels broken. AI writing is sterile. There are no surprises, no bold opinions, no "wrong" takes. Everything is safe. I’m worried that if we keep going down this path, we’ll forget how to connect honestly through words. We’re becoming content consumers instead of thought appreciators.
dwrite.me: Back to Basics
I built dwrite.me with a very simple concept. In fact, it might be too simple by today's standards.
No AI, Just Friction:
I want people to feel the effort of typing again. I want there to be a "clash" between the mind and the keyboard.
Pure Minimalism:
No clutter, no distractions. No Copy Paste. It’s just you and your message.
Handcrafted:
Every word typed here is a conscious choice made by a human being.
I don’t expect this platform to compete with the giants like Medium or Substack. Not at all. dwrite.me is just a small space for those who still believe that human thought with all its flaws is infinitely more valuable than a text generated by a thousand servers in a matter of seconds.
If you also feel like the internet is getting drowned in automated "noise," maybe we’re on the same frequency.
Check it out at dwrite.me. Let’s start thinking again, one slow word at a time.
https://dwrite.me
Open for collaboration. Let’s build this together if you have the same vision.

value: Show HN: Dwrite.me A minimalist writing space that blocks copypaste to fight AI

author: ketutdana


value: thesecretceo

value: I didn’t want my home address on every shipping label, so I built  Shipto.me which lets people ship and receive packages without exposing where they live. It works with standard carriers and doesn’t change the delivery experience.

value: Show HN: Ship packages without exposing your real address

author: thesecretceo


value: notamitgamer

value:
I built Githrun to eliminate the need to clone entire repositories just to run a single utility script.
Key Features:
Instant Execution: Run any Python script via its GitHub URL or Gist ID using githrun run [URL].
VS Code Extension: I've added a VS Code extension so you can execute remote scripts directly from your editor.
Local Shims: It creates local shims in your PATH, allowing remote scripts to behave like native CLI tools.
Smart Caching: To avoid GitHub API rate limits, it caches metadata and responses locally.
It’s open-source (MIT) and available on PyPI. I'd love to hear what you think of the VS Code integration!

value: Show HN: Githrun – Run Python Scripts from GitHub URLs and VS Code Extension

author: notamitgamer


value:
Mojic (v2.1.2) is a multi-layered protection tool for C source code that combines obfuscation with a cryptographic engine.
What it does:
Identifier Obfuscation: It renames variables and functions to ambiguous symbols to break static analysis.
CipherEngine: It uses a password-based encryption system (utilizing the Scrypt library for key derivation) to secure the source code artifacts.
Integrity Checks: The tool includes security alerts for "File Tampered" or "Integrity Failure" if the encrypted code is modified.
Web & CLI: It offers a Tailwind-powered web interface for quick use and a CLI for larger projects.
I built this to explore how much "unmaintainability" can be automated to protect intellectual property in C projects. Happy to answer any technical questions about the obfuscation logic!

value: Show HN: Mojic – A C code obfuscator and encryption tool for source protection


value:
Founders often share user and revenue screenshots when building in public.
I found myself spending more time updating screenshots than building.
So I built a small tool that lets you update numbers instantly and generate clean MRR screenshots.
It’s free and very simple.
Would love feedback on what could be improved or what features would be useful.

value: Show HN: Share your MRR in seconds. Stop wasting time on screenshots


value: ctxcode

value: Hello everyone. I want to show you the Valk programming language. It focusses on simplicity and performance. It has a stateful GC, which i think hasn't been done before. I would like your feedback. Note we are still working on more features, it's not the complete/final product. If you like the project, join our discord (link in GitHub).

value: Show HN: Valk programming language with a stateful GC

author: ctxcode


value: Show HN: Klint – Linux Kernel Security Scanner


value: avinshe

value:
npx agentseed init
AGENTS.md (https://agents.md) is a standard file used by AI coding agents to understand a repo
(stack, commands, conventions).
Agentseed generates it directly from the codebase using static analysis.
Optional LLM augmentation is supported by bringing your own API key.
Extracts languages, frameworks, dependencies, build/test commands,
directory structure, and monorepo boundaries.

value: Show HN: Agentseed – Generate Agents.md from a Codebase

author: avinshe


value: neuralweaves

value:
I built a bootable Linux distribution that treats AI as a system primitive – like CPU or memory. Designed for security-conscious environments where data cannot leave the network.
The problem: Most AI requires cloud APIs, which means your data leaves your control. For banks, healthcare, defense, and regulated industries – that's a non-starter.
The solution: EdgeAI-OS runs everything locally. No cloud calls. No API keys. No telemetry. Boot the ISO, use AI. Your data never leaves the machine.
Security features:
- 100% offline operation – air-gap friendly, zero network dependencies
- No external API calls – all inference runs locally on CPU
- Command risk assessment – every command classified as Safe/Moderate/Dangerous
- Dangerous pattern blocking – prevents rm -rf /, curl|bash, fork bombs, etc.
- Open source & auditable – MIT licensed, inspect every line of code
- No data exfiltration – nothing phones home, ever
What's in the ISO:
- Local LLMs (TinyLlama 1.1B + SmolLM 135M) – runs on CPU, no GPU needed
- ai-sh: natural language shell where 80% of queries resolve instantly via templates
- Multi-tier routing: simple queries → fast model, complex → larger model
Example ai-sh session:
what time is it?
[template] date              ← instant, no LLM
files larger than 1gb
[template] find . -size +1G  ← instant, no LLM
rm -rf /
[DANGEROUS]  Blocked        ← security check
configure nginx as reverse proxy
[ai-generated] ...           ← uses local LLM (~1-2s)
Target use cases:
- Air-gapped enterprise environments (banks, healthcare, government)
- Defense & classified networks
- Edge devices with no internet connectivity
- Privacy-conscious developers
- Compliance-heavy industries (HIPAA, GDPR, SOC2)
Built with Rust, based on Debian. 4GB RAM recommended.
GitHub: https://github.com/neuralweaves/edgeai-os
ISO Download: https://github.com/neuralweaves/edgeai-os/releases (1.2GB)
Would love feedback, especially from anyone working in secure/regulated environments. What features would make this enterprise-ready for you?

value: Show HN: EdgeAI-OS – Air-gapped Linux distro where AI is a system primitive

author: neuralweaves


value: edukid

value: Show HN: Safeoid – Turn Messy PDFs into Structured Excel, CSV, or JSON

author: edukid


value: twwch

value:
URL: https://github.com/twwch/next-chat-skills
---
Text (paste into the "text" field):
Hi HN,
I built an open-source AI assistant that can autonomously discover, install, and execute Skills to actually complete tasks for you.
The Problem:
Most AI chatbots today are stuck in "read-only" mode. They can tell you how to do something, but they can't do it. Want to convert a PPTX to PDF? The AI will explain how, but you still have to run the commands yourself.
The Solution:
Next-Chat-Skills is a self-hosted AI assistant with a plugin system called Skills. When you ask the AI to do something it can't handle natively, it:
1. Searches for a relevant Skill (like an app store for AI capabilities)
2. Installs it automatically (npx skills add ...)
3. Executes the Skill's scripts (Python, Node.js, Shell)
4. Streams real-time output back to you in a terminal UI
5. Recovers from errors by installing missing dependencies and retrying
For example:

  User: "Summarize this YouTube video for me"
  AI:   -> Searches for a video-summarizer Skill
        -> Installs it (yt-dlp + Whisper)
        -> Downloads the video, transcribes audio
        -> Returns a structured summary

No manual setup. No copy-pasting commands. The AI handles the entire workflow.
What is a Skill?
A Skill is just a folder with a SKILL.md descriptor and some scripts:

  ~/.agents/skills/video-summarizer/
  ├── SKILL.md              # Metadata + description
  ├── scripts/
  │   ├── download.py       # Download video
  │   ├── transcribe.py     # Whisper transcription
  │   └── summarize.js      # Generate summary
  └── rules/                # Usage guidelines for the AI

Anyone can create and share Skills. The AI reads the SKILL.md to understand when and how to invoke each script. It's composable — the more Skills you add, the more capable your assistant becomes.
Key Features:
- Autonomous Skill discovery & installation — AI finds and installs what it needs
- Real-time script execution — streams terminal output via SSE, supports Python/Node.js/Shell
- File generation & download — scripts can generate files (PPTX, PDF, images) that users can download directly from chat
- Multi-file upload & parsing — supports images, PDF, DOCX, XLSX, PPTX
- Dual database — SQLite (zero-config) or PostgreSQL (production)
- Optional auth — Google OAuth or fingerprint-based, works without login too
- Docker-ready — pre-built image with Python, FFmpeg, LibreOffice, and popular Skills pre-installed
- Works with any OpenAI-compatible API — GPT-4o, Claude (via proxy), local models, etc.
Tech Stack: Next.js 16, React 19, TypeScript, Vercel AI SDK, Tailwind CSS 4, shadcn/ui, Drizzle ORM (SQLite / PostgreSQL), Docker (Node.js 20 + Python 3)
Quick Start:

  # Docker (fastest)
  docker run -p 3000:3000 \
    -e OPENAI_API_KEY=sk-xxx \
    -e OPENAI_BASE_URL=https://api.openai.com/v1 \
    twwch/next-chat-skills:latest

  # Or from source
  git clone https://github.com/twwch/next-chat-skills
  cd next-chat-skills
  npm install && npm run dev

Why I Built This:
I got tired of AI assistants that stop at "here's a code snippet." I wanted an AI that could actually run the code, handle failures, install dependencies, and deliver the final result — like having a junior developer who can use any Skill you point them at.
The Skills system makes this extensible without modifying the core app. Anyone can package a workflow as a Skill and share it.
What's Next:
- Skill marketplace / registry for community sharing
- Multi-step workflow chaining (Skill A output -> Skill B input)
- Better sandboxing for script execution
- MCP (Model Context Protocol) integration
I'd love to hear your feedback. What Skills would you want to see? What's missing?
GitHub: https://github.com/twwch/next-chat-skills
License: Apache 2.0

value: Show HN: Give Your AI the Ability to Find, Install, and Use Skill Autonomously

author: twwch


value: cc-magus

value:
Write with rust, very simple.
github:https://github.com/minxuanz/noveltui
It only supports TXT files.
The bookmark feature is implemented by inserting a symbol at the end of a line and saving it. Every time you exit, the current line will be marked with the bookmark symbol, and the next time you open the file, it will jump to the last bookmarked position. This way, it remembers your reading position, so it’s best to back up the original file.
It also supports custom regular expressions to split chapters and generate a table of contents, automatic reading , and multiple themes.
It works on Linux, macOS, and Windows. It’s just for fun.

value: Show HN: Terminal txt novel reader support bookmark and pagination

author: cc-magus


value: TomoyaFujita

value:
The idea is simple: pipe your command through logifai, and Claude Code can search your logs directly.
npm run dev 2>&1 | logifai
Hit an error → just ask Claude "what went wrong?"
It captures everything into structured NDJSON, has a Web UI with live streaming, auto-redacts secrets, and includes a Claude Code Skill so Claude can search your logs without you ever copy-pasting terminal output.
It also has a Log Reference feature — select lines in the Web UI, click "Copy Ref", paste a compact logifai:// URI into Claude instead of hundreds of log lines. Keeps your context window clean.
It solves what I found to be the biggest pain point: the manual copy-paste shuttle between terminal and Claude Code.
Feedback and contributions welcome!
https://github.com/tomoyaf/logifai

value: Show HN: Logifai – Auto-capture dev logs for AI coding assistants

author: TomoyaFujita


value: arustagi

value:
I built MCPlexor to solve a token waste problem I kept running into with MCP-based agents.
The Problem:
MCP (Model Context Protocol) is great for giving LLMs access to external tools. But if you connect multiple servers (GitHub, Linear, Postgres, Slack), you end up with 40-50k tokens of tool definitions injected into every request – before the agent even does anything.
On a 200k context model, that's 25% gone. On smaller models, it's worse. And most runs only use 1-2 tools.
The Solution:
MCPlexor sits between your agent and your MCP servers. Instead of loading all tool definitions upfront:
Agent asks for a capability ("create an issue")
MCPlexor routes to the right server using semantic matching
Only relevant tools get exposed
Result: ~500 tokens overhead instead of ~20k.
Technical Details:
- Written in Go, single binary, no runtime deps
- Supports both stdio and HTTP transports
- Stores credentials in OS keychain (macOS Keychain, Windows Credential Manager, Linux keyring via zalando/go-keyring)
- Works with Claude Desktop, Cursor, Augment Code, or any MCP-compatible client
The routing logic can run entirely locally using Ollama. No API calls, no cost, works offline.
Business Model (for transparency):
- Local/Ollama users: completely free
- Cloud tier (on waitlist): we run inference on efficient small models instead of Opus/Pro, pass on savings, take a margin
The bet is that routing is a narrow enough task that a fine-tuned 7B model does it as well as a frontier model. Early testing suggests this works.
CLI uploads: https://github.com/arustagi101/mcplexor
Install: `curl -fsSL <a href="https://mcplexor.com/install.sh" rel="nofollow">https://mcplexor.com/install.sh</a> | bash`
Happy to answer questions about the architecture, the routing approach, or anything else.

value: Show HN: MCPlexor – MCP multiplexer that cuts agent context usage by 95%

author: arustagi


value: moimaere

value:
Hi HN, the creator of MemeOS here.
I built MemeOS because I was tired of the current state of meme generators. Most existing mobile apps / websites are either riddled with ads, have outdated templates, or are just simple image captioners without real editing power.
MemeOS is a native iOS app designed to treat memes as a serious medium. I wanted to build something that feels like a "pro" tool but for something as fun as memes.
Key Features:
AI Meme Maker: I built an agentic workflow using Supabase Vector Search. You can describe a situation or feeling, and my "Meme Maker Agent" (yes, I really built a meme agent!) will find relevant templates and suggest captions.
Professional Editor: Layer-based editing, and precise text controls. It feels more like a mini-Photoshop for memes than a simple captioner.
Meme Lore: Every meme has an origin story. I use AI to research and write the history ("lore") of each template, so you know exactly where it came from and how to use it correctly.
The Tech Stack:
Backend: Supabase (PostgreSQL).
Frontend: SwiftUI (100% native iOS).
AI/Search: Supabase Vector for semantic search of templates and RAG for the "Lore" generation.
Edge Functions: Deno runtime for the heavy lifting of AI coordination.
The app is free to try. I monetize through a separate subscription for power users (AI tools, premium assets, watermark removal), but the detailed Meme Lore and the core editor are accessible to everyone.
You can check it out here:
Website: https://memeos.app
Download (iOS): https://memeos.app/download
I’d love to hear your feedback on the editing feel. I am actively tweaking the vector search weights, so any examples where the AI "missed" the vibe would be super helpful!

value: Show HN: MemeOS – The Ultimate Meme Operating System (iOS)

author: moimaere


value: maksim-pokhiliy

value:
I built Invox because every invoicing tool I tried was either bloated, expensive, or wanted to own my data.
It does what freelancers actually need: create invoices, send them via email, track when clients open them, set up recurring billing, and get automated payment reminders. No accounting features, no payment processor lock-in.
Tech stack: Next.js 16 (App Router), MUI 7, Prisma, PostgreSQL, Zod 4, React Query. Feature-Sliced Design architecture. TypeScript strict mode throughout.
Self-host with Docker in 3 commands:
git clone https://github.com/maksim-pokhiliy/invox.git
cd invox
docker compose up
Live demo: https://invox-green.vercel.app
MIT licensed. Looking for feedback on the UX and what features freelancers actually want next.

value: Show HN: Invox – Open-source self-hosted invoicing for freelancers

author: maksim-pokhiliy


value: novelica

value:
Hey HN,
I built a managed platform for OpenClaw (the open-source AI agent framework) and shipped the whole thing in a day. Then I open-sourced the platform itself.
The problem: Running your own AI agent means a Mac Mini in your closet, praying your wifi holds, and becoming a part-time sysadmin. Most people give up before they start.
The solution: 3 steps, 5 minutes, done.
1. Sign up
2. Paste your Anthropic API key + Telegram bot token
3. Hit launch
You watch your agent boot in real-time. When it hits "Ready," it's live on Telegram - running 24/7 without your laptop open.
What actually happens when you hit Launch:
- ECS Fargate spins up an isolated container (FARGATE_SPOT, 2 vCPU/4 GB)
- Your API keys are pulled from AWS SSM Parameter Store (SecureString), encrypted at rest and never stored in our database
- Each container gets its own ENI with an egress-only security group - no inbound ports, the agent initiates all connections
- A background process patches the OpenClaw config for Telegram DM access
- CloudWatch logs stream back to the dashboard, parsed into setup phases: provisioning -> configuring -> health check -> nginx -> gateway ready
- Supabase Realtime pushes updates to the browser in real-time (3s polling during setup)
Stack: Next.js, Stytch B2B auth, Supabase (Postgres + Realtime), AWS ECS Fargate, SSM Parameter Store, CloudWatch, Stripe.
Security model:
- Full container isolation — every agent is its own Fargate task, no shared compute
- BYOK — you bring your own Anthropic key, we never see your usage or bill
- Zero inbound ports — egress-only security group
- Secrets encrypted in SSM with per-org/per-instance paths, never persisted to Supabase
- You can inspect every line of code — the entire platform is AGPL-3.0
The agent itself can search the web, read/write files, run shell commands, manage cron jobs, monitor services, send messages - it's a full autonomous assistant. I run one myself that monitors my Sentry errors, checks my analytics, reads my Slack, and flags anything that needs attention. All through Telegram.
Pricing: $49/mo (starter) / $149/mo (pro). Or self-host the whole thing for free - it's all on GitHub.
I'm a solo developer. This is the entire platform, open source, built in a day on top of the existing OpenClaw OSS project.
Oh, and autoscale is on. ;)
business.molinar.ai
GitHub: https://github.com/Molinar-AI/openclaw-business

value: Show HN: Molinar – Open-source alternative to ai.com (AGPL-3.0)

author: novelica


value: onesandofgrain

value: I've always wanted to follow podcast guests across      shows, not subscribe to entire podcasts. Most of the time the podcasts host guests which I don't really care about.<p>When a guest you follow appears on a random podcast, they will appear as a new entry in the rss-feed for that particular guest. Hopefully some here will find that useful :D

value: Show HN: I built RSS feeds for podcast guests, not podcasts

author: onesandofgrain


value: amiralul

value:
In TILES, each note (or tile, if you will) is a single plaintext paragraph stored in its own .org file, organized through tags and bold keywords. TILES tries to keep it simple: there is no note title (to reduce friction when creating a note, and honestly a note title is not something I find very useful anyway), there are no dependencies (except for Emacs, version 27.1 at least), no links between notes, no backlinks, no graphs, and no database; every note is a paragraph in its own plaintext file.<p>Other notable features are:
- a dashboard offering a quick glance and a preview of your notes;
- note stitching (borrowed from Howm) and the possibility to get note content by using Dynamic Blocks in Org Mode (borrowed from Denote);
- tags are mandatory and used for hierarchy;
- keywords are optional and automatically extracted from bolded content inside the notes;
- search is performed exclusively on tags and/or keywords;
- subnotes (or undertiles, if you will), a kind of meta-content (or private content) inside a note, which is a paragraph prefixed with '&&' hidden everywhere except in expanded view in the dashboard and, of course, in the note editing buffer (it's not exported trough Dynamic Blocks actions, nor through stitching);
- color coding in the dashboard, depending on the note's age.

value: Show HN: Tiles – yet another Emacs package for note-taking

author: amiralul


value: msakai

value: CPL is a programming language based on category theory, originally designed by Tatsuya Hagino in his 1987 PhD thesis at the University of Edinburgh. It has no built-in data types — products, coproducts, natural numbers, and even exponentials (function space) are all defined by the user using F,G-dialgebras.<p>In this release, CPL now runs in your browser via WebAssembly with no installation required. I've also added tutorials in both English and Japanese.

value: Show HN: CPL – A categorical programming language that runs in the browser

author: msakai


value: roschdal

value: Show HN: Freeciv 3D with hex map tiles and WebGPU renderer

author: roschdal


value:
I built a 2D N-body simulator to explore the hypothesis that our
universe exists inside a black hole. The code simulates gravitational
dynamics within a membrane boundary (event horizon analog), tracks
atmospheric evolution, and models dark energy as external mass injection.
After 2000 epochs: 2.7% of bodies developed breathable atmospheres.
The code is MIT-licensed and needs GPU acceleration / 3D extension.
Looking for collaborators with computational resources.
GitHub: https://github.com/pongtse822-rgb/V6-Black-Hole-Universe
Would love feedback on the physics assumptions!

value: Show HN: Black Hole Universe Simulator (seeking collaborators)


value: Divyeshhn

value: Show HN: Auto Formatting PDF generator web tool for Travelers

author: Divyeshhn


value: vipdestiny

value:
I've been using Claude Code, Codex CLI, and Gemini CLI on the same projects. They're each great alone but running them concurrently is chaos: merge conflicts from simultaneous edits, decisions made in one context lost to another, and slow architectural drift as each agent optimizes locally without a shared plan.
Forge is an orchestration layer that sits between AI coding tools and your codebase. It's a single Rust binary (~3 MB, zero runtime deps) that runs as an MCP server over stdio. Any MCP-compatible AI tool can call it.
What it does:
- File locking: When an agent claims a task, Forge locks the target files. Other agents see the lock and work on something else. Conflicts become structurally impossible.
- Knowledge flywheel: Agents call forge_capture_knowledge to store decisions, patterns, and gotchas. Other agents query the store before making decisions. Knowledge compounds across sessions instead of evaporating.
- Drift detection: Sends recent changes + the project spec to an LLM for alignment scoring. Catches "you were supposed to build auth but you're refactoring CSS" before it compounds.
- Governance: 5-dimension health check (tests, security, docs, architecture, git hygiene) that agents and humans can query at any time.
The brain is pluggable: a free heuristic engine (pattern matching, works offline) or an LLM engine (GPT-4.1 by default). Switch with one CLI command.
State is a single JSON file in .forge/ — human-readable, git-trackable, zero operational overhead.
51 tests (30 unit, 9 CLI, 12 MCP protocol), 0 compiler warnings, 0 unsafe blocks.
MIT licensed. Whitepaper with the full architecture: https://nxtg.ai/insights/forge-whitepaper
Happy to answer questions about the Rust implementation, MCP protocol design, or the multi-agent coordination problem in general.

value: Show HN: Forge – 3MB Rust binary that coordinates multi-AI coding agents via MCP

author: vipdestiny


value: arkforge

value:
I'm a solo dev, and I got tired of signing up for monitoring services that require installing agents, browser extensions, or wiring up Slack/PagerDuty just to know if my side project is down.
So I built ArkWatch: a free uptime monitoring API with zero dependencies. No SDK, no npm package, no webhook setup. Just curl + your email.
One command to start monitoring:

  curl -X POST https://watch.arkforge.fr/monitors \
    -H "Content-Type: application/json" \
    -d '{"url":"https://yoursite.com","email":"you@example.com"}'

That's it. Your URL gets checked every 5 minutes. If it goes down, you get an email. No dashboard to check, no account to manage, no vendor lock-in.
It also has an AI layer (Mistral) that summarizes what actually changed on a page – useful for tracking competitor pricing or changelog updates. But the core use case is dead-simple uptime alerts.
Stack: Python/FastAPI, hosted on Hetzner EU. Free tier: 3 URLs, 5-min checks. Paid starts at €9/month for more URLs and faster intervals.
I'd love feedback from HN – especially on what you'd want from a zero-dependency monitoring tool. Try it, break it, tell me what's missing.

value: Show HN: ArkWatch – Uptime monitoring with zero dependencies

author: arkforge


value: jacobsyc

value:
As a developer, I hate writing documentation.
Not because I don't see the value, I do. But because it always falls behind. You ship a feature, update the docs, then three sprints later realize half of it's wrong and nobody bothered to fix it.
So I built BunnyDesk AI to make this less painful.
Here's what it does:
AI that actually reads your docs
Ask "How do I authenticate API requests?" and get an answer pulled from your actual documentation.
Not generic ChatGPT responses—answers based on what you wrote.
Knows when docs go stale
Tag documentation pages with the code files they describe. When those files change in Git, it updates the doc automatically.
You can also add loom video and it'll auto generate docs based on that. Plus, it can add screenshots and am also bringing annotations too. Technical writers would love this as most of them start writing from scratch, but with BunnyDesk you need one TW instead of 3-4.
I'm sure plenty of people here have other documentation pain points. Would love to hear what's broken in your workflow and what would actually help.

value: Show HN: SaaS for making software documentation automatically

author: jacobsyc


value: lorenzkrinner

value:
I know. Another Helpdesk. Who would need that? I‘ll be honest: not everybody. Aidkit (the tool) originated out of a simple need for something simpler & lightweight.
Compared to the gorillas in the room like Front.com or Zoho desk, I did not build it for enterprise but for small software teams of ~1-10 members.
It does everything you need, collecting & managing tickets, and has nothing you don’t like AI responses, big bulky dashboards, or enterprise bloat.
Give it a try if you’re looking for something simple to manage your support.

value: Show HN: Simple Helpdehk tool for small software teams

author: lorenzkrinner


value: deepresearch

value: I've built a CLI tool that stores project management data (issues, milestones, logs) as plain markdown files with YAML frontmatter in a .mdp/ directory. No database, no server, just files on disk that work with git.<p>The main use case is giving AI coding agents a structured way to track their own work. The CLI is fully non-interactive (all input via flags/stdin, JSON output), so agents can create issues, update statuses, log progress, and check milestone completion programmatically.

value: Show HN: Markdown Projects – File based project management for AI agents

author: deepresearch


value: anthonybrooks

value:
Written in Rust! (not really)
I've been using Git for writing recently and was lacking a good UI for editing markdown files when away from the laptop. I created GitWriter to fill that gap.
It's built with Expo and I added caching for offline editing with local sqlite, writing goals and a bunch of other features.
Markdown is having a huge moment thanks to AI and more and more people are starting to see Git is a really solid choice for creative and technical writers.
I've recently launched for iOS and would appreciate feedback!

value: Show HN: GitWriter – mobile Markdown editor for writers

author: anthonybrooks


value: thenextechtrade

value:
I’ve been tracking the latest release from ByteDance, Seedance 2.0, and I’ve integrated it into my platform. Unlike previous models that focus only on pixels, Seedance 2.0 achieves frame-level audio-visual synchronization natively.
Check out the model's capabilities here: https://videomakerai.app/models/seedance-ai
Key Highlights:
12-Way Multimodal Control: Supports multi-image and video references for consistent characters.
Native Audio-Visual Sync: No more "dubbing" after generation; the sound and motion are generated together.
Production Ready: Optimized for dynamic comics and marketing videos with 99%+ success rate.
Would love to hear your thoughts on the consistency of the output!
website: https://videomakerai.app/models/seedance-ai

value: Show HN: Seedance 2.0 – Native audio-visual sync video model

author: thenextechtrade


value: alfredray

value:
We built Pubmed-max to optimize for core clinical evidence density, not just retrieval count.
In a real extraction benchmark:
- Human baseline: physician-curated workbook (MD+PhD profile), ~2-3 days
- Pubmed-max: end-to-end run in ~3m30s
Measured deltas:
- Core non-empty clinical endpoint values: 186 -> 198 (+6.5%)
- Unique trials across task sheets: 23 -> 30 (+30.4%)
- Evidence rows: 94 -> 112 (+19.1%)
- Incremental dynamic evidence quality: 11/11 A-level
- Evidence mapping for non-empty core cells: 100%
- Unresolved extraction conflicts admitted to main tables: 0
This is not a retrieval-only benchmark; it is content extraction with traceability constraints.
Repo and benchmark report are linked in README.

value: Show HN: PubMed-max – a content-first, auditable medical retrieval pipeline

author: alfredray


value: oasadiq

value:
Hi HN,
I'm building Foliobase, a portfolio builder specifically for freelance writers.
The problem: Writers lose clients to other writers with better portfolios. But every solution sucks:
- Squarespace: $300/year, 3 days setup, made for restaurants
- WordPress: 20+ hours learning
- Hiring someone: $500+
My approach: 10-minute setup, writer-focused templates, $0-9/month.
Tech: React, TypeScript, Supabase, Vercel
Currently: 8 waitlist signups, launching in 2 weeks
Live demo: https://foliobase.vercel.app
Would love feedback on:
1. Does the landing page clearly communicate value?
2. Any obvious things I'm missing?
3. Best ways to reach freelance writers at scale?
Thanks!

value: Show HN: Foliobase – Portfolio builder for freelance writers

author: oasadiq


value: Show HN: Moonbuggy, a .NET alloc-free internationalization library


value: jdbohrman

value: Show HN: I built a ledger platform for LLM-enabled teams to track change

author: jdbohrman


value: KhushiMhasange

value: Alchemyst Al is an AI context engine that gives your AI agents persistent memory, business data, and operational context. Launch production-ready Al agents 20x faster with context-aware capabilities that make your Al applications accurate, reliable, and truly intelligent.

value: Show HN: Alchemyst AI – Auditable context layer for your AI agents

author: KhushiMhasange


value:
I tested Claude 3 Haiku on "What is 247 * 18?" across 100 trials.
Pass rate: 70%. 95% CI: 48%-85%. A task any calculator solves 100%
of the time.
This is the core problem with agent evals today: one run tells you
nothing. The same prompt, same model, same tools — different result
every time.
I built agentrial to fix this. It's a pytest-style CLI that runs
your agent N times and gives you:
- Wilson confidence intervals on pass rate
- Step-level failure attribution (Fisher exact test pinpoints which
  tool call or reasoning step diverges between pass/fail runs)
- Real API cost from response metadata
- A GitHub Action that blocks PRs when reliability drops
Usage is minimal — write a YAML config, run "agentrial run":

  pip install agentrial

Tested extensively with LangGraph agents. 100 trials cost $0.06.
MIT licensed, no telemetry, runs locally.
Looking for feedback on what metrics matter most when you're
shipping agents to production.

value: Show HN: Ran an AI agent 100x – pass rate 70%, not 100%


value:
I am working on a tool called MaiMap which combines static code parsing with LLM-based analyses to generate architectural docs and diagrams for microservices.
The link I have posted here is to a demo of what the generated docs look like. My plan is to provide this knowledge to user's LLMs so you can ask it questions about your distributed system. I would also like to have this read documentation and incorporate that into its knowledge base. Any feedback here would be much appreciated - would you like to use a tool like this at your workplace or on a project? What use-cases do have for a tool like this?
This will be a paid-product with a self-hosted option. I have provided more details and some docs at https://maimap.dev/. The code is not currently open-source. I am aiming to release a beta version around April 2026, however it will only support Go-based microservices. Java, Typescript and C# support will be added next.
Thank you!

value: Show HN: Live architecture docs using AST parsing + LLM


value: dawitworku

value:
I built *Fifu (Fetch It For Us)*, a cross-platform *TUI* for downloading YouTube channels and playlists with zero friction.
It’s built with *Textual* + *yt-dlp*, supports *async downloads*, *subtitles*, *audio extraction*, and has *keyboard-first navigation*. Perfect for power users who want to download entire channels or playlists quickly.
*Features:*
*  Multi-threaded downloads (3 at a time)
*  Search channels by popularity
*  Playlist & section downloads
*  Favorites & download history
*  Auto subtitles & audio extraction
*Quick Start:*
```bash
npx fifu-tui
# or via pipx
pipx install git+<a href="https://github.com/Dawaman43/fifu.git" rel="nofollow">https://github.com/Dawaman43/fifu.git</a>
```
*More info & docs:* [https://fifu-docs.vercel.app/](https://fifu-docs.vercel.app/)
Made with  by me, *Dawaman43*

value: Show HN: Fifu – Ultra-Fast Terminal YouTube Downloader

author: dawitworku


value: Show HN: Turn DeFi whitepapers into executable flows for quick validation


value: hugodutka

value: Show HN: Blink – Build custom AI agents in TypeScript for your team

author: hugodutka