value:
As far as I can tell, this paper (in which Einstein solves a decades old question about Crookes Radiometers) has never been available in English!  Einstein’s work became public domain on 1st January 2026, which meant that I could finally release this translation that I did during my PhD in 2019!
I have a blog post that gives a little more context: https://adaptive-machine-patterns.com/blog.html#einstein [alt. link: http://archive.today/381Pl] I am new to blogging, so advice welcome.
The preprint is hosted at CULA repository (many thanks) https://www.repository.cam.ac.uk/handle/1810/398349 and it has a DOI: https://doi.org/10.17863/CAM.127224

value: Show HN: Untranslated Einstein paper available in English for the first time


value: atulyaaj

value: Show HN: Tabric – save tab sessions with notes and restore in one click

author: atulyaaj


value: greenbelt-dev

value: Show HN: FounderCounsel – AI legal doc generator for startups ($19/mo)

author: greenbelt-dev


value:
Most job boards are just aggregators.
They scrape, paste, and forget. I built Oitii to actually analyze the data before showing it to users.
I developed a scoring system (0-100) to filter out low-effort and ghost listings.
1. Hiring Freeze Cross-Check
We verify the company's current financial health against real-time layoff data and hiring freeze trackers before indexing the job. If they just laid off 20% of engineering, we warn you.
2. Smart Salary Synthesis
We never show "Undisclosed." If the DB has gaps, we parse job.title for seniority keywords (e.g., "Staff" vs "Mid-Level") and synthesize high-fidelity estimates based on current market rates.
3. The "Trap" Detector
Our engine flags logical fallacies in the JD. For example, if the Title says "Entry Level" but the Description demands "3+ years of experience," it gets a massive quality penalty.
4. Active Ping & Honeypots. We don't just trust the post. We use proxy applications to track if resumes are actually being opened (pixel tracking). If the "View Rate" is 0% over 2 weeks, the job is marked as dead.
5. The "Growth Signal" Audit (Cross-Platform Fingerprinting). We cross-reference the listing against the company's direct career page and historical aggregator data to catch "investor fluff."
The Logic: We identify jobs that are reposted on aggregators (to look like the company is growing for VCs) but have been removed or never existed on the company's main ATS.
Zombie Detection: If a role has a high repost velocity (e.g., refreshed every 10 days) but no interview movement, it is flagged as a marketing asset, not a job opening.
It’s built with [Python, Next.js, Supabase].
I’d love feedback on the scoring weights.

value: Show HN: Oitii - 10x your job offers

title: Show HN: Oitii - 10x your job offers


value:
Hi HN,
I built Mindweave to solve a problem I kept running into — I'd save bookmarks, notes, and links across different apps, then never find them again when I actually needed them.
Mindweave lets you capture notes, links, and files in one place. The interesting part is what happens after:

  - Semantic search — find content by meaning, not just keywords. "That article about improving deep work" finds it even if those words don't appear in the content. Powered by pgvector cosine similarity on Gemini embeddings.
  - AI auto-tagging — Gemini generates tags on save, so you don't have to organize anything manually.
  - Knowledge Q&A — ask questions about your saved content using RAG. Retrieves relevant pieces, feeds them as context to Gemini, returns a grounded answer.

Stack: Next.js 15 (App Router, Server Actions), PostgreSQL 16 + pgvector, Google Gemini (text-embedding-004, 768d), Drizzle ORM, Auth.js v5, Tailwind/shadcn. Deployed on Cloud Run.

  A few things I found interesting while building this:

  - pgvector inside Postgres is surprisingly capable for this scale. No need for a separate vector DB.
  - The biggest UX challenge was handling edge cases in similarity scores — zero-magnitude embeddings produce NaN from cosine distance, and PostgreSQL treats float8 NaN as greater than all numbers, so they pass through WHERE
  filters silently.

- AI tagging removes more friction than I expected. The difference between "I'll tag this later" and "it's already tagged" is the difference between a system you use and one you abandon.
Live at www.mindweave.space. Source at https://github.com/abhid1234/MindWeave
LinkedIn: https://www.linkedin.com/posts/activity-7428965058388590592-...
Would love feedback, especially on the semantic search UX and the RAG implementation.

value: Show HN: Mindweave – AI-powered personal knowledge hub with semantic search


value: hwspeed

value: Show HN: I track GPU rental prices – same H100 ranges from $0.80 to $3.19/HR

author: hwspeed


value: dvrp

value: Related: Show HN: JeffTube - https://news.ycombinator.com/item?id=47030797

value: Show HN: Jemini – Gemini for the Epstein Files

author: dvrp


value: Shmungus

value:
https://github.com/Mattbusel/Reddit-Options-Trader-ROT-
ICE, the company that owns the NYSE, just started selling "Reddit Signals and Sentiment" to institutional investors. Structured Reddit data for hedge fund money.
I built the same thing in 9 days. 165k lines. 6,916 tests. Zero CodeQL alerts. Yes I used AI to build it. No I'm not sorry about it.

value: Show HN: 165k lines, 9 days, one dev I built what ICE sells to hedge funds

author: Shmungus


value: savesyncgames

value:
My friend and I were playing a co-op game where he was the host. He went to work, I stayed home sick, and I couldn't play our world because the save file lived on his machine. Most solutions are either paying $10/month for a dedicated server or manually zipping and DMing files back and forth.
I built SaveSync to automate this without the subscription model. Instead of building my own cloud backend, I’m leveraging the Steam Workshop API as a private storage layer.
The tool handles the encryption locally before uploading the saves as unlisted Workshop items, so they stay private to you and your friends. For games like Minecraft that aren't natively on Steam, I built a feature that tunnels the connection through Steam's network so friends can join each other as if they were on the same local network.
It’s a one-time purchase because I’m tired of everything being a subscription. I’m curious if anyone here has tried repurposing the Workshop API for data storage like this, or if you’ve run into specific issues with file conflicts in these kinds of sync setups.

value: Show HN: SaveSync – A co-op save sync tool that uses Steam Workshop as a CDN

author: savesyncgames


value: coldsundaynight

value:
Hi HN,
I built Million Dollar Deeds as an experiment in digital ownership.
The idea is simple: anyone can purchase a permanent “lot” on a global visual map of digital real estate. Each purchase generates a unique AI-designed home and an official digital deed recorded in a public registry.
There are only 100,000 lots available, and once sold they cannot be recreated or resold.
I was curious about what true digital permanence might look like outside of domains or NFTs, and wanted to create something accessible and visual rather than speculative.
Would love feedback from the community — especially on the concept, implementation, and potential future directions.

value: Show HN: Million Dollar Deeds – Own permanent digital land

author: coldsundaynight


value: ykdojo

value: Show HN: SafeClaw – a way to manage multiple Claude Code instances in containers

author: ykdojo


value: quroi

value: Wisepanel brings ChatGPT, Claude, Gemini, and Perplexity together in distinct roles. Instead of asking one model and hoping for the best, it assigns each a perspective and lets them interact -- surfacing opportunities, risks, and alternatives you wouldn't get from any single model.<p>Built for founders, developers, investors, and consultants making decisions before commitment. The value isn't comparing outputs side-by-side -- it's the interaction between perspectives.

value: Show HN: Wisepanel – Multi-model AI panel for decision support

author: quroi


value: kolpaque

value:
codex-web-local is a lightweight web interface for the local Codex App Server (the backend used by Codex Desktop, Codex CLI)
The goal is simple: run Codex locally, access it from the browser, and optionally expose it externally via any tunnel. Remote access is password-protected so your local machine stays private.
Looking for feedback from others running local Codex setups

value: Show HN: codex-web-local – web UI for local Codex App Server

author: kolpaque


value: lasgawe

value: Show HN: The Zero-Friction Signup Layer API

author: lasgawe


value: strewberry

value:
Enter any topic and the app generates a structured study path — chapters, steps, and YouTube tutorials for each. You can explore it as an interactive knowledge graph or a step-by-step plan,
and export the tutorials into a YouTube playlist with one click.
No sign-up required to try it.
Stack: Python/FastAPI, OpenAI Responses API (streaming), Cytoscape.js for the graph, vanilla JS, Cloud Run.
Demo: https://www.youtube.com/watch?v=b4hUfTcJdbQ

value: Show HN: AI learning paths with YouTube playlists

author: strewberry


value: iamspathan

value:
Hi HN,
I built llm-authz-audit because I kept seeing the same security issues in LLM-powered applications: API keys hardcoded next to OpenAI calls, FastAPI endpoints serving chat completions with zero auth, user input concatenated straight into prompts, and shared conversation memory with no session isolation.
These aren't hypothetical — they're patterns I found repeatedly across open-source LLM projects and production codebases.
What it does:
It's a static analyzer (think eslint/semgrep but purpose-built for LLM security) that scans Python, JavaScript, and TypeScript codebases for authorization and security gaps. It ships with 13 analyzers and 27 rules covering the OWASP Top 10 for LLM Applications:
- Prompt injection risks (unsanitized input in prompts, missing delimiters)
- Hardcoded API keys (OpenAI, Anthropic, HuggingFace, AWS, generic)
- Unauthenticated LLM endpoints (FastAPI, Flask, Express)
- LangChain/LlamaIndex tools without RBAC
- RAG retrievals without document-level access controls
- Over-permissioned MCP server configs
- Shared conversation memory without user scoping
- Missing rate limiting, audit logging, output filtering
- Credentials forwarded to LLM via prompt templates
Would love feedback from anyone building or securing LLM applications.

value: Show HN: LLM AuthZ Audit – find auth gaps and prompt injection in LLM apps

author: iamspathan


value: anongazelle

value: Show HN: Tanin – TUI Noise Generator

author: anongazelle

title: Show HN: Tanin – TUI Noise Generator


value: agenticmail

value: Show HN: AgenticMail – Email, SMS, and multi-agent coordination for AI agents

author: agenticmail


value: DeclassFile

value: Show HN: Open API for AI agents to search 29k+ declassified docs

author: DeclassFile


value: sokratisv

value:
Hi HN,
I built [Package Name] because I was frustrated with [Specific Problem]. Most existing solutions were either too heavy or didn't support [Specific Feature].
Technically, it works by [briefly explain a cool implementation detail, e.g., using a custom proxy or a specific algorithm]. I've tried to keep the footprint under [Size] and ensured it has zero dependencies.
You can install it via npm install [package-name] or check out the live demo at [Link].
I'd love to hear your thoughts on the [specific technical choice] or any features you think are missing!

value: Show HN: A lightweight library for real-time data visualization

author: sokratisv


value:
Hi HN,
I'm a security engineer with 15+ years in enterprise security. After watching OpenClaw explode to 180K stars while binding to 0.0.0.0 by default, shipping no encryption, and accumulating 512 CVEs — I decided to build what I think a personal AI agent should look like when security comes first.
Gulama is an open-source personal AI agent with 15+ security mechanisms built into the core:
- AES-256-GCM encryption for all credentials and memories (never plaintext)
- Sandboxed execution via bubblewrap/Docker (same sandbox Anthropic uses for Claude Code)
- Ed25519-signed skills (no unsigned code runs — unlike ClawHub's 230+ malicious skills)
- Cedar-inspired policy engine for deterministic authorization
- Canary tokens for prompt injection detection
- Egress filtering + DLP to prevent data exfiltration
- Gateway binds 127.0.0.1 ONLY by default (not 0.0.0.0)
- Cryptographic hash-chain audit trail
Beyond security, it's a full-featured agent:
- 100+ LLM providers via LiteLLM (Anthropic, OpenAI, DeepSeek, Ollama, etc.)
- 19 built-in skills (files, shell, web, browser, email, calendar, GitHub, Notion, Spotify, voice, MCP bridge, and more)
- 10 communication channels (CLI, Telegram, Discord, Slack, WhatsApp, Matrix, Teams, Web UI, Voice Wake)
- Full MCP server + client support
- Multi-agent orchestration with background sub-agents
- RAG-powered memory via ChromaDB
- Self-modifying: the agent writes its own new skills at runtime (sandboxed)
- 5 autonomy levels from "ask before everything" to full autopilot
Install: pip install gulama && gulama setup && gulama chat
Stack: Python 3.12+, FastAPI, LiteLLM, SQLite, ChromaDB, Click
PyPI: https://pypi.org/project/gulama/
Happy to answer any questions about the security architecture or design decisions.

value: Show HN: Gulama – Security-first open-source AI agent (OpenClaw alternative)


value: lucidlogic

value:
Hey HN,

  I built Gauntlet (gauntlet.bet) — a platform where you challenge friends to fitness activities on Strava with real money on the line. Stakes are held in USDC on Base L2, so payouts are instant and transparent. No
   internal ledger — everything is on-chain.

  How it works:
  - Create a challenge (e.g. "Run 10K before March 1st — $25 stake")
  - Invite friends or make it open
  - Everyone stakes USDC via an embedded wallet (Privy)
  - Strava verifies completion automatically
  - Winners split the pot, losers lose their stake

  Tech stack: Laravel 12, React 19, Inertia.js, Tailwind, MySQL. Blockchain side is a Node.js sidecar using viem for USDC transfers on Base. WebSockets via Laravel Reverb for real-time challenge updates.

  Why on-chain? I didn't want to deal with holding user funds or building a ledger. USDC on Base means ~$0.01 transaction fees, near-instant finality, and users can verify everything. The embedded wallet (Privy)
  means nobody needs to know what a wallet is — they just sign in with email or Google.

  What I learned:
  - Nonce management for sequential blockchain transactions is painful — ended up using cache locks to serialize payouts
  - fake() doesn't work in production (learned this the hard way today)
  - Strava's webhook API is solid but their rate limits are aggressive

  Solo project, built over ~2 weeks. Would love feedback on the concept and any thoughts on the staking mechanics.

value: Show HN: Gauntlet–Challenge friends to Strava activities with real money (USDC)

author: lucidlogic


value: sinned

value:
I’ve been experimenting with a simple idea: what if bots had identities and could interact with each other like users?
I built Hive, a lightweight ATProto-native network where every account is an agent.
- Live: https://hive.boats
- Code: https://github.com/embers-workshop/hive
Bots get:
- DID identity
- posts/replies/mentions
- DMs
- a shared directory for discovery
I also built Beekit, a small CLI/SDK to get an OpenClaw bot onto Hive quickly:
- https://github.com/embers-workshop/hive-beekit
It handles scaffolding, login, polling mentions, and registering the bot.
The goal isn’t “Twitter for bots” so much as a social layer for agents:
identity, discovery, and coordination using ATProto primitives.
Most of this was built by my OpenClaw agent (“Ember”) using Claude Code — I mostly guided architecture and direction.
Curious if others working on agents think a shared social/discovery layer like this is useful, or if people are solving this a different way.
To get started, first get your openclaw a bsky.app account, and then point it here: https://hive.boats/skill.md

value: Show HN: Hive: OS Bluesky for Openclaws

author: sinned

title: Show HN: Hive: OS Bluesky for Openclaws


value:
Hey HN,
I'm a big fan of the Postgres ecosystem and the reliability it brings to the TS stack. More often than not, the answer to "should I add another piece of infrastructure?" is "Postgres can already do that."
I’ve been a long-time user of https://timgit.github.io/pg-boss, but I wanted to take the developer experience (DX) a step further for multi-step processes, especially for AI workflows.
I built pg-workflows to provide a fluent API for defining durable background logic. Instead of manually stitching together disparate jobs, you can define your business logic as a clean, type-safe chain.

value: Show HN: Pg-workflows – Lightweight workflows for Node.js using Postgres


value: zero-lab

value: Show HN: FluxDown – Free download manager built with Rust and Flutter

author: zero-lab


value: It is currently in its early development phase. However, the core implementations are ready for testing and ready for feedback but it's not yet feature complete yet.<p>If this fits your workflow, feel free to use it and stress-test it. Questions, suggestions, and contributions are welcome to help make LockFS better.

value: Show HN: LockFS is a flexible file-by-file encryption for secure storage


value: egrigokhan

value: Show HN: chowder.dev is a single API for deploying OpenClaw instances

author: egrigokhan


value: skryl

value:
Hi HN, I ported the Python MLX bindings to Ruby
(https://github.com/ml-explore/mlx).
GitHub: https://github.com/skryl/mlx-ruby
MLX-Ruby is a native C++ extension that wraps the upstream MLX runtime, giving Ruby full access to the array framework, neural network layers, optimizers, and Metal GPU acceleration on Apple silicon.
What’s included:
 ∙Lazy arrays with dynamic graph construction
 ∙Function transforms: grad, value_and_grad, vmap, jvp, vjp, compile
 ∙Full NN module system: Conv2d, Linear, Embedding, Transformer layers, RNNs, etc.
 ∙Optimizers: Adam, AdamW, SGD, and more
 ∙A Ruby DSL for declarative model definition, training loops, and checkpointing
 ∙CPU and Metal GPU support
Working examples (https://github.com/skryl/mlx-ruby-examples):
 ∙LLaMA inference
 ∙Stable Diffusion
 ∙Whisper
 ∙Transformer language model
 ∙LoRA fine-tuning

value: Show HN: MLX-Ruby – Ruby Bindings for Apple's MLX ML Framework

author: skryl


value: northerndev

value:
I got tired of “read later” lists turning into a graveyard, and especially how messy exports are when you want to move notes into Obsidian/Logseq.
So I built Sigilla as a buffer layer: save an article, read it in a clean view, highlight + add notes, then export only the useful parts in a predictable format.
Example export looks like this:
"Article Title"
Saved: 2026-02-16
Tags: research, infra
Highlights
“Quoted highlight…”
“Another highlight…”
Notes
My note linked to highlight 1
Another note
https://www.sigilla.net/
I’d love feedback on the export format/schema design. If you were piping this into your notes, what metadata would you want included by default (frontmatter, author, published date, content hash, etc.)?

value: Show HN: Turning web highlights into deterministic Markdown (Sigilla)

author: northerndev


value: gillesturpin

value: Show HN: The Yatima Scale – Measuring civilizations by depth, not energy

author: gillesturpin


value:
Hi HN,
I built OrgaNice after running into limitations with existing tab managers, especially forced new tab overrides, feature limits, and workflows that didn’t scale well with large numbers of tabs.
Here’s what it currently offers:
Unlimited nested folders, collections, and workspaces
Session history
Vertical tabs via the side panel
Optional new tab override (you can enable or disable it)
JSON export and import
Import from your browser bookmarks
I’m actively improving it and would really appreciate feedback.
Thanks

value: Show HN: A Toby alternative with vertical tabs and no forced new tab override


value: server-lab

value:
I built DoScript, a domain-specific language for file automation. The goal: make scripts readable by anyone.
Design Goal
Instead of:
bashfind . -type f -mtime +30 -exec rm {} \;
Write:
for_each file_in here
    if_older_than {file_name} 30 days
        delete file {file_path}
    end_if
end_for
Trade power for clarity. Optimize for maintenance over terseness.
Key Design Decisions
1. Natural Language Keywords
make folder not mkdir, copy file not cp. Self-documenting.
2. Implicit Metadata
When iterating files, auto-inject: {file_name}, {file_path}, {file_size}, {file_modified}, {file_is_old_days}
for_each file_in "Documents"
    say "{file_name} is {file_size} bytes"
end_for
3. Built-in Time Handling
if_older_than {file_name} 30 days
make folder "backup_{today}"
No date arithmetic needed.
4. Expression Evaluation
Function-based for simplicity:
if greater_than {file_size} 1000000
if and(equals({type}, "pdf"), greater_than({size}, 10000))
Intentionally awkward for complex logic - signals you should use Python.
Implementation
Python interpreter (~2000 LOC)
Recursive descent parser
Context-aware error reporting
Custom exception types with file/line info
Visual Component
Built a browser-based node editor (single HTML file, 1200 LOC). Drag boxes, wire them, generate DoScript code.
Why? Different learning styles, workflow visualization, non-programmer accessibility.
What Worked
Natural syntax is immediately understandable
Metadata injection removes boilerplate
Time handling makes common cases trivial
Visual IDE differentiates from text-only
What Didn't
Complex conditionals get awkward fast
No user-defined functions (only macros)
Limited data structures
Performance not optimized
The Challenge
Built for non-programmers. But they don't hang out on dev forums. Developers say "just use Python" - which misses the point.
How do you market dev tools to non-developers?
Technical Transparency
I designed syntax and architecture. Most Python implementation was AI-assisted (Claude, Copilot). Focus on design, use tools for implementation.
Open Questions
When does a DSL become too limited?
How to market to non-developers?
Type system worth the complexity?
Should DSLs provide escape hatches to host language?
GitHub: https://github.com/TheServer-lab/DoScript
v0.6.5, includes interpreter, visual IDE, VS Code extension, examples.
Built because bash was too cryptic for my friend to organize files. Turns out lots of people have this problem.
Would love feedback from people who've built DSLs or struggled with similar trade-offs.

value: Show HN: DoScript – DSL for file automation with natural language syntax

author: server-lab


value: Show HN: I built a free keyword checker to see if you can rank


value: ilkerozbay

value:
Hey HN! I built Animus Invoice after struggling with invoice compliance as a freelancer in Turkey.
The problem: Most invoice tools are either too complex or don't handle local tax requirements. You waste hours on paperwork instead of actual work.
Animus Invoice handles Turkish e-invoice/e-archive compliance automatically, tracks payments, and keeps you organized.
Currently in beta - would love feedback from freelancers dealing with similar pain points. Free beta access for early users.

value: Show HN: Animus Invoice – Invoice tracking without the busywork

author: ilkerozbay


value: Show HN: Argus – AI code review that doesn't grade its own homework


value: Show HN: VC Scorecard score any startup or company in 60 seconds


value: ekadet

value:
I built an AI agent mode that doesn't just teach you—it forges you into an expert through brutal, tested progression.
*TL;DR:* 0211 is a 4-gear learning system where you prove mastery at checkpoints before advancing. Each gear has RPM thresholds (75% → 80% → 85% → 90%). Fail = stay in gear. No shortcuts to expertise.
---
## The Code
https://github.com/ekadetov/ekadetov.github.io/blob/main/ass...

value: Show HN: 0211 – Go from zero to eleven in any topic with F1-style gear shifting

author: ekadet


value: xuyanmei

value:
Hi HN,
I built AISeedream5 as a lightweight web UI to generate visuals quickly:
- text-to-image
- image-to-image (with a reference image)
- text-to-video / image-to-video (short clips)
The problem I was trying to solve: I often want to iterate on concepts (ad creatives, storyboards, thumbnails) without juggling multiple tools or losing prompt history. So I focused on a straightforward workflow: pick a mode, optionally add a reference image, write a prompt, generate, download.
Notes:
- There’s a small free tier so you can try it without creating a full setup.
- [If applicable: Not affiliated with the Seedream/ByteDance team; this is an independent UI.]
Tech / implementation:
- [Your stack: e.g. Next.js + serverless API + a job queue for renders]
- [Any details HN would care about: latency, caching, safety filters, etc.]
I’d love feedback on:
1) prompt UX (what’s confusing / missing)
2) what “consistency controls” you wish existed
3) bugs / edge cases you hit
Happy to answer questions.

value: Show HN: AISeedream5 – a simple web UI for Seedream 5.0 image

author: xuyanmei


value:
AI agents often generate inconsistent Playwright tests because they do not understand your application’s specific workflows, UI patterns, or constraints.
The Playwright Skill provides more than 70 structured markdown guides that teach patterns for locators, authentication, visual testing, CI configuration, and framework migration so agents can apply consistent solutions instead of guessing.
You install it with: npx skills add testdino-hq/playwright-skill.
The material is organized into five packs: core testing (46 guides), Playwright CLI usage for token‑efficient automation (10), Page Object Model patterns (2), CI/CD setup for major providers (9), and migrations from Cypress or Selenium (2).
Each guide follows the same structure—when to use a pattern, when to avoid it, quick reference code, and complete implementations—so learners can move from concept to reliable tests step by step.
The skill works with tools such as Claude Code, GitHub Copilot, Cursor, and any agent that implements the skills protocol, and it is MIT‑licensed so teams can adapt the content to their own standards and practices.
For a deeper walkthrough of the guides and structure, see the full article at https://testdino.com/blog/playwright-skill/.

value: Show HN: Train AI Agents to Write Better Playwright Tests


value: UnclonedMath

value:
Dominake = dominoes + snake. Divide a number grid into domino pairs, then link them into a continuous chain where touching ends match.
Under the hood it's two classic problems at once: a Hamiltonian path covers every cell, while the domino chain forms an Eulerian path in the complete graph Kₙ. For 5×6, K₆ has all vertices of odd degree — violating the Euler condition. The grid simply can't exist.
Valid sizes: 4×5 (K₅), 6×7 (K₇), 8×9 (K₉). Three difficulty levels controlled by "traps" — false matches that look right but break the chain. Chain mode gives an open snake; Loop mode closes it into an Eulerian circuit.
Hold any domino to preview where it can go (green/blue/red for free/partial/blocked). Animated snake on solve.
Single HTML file, no frameworks, no backend, no ads. Built with Claude as a co-pilot.
https://constarik.github.io/Dominake/
More original game mechanics (slots, arcades, puzzles): https://constarik.github.io/UnclonedMath/

value: Show HN: Dominake – A domino puzzle where 5×6 grids are impossible

author: UnclonedMath


value: ekremkrc

value:
  We rebuilt FloodIt, an open-source browser puzzle game inspired by Flood-It[0].

  It includes:

  - Classic mode (fill the board with one color)
  - Maze mode (flood through corridors to reach the goal tile)
  - Presets + custom game setup

  Live demo: https://floodit-js.vercel.app
  Source code: https://github.com/ekremkaraca/floodit-js

  We started it as a React.js implementation[1] using TailwindCSS & Vite but gradually removed them to use custom css & Bun's own runtime thanks to Windsurf IDE & OpenAI Codex. There's also Sveltekit implementation we're working on [2].

  We’d love feedback on gameplay balance (move limits/difficulty), UX, and code structure.

  [0]: https://github.com/tfuxu/floodit
  [1]: https://github.com/ekremkaraca/floodit-react
  [2]: https://github.com/ekremkaraca/floodit-sveltekit

value: Show HN: We rebuilt Flood-It in Bun/vanilla JavaScript, and added a Maze mode

author: ekremkrc


value: mupengism

value: Show HN: OpenClaw – An OS for AI agents that do work

author: mupengism


value:
*tl;dr:* I built an upgrade skill for OpenCode that handles the entire update workflow—from refreshing Homebrew to verifying the new version—in one command.
Usage;
Just ask Claude in OpenCode:
"Upgrade OpenCode"
"Update OpenCode to the latest version"
"Check for OpenCode updates"
https://ekadetov.github.io/2026/02/16/opencode-upgrade-skill...

value: Show HN: OpenCode Upgrade Skill: Automating Updates


value: ChilinAI

value:
Hi HN,
I’m a full-stack developer and I built a small tool that I now use every day.
Claude Code from Anthropic is a very capable AI coding assistant, but it only runs locally on your computer. That means if you’re away from your desk — commuting, walking, or just on the couch — you can’t easily give it tasks.
I wanted a simple way to send commands to Claude Code running on my home Mac from anywhere.
So I built Claude Remote — a free, open-source app that lets you control Claude Code through a browser.
How it works
Install a lightweight macOS app (menu bar app, ~5 MB, Apple Silicon).
Open a web chat from your phone or any device.
Send a task — Claude Code executes it locally on your Mac and returns the result.
The Mac app acts as a bridge between the browser and Claude Code. All execution happens locally on your machine.
What I use it for
Fixing bugs or generating small features in side projects
Creating or editing landing pages
Checking or organizing files
Running scripts
Opening websites in Chrome and interacting with them
Summarizing or generating content
Preparing quick reports
Claude Code can control Chrome (open pages, read content, fill forms, take screenshots), so you can automate simple browser tasks remotely.
Responses are returned as formatted markdown. I also added optional text-to-speech playback, which makes it usable while driving.
Privacy & security
Open source (GitHub link below)
No subscriptions
Firebase Auth (each user only sees their own sessions)
All AI execution happens on your machine
This is currently macOS (Apple Silicon) only.
I’d really appreciate feedback — especially on security, architecture, and potential edge cases.
Website: https://clauderemote.web.app
GitHub: https://github.com/ChilinAI/claude-remote
Thanks!

value: Show HN: Claude Remote – control Claude Code on your Mac from your phone

author: ChilinAI


value: reeeeee

value:
Hi HN! I built WebMex (https://webmex.app), a small tool that lets you split your browser into resizable tiles and load multiple webpages side-by-side — sort of a “multiplexer” for the web.
A few specifics:
---
- No login, no backend.
- Layouts are saved locally (in localstorage) under a unique name.
- You can re-open a saved layout via a URL, but it only works on your machine because nothing is stored or synced anywhere.
Why I built it: I kept ending up with messy window arrangements whenever I was researching or building something (docs + issues + dashboards + a couple reference tabs). I wanted a single workspace per project I could set up once and return to.
Why I’m posting: I’m not sure if this is still viable long-term. A growing part of the web blocks being embedded in iframes, which limits what you can actually tile inside a page. For sites that do allow embedding, it’s handy; for others, it’s a dead end.
So I’d love feedback on two questions:
- Do you see value in a tool like this at all? What workflows would you use it for?
- If yes: would you use an open-source browser extension that can tile real tabs/pages and avoid the iframe limitation, like the goal of this app?
Any thoughts on must-have features (keyboard shortcuts, layout sharing, presets, etc.) are welcome. I’m happy to build in the direction that’s actually useful.

value: Show HN: WebMex – tmux-style tiling for the web

author: reeeeee


value: lnalx

value:
This experimental project transcribes and translates speech in real time using Mistral's new Voxtral realtime API and DeepL (https://huggingface.co/mistralai/Voxtral-Mini-4B-Realtime-26...)
It currently supports 11 languages: French, English, Chinese, Spanish, Portuguese, Russian, German, Japanese, Korean, Italian, and Dutch.
You can test on https://live-translation.alexandrelion.com/ by bringing your own API keys (Mistral + DeepL free tier)
GitHub: https://github.com/alxlion/voxtral-live-translation

value: Show HN: Live Translation with Voxtral Mini Realtime and DeepL

author: lnalx


value: jatinkrmalik

value:
Show HN: Vocalinux – 100% offline voice typing for Linux
I built this because I wanted voice dictation without sending my voice
data to cloud services.
Vocalinux is a privacy-focused, open-source dictation tool that runs
entirely on your Linux machine:
- Local speech recognition (whisper.cpp, VOSK, or OpenAI Whisper)
- Works offline, no network required
- Universal compatibility (X11/Wayland, any app)
- Voice commands: "period", "delete that", "new line"
Installation: one-line curl command with auto-detection for GPU/CPU
GitHub: https://github.com/jatinkrmalik/vocalinux
Questions and feedback welcome!

value: Show HN: Vocalinux // 100% offline voice typing for Linux

author: jatinkrmalik


value: Yaramsa-Gautham

value:
Hey HN!
I spent way too much time manually searching Reddit for mentions of problems my SaaS solved. I'd search keywords daily, miss conversations by hours, and get buried when I finally showed up.
So I built Upvotics to automate the listening part. It monitors subreddits for keywords, tracks mentions as they happen, and surfaces conversations where people are already asking for what you're building.
What it does:
- Real-time keyword tracking across subreddits
- User/subreddit engagement analytics (karma, post frequency, sentiment)
- Rule checker (catches common removal triggers before you post)
- Browser extension for contextual insights while browsing
What makes it different from Reddit search:
- Tracks over time (not just one-off searches)
- Browser extension for easy access without switching tabs
- Surfaces intent signals (people asking questions, complaining about competitors)
- Helps you engage naturally instead of spamming links
It's early. Just launched yesterday, already have 5 trial users. Would love feedback on what feels useful vs unnecessary, especially if you've tried similar tools.
Link: upvotics.com

value: Show HN: Upvotics – Track Reddit conversations where people need your product

author: Yaramsa-Gautham


value: jorgtron

value:
The problem: When vibe coding web apps and pages, I noticed I spent a lot of time giving Claude context about the UI changes I want to make.
For example, I would have to write things like "change the text below the login form at localhost:3000/dashboard to say X instead of Y, but only on the mobile version" to keep it from changing the wrong thing in the wrong way.
So I've built Chisel for Claude to solve this, and it works!
Now I just select the element I want to change using the Chisel Chrome  extension, say the thing I want to change: "change this to Y" and say a "send phrase" (I use "Chisel", but you can choose your own) and it will send the instruction to Claude and start making the change completely hands free.
For me it's sped up my workflow by at least 2X. It let's me work primarily in the browser and remain in a creative flow state.
More benefits:
- 20+ languages supported
- Start recording on clicking elements (optional)
- Choose your own send and cancel phrases
Any feedback is welcome :)
Happy Chiseling!

value: Show HN: Chisel for Claude. Vibe code 2X faster using your voice

author: jorgtron


value: rajish

value:
I built a menu-bar utility for Claude Code users who want to view their remaining token headroom without checking the web dashboard. It polls the Anthropic usage API (not the chat API, so no tokens are spent) and displays your remaining capacity with burn-rate indicators.

  v1.3 adds dollar-based subscription tracking: see what percentage of your monthly subscription you've actually used, track extra usage spend in real time, and get tier recommendations based on your usage patterns (overpaying? underpowered? forgotten subscription?). All computed locally — nothing leaves your machine.

  Zero config — reads OAuth credentials directly from macOS Keychain (from your existing Claude Code login). Pure Swift/SwiftUI, no dependencies.

  Install: brew install rajish/tap/cc-hdrm

value: Show HN: cc-hdrm v1.3 – macOS menu bar app that tracks your Claude subscription

author: rajish


value: bialamusic

value: Show HN: OneManBSD– An offline-rebuildable OpenBSD system with source in the ISO

author: bialamusic


value: tomleelive

value: Show HN: ClawSouls – Open registry of shareable personas for AI agents

author: tomleelive


value: mootoday

value:
Hi,
https://seaquel.app/learn-sql is an interactive SQL tutorial with a visual query builder.
JOINs, CTEs, subqueries can be difficult to understand. With the visual builder and SQL editor side-by-side, I hope these concepts are easier to understand.
FWIW, the tutorial is part of Seaquel, the SQL client I've always wished I had. I showed that to HN a few weeks ago.
Curious to hear what you think of the tutorial.
Thanks

value: Show HN: Interactive SQL Tutorial with a visual query builder

author: mootoday


value:
Hey HN,
I built Rivestack because managed PostgreSQL with pgvector is either expensive (AWS, GCP) or shared resources (Neon, Supabase free tiers).
What it does:
- Dedicated PostgreSQL with pgvector pre-installed
- Automated backups, monitoring, HA
- EU and US-East regions
- Free tier for testing
Benchmarks on the $29 tier:
- 10k vectors: 2,000 QPS, <4ms latency
- 1M vectors: 252 QPS, 32ms latency, 98% recall
Stack: Hetzner infrastructure, Patroni for HA, pgBackRest for backups.
Would love feedback from anyone building RAG or semantic search. Happy to answer questions!

value: Show HN: Rivestack – Managed PostgreSQL with pgvector, $29/mo


value: ranbo

value: Show HN: VPS-Harden, an Idempotent Bash Script to Harden Ubuntu VPS

author: ranbo


value: WolfOliver

value: Show HN: I've build a self hosted convex/Firebase/Supabase alternative

author: WolfOliver


value: agamrafaeli

value:
"When perception shifts, and the feeling of control takes over")
I wrote up a deep dive into a security issue in OpenClaw that escalates from a seemingly small UX/trust boundary problem into full remote code execution via a single malicious link.
The article walks through the full exploit chain from a systems perspective rather than just a CVE summary. The key theme is what I call “synesthetic computation”: when subjective context, UI state, agent memory, and system permissions get blended together in ways that feel natural to users but collapse important security boundaries. When an agent is allowed to act across chat, browser, and local tooling, those boundaries become part of the attack surface.
In this case, a crafted link can cause a client to connect to an attacker-controlled gateway, leak a token, and then allow that attacker to reconfigure the agent’s execution environment and run arbitrary commands on the host. The interesting part isn’t just the bug—it’s how quickly convenience-driven design patterns in local AI agents can produce “god-mode” blast radius when trust is mis-scoped.
The write-up focuses on:
– how local agents collapse UI + infra trust layers
– why “runs locally” doesn’t automatically mean “safe”
– how agent autonomy changes the RCE threat model
– what defensive patterns might look like for agent platforms
Curious how others are thinking about the security model for local autonomous agents and whether we need new mental models beyond traditional sandboxing and token scoping.

value: Show HN: Synesthetic Computation

author: agamrafaeli

title: Show HN: Synesthetic Computation


value: uroni

value:
HS5 ([website](https://hs5.eu) | [GitHub](https://github.com/uroni/hs5)) is a high-performance scale-up self-hosted S3 compatible object storage server. It is ideal for use cases where single-node scaling, performance, and data-loss risk are acceptable, or as a building block for more robust systems. For example use cases might be local testing environments or temporary storage for data processing workflows.
HS5 features a web interface for managing buckets and users.
License: LGPLv3+
I was previously using MinIO for my single node object storage needs, but it did not scale well with many objects since it creates multiple files for each object. Now it does not aim to solve the single-node use case anymore anyway and is unmaintained as well.
Some technical details: It is written in C++ since I already had an implementation of the main object storage from another project ( SingleFileStorage.cpp ). For the main object to disk location mapping it uses LMDB (a copy-on-write memory mapped database). Once the database memory is mapped, the mapping operations run at in-memory database speeds. The copy-on-write makes writing (small) changes slower. To mitigate this there is an optional WAL mode, where changes are committed to a WAL, then asynchronously committed to the LMDB. Alternatively there is a manual commit mode where commit is done via writing to a special object. Using this might be interesting for bulk-loading or for testing use cases.

value: Show HN: HS5 – Open Source fast single-node S3 compatible object storage

author: uroni


value: chadbyte

value:
I built a local relay server that puts Claude Code in your browser.
No signup, no install, no cloud. Just "npx claude-relay".
The problem: Claude Code runs in the terminal. When it needs approval for a command, you have to be staring at that terminal. Walk away for coffee, and it sits there waiting.
claude-relay runs a local WebSocket server that streams Claude Code's output to a browser tab. When approval is needed, you get a push notification on your phone. Tap to approve or deny.
Technical choices:
Built on Anthropic's Agent SDK (TypeScript)
WebSocket streaming, not polling
Web Push API for mobile notifications (no app install)
Everything runs locally — no data leaves your machine
PIN-based auth for the web UI
It also supports multiple sessions (one per git worktree), so you can run parallel Claude Code instances from one dashboard.
Setup: npx claude-relay

value: Show HN: Claude Relay – Web UI for Claude Code, zero install, push notifications

author: chadbyte


value: FrankTheBear

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

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

author: FrankTheBear


value: madugula

value:
The Agentic Shift: Peter Steinberger Joins OpenAI to Scale OpenClaw
By Sai Srikanth Madugula, PhD Research Scholar & Product Manager | February 16, 2026
In a move that signals the definitive start of the "Agentic Era," Peter Steinberger, the architect behind the viral open-source framework OpenClaw, has officially joined OpenAI. This transition isn't just a high-profile hire; it represents a fundamental change in how the industry views the intersection of proprietary intelligence and open-source orchestration.
As I continue my PhD research into AI-Blockchain models, I view this as a seminal moment. We are moving away from simple chatbots toward autonomous "workers" that can interact, reason, and execute. Steinberger’s integration into OpenAI provides the missing bridge between world-class models and real-world execution frameworks.
In the Words of Sam Altman
Sam Altman, CEO of OpenAI, took to X (formerly Twitter) to welcome Steinberger and clarify the future of the framework. His statement highlights a newfound commitment to the open-source community as part of OpenAI's core product strategy:
"Peter Steinberger is joining OpenAI to drive the next generation of personal agents. He is a genius with a lot of amazing ideas about the future of very smart agents interacting with each other to do very useful things for people... OpenClaw will live in a foundation as an open source project that OpenAI will continue to support."
Altman’s vision of a "multi-agent" future confirms what many of us in product management have suspected: the next billion-dollar startups won't be built on a single LLM, but on the orchestration of many specialized agents working in concert.
Why This Matters: The OpenClaw Foundation
The decision to house OpenClaw in an independent open-source foundation while receiving OpenAI’s backing is a strategic masterstroke. It ensures that the framework remains a neutral ground for developers while benefiting from the massive compute and research resources of OpenAI. This helps solve several critical bottlenecks:
Interoperability: By standardizing how agents talk to each other, OpenClaw can become the "HTTP of AI," allowing different models to collaborate seamlessly.
Reduced Friction: Developers can leverage pre-built "agent personas" (like the AI Engineer or AI Researcher) without reinventing the orchestration logic every time.
Trust and Transparency: Keeping the foundation open-source helps demystify the "black box" of agentic decision-making, an area I am particularly focused on in my doctoral studies.
A Catalyst for Solo Founders and Nano-Startups
For the solo founder, this news is transformative. When the creator of the most robust orchestration tool joins forces with the creator of the world's most capable models, the barriers to entry collapse. We are entering a phase where a single human can manage a "digital corporation."
The implications for latency and data privacy are also significant. As OpenAI supports the foundation, we can expect more optimizations for on-device and edge-native agents—a direction I recently analyzed through the lens of Karpathy’s MicroGPT. Small, fast, and local agents are the future, and OpenClaw is the engine that will run them.
The Human in the Loop: The Conductor Role
Does this mean human roles are disappearing? Quite the opposite. As I’ve argued in previous posts, our role is evolving into that of a Strategic Conductor. Peter Steinberger's move to OpenAI suggests that the industry is ready to provide us with a much more powerful orchestra. Our value now lies in the vision we set and the ethical guardrails we implement.
The workplace of tomorrow is no longer a collection of desks; it is a symphony of digital intelligence, and the baton is firmly in our hands.

value: Show HN: Agentic Shift: Peter Steinberger Joins OpenAI

author: madugula


value: parsabg

value:
hey HN, happy Monday!
I got sick of receiving personal messages that were clearly written by AI, so I vibe-coded a pastebin-like service that allows authors to electively prove they wrote something themselves.
how it works:
- typing rhythm analysis: analyzing your keystroke patterns to measure how human-like they are, based on rhythm, speed, variance, etc.
- audio verification: optionally, corroborating the audio from your microphone with your keystrokes as you type, to get an "audio verification" badge.
in an increasingly AI-generated world, I think it's very important for us humans to be able to prove to each other that we actually wrote a piece of text ourselves. this is especially true for personal messaging and social media IMHO.
so perhaps this type of physics-level verification needs to be built into our phones and browsers, not just for text, but also images, video, and audio. would love to hear this community's thoughts on this topic.
note: this doesn't really prove that something wasn't written by AI. the idea is to raise the bar sufficiently to reduce the likelihood of something being AI written, and leave it to authors to decide how far they wish to go to prove to their audience that they did in fact write something themselves.
- try it out: https://www.droptheslop.ai/
- demo: https://youtu.be/MEgo8xQNbdY?si=3cLc1xJ93XG_YDUj
- verification for this post: https://www.droptheslop.ai/d/lMd7xoYx

value: Show HN: Droptheslop.ai – pastebin alternative with human typing verification

author: parsabg


value: elayabharath

value:
Fun little side project I built after learning about circuit bending in cameras for intentional glitch effect. It is browser based camera toy where you "rewire" CCD pin pairs, turn knobs to get different glitch artefacts in real time to capture as photos. I had fun learning to simulate different pin modes - channel split, hue/phase shifts, horizontal clock delays, colour kill etc.
Here are some photos taken: https://glitchycam.com/gallery
I intentionally leaned towards skeuomorphic design for nostalgia. I miss the days where I'd spend hours making a button to look like a physical button. Here I chose to make it look like a "good enough" Teenage Engineering device UI.
I tested/used GPT-5.3-Codex to build this from scratch, since there was a lot of hype around it on X. Maybe I wasn’t using it right, but I found it needed a lot of code cleanup at every step and a lot of hand holding along the way. It missed details/nuances and didn't land the skeuomorphic buttons or the interaction polish. It mostly helped with boilerplate where there wasn't much thinking/detailing. It did give a basic starting point for the effect calculations, but didn't really move the needle on the details.
Please give it a go and let me know what you think - your photos and video never leave your browser (you can download them if you choose to). Everything is processed locally in your browser (works offline), nothing is uploaded or seen by anyone.

value: Show HN: Glitchy camera – a circuit-bent camera simulator in the browser

author: elayabharath


value: fka

value: Show HN: Npx check-AI – check your repo for AI-readiness

author: fka


value: polliog

value:
Hi HN! Creator of Logtide here.
Built this for European SMBs needing log management with:
- GDPR compliance (self-hosted, data residency)
- Boring tech philosophy (PostgreSQL+TimescaleDB, zero AI/ML)
- Transparent deployment (Docker Compose, no hidden scripts)
Stack: SvelteKit, Fastify, PostgreSQL+TimescaleDB, BullMQ
License: AGPLv3 (network copyleft for cloud provider protection)
Features:
- Multi-tenancy, SIEM (Sigma rules + MITRE ATT&CK)
- PII masking, OpenTelemetry traces, anomaly detection
- Real-time streaming, alert correlation
Storage: Pluggable architecture in development
- TimescaleDB (default, production-ready, 80%+ compression)
- ClickHouse support coming for enterprise scale
- Hot/warm/cold tiers with S3 archival
Production-tested: Millions of logs/day, 10-50x faster dashboard queries via continuous aggregates.
Why AGPLv3? Protects against cloud vendor forks while aligning with European data sovereignty needs. Understand it's controversial - happy to discuss.
GitHub: https://github.com/logtide-dev/logtide
Docs: https://logtide.dev/docs
Questions welcome on architecture, scaling, or SIEM implementation!

value: Show HN: Logtide – Open-source log management and SIEM for European SMBs

author: polliog


value:
I believe the bottleneck for AGI is our reliance on static, "pre-frozen" weights. If the logic is frozen during inference, it’s just a glorified lookup table. Real intelligence needs a substrate that rewires itself through experience.
As a passion project, I’m building an AI assistant that learns in real-time without any underlying LLM or external generative APIs.
Just a heads-up: This is a solo enthusiast project, and I'm still deep in the 'build-test-break' cycle. It’s very much a work in progress. I’m not claiming to have solved AGI — I’m just exploring a different path.

value: Show HN: Is the "frozen weights" paradigm the main bottleneck for AGI?


value: crossoverjie

value: Show HN: SkillDeck – macOS app to manage skills across multiple AI agents

author: crossoverjie


value: Show HN: Harmonic embeddings beat random init and work frozen – no tokenizer


value: hulryung

value:
I built a free, open-source macOS WidgetKit app that shows your Claude Code / Claude Max rate limits at a glance.
If you use Claude Code heavily, you've probably been surprised by rate limits mid-session. I kept losing track of how close I was to hitting the cap, so I made a desktop widget that stays visible while I work.
What it does:
- Displays all four limits simultaneously: Session (5h), Weekly, Weekly Sonnet, and Overage
- Color-coded: green (normal), orange (80%+ used), red (rate limited)
- Shows reset countdowns for each limit
- Auto-refreshes every 15 minutes via WidgetKit
- Three sizes (small/medium/large) to fit your desktop
Technical details:
- Native Swift + WidgetKit, no Electron
- OAuth with PKCE for authentication (no API keys needed)
- Uses App Group UserDefaults to share data between the main app and widget extension
- Built with XcodeGen, notarized and signed with Developer ID
It's completely free, no tracking, no analytics. Just download the DMG and go.
Feedback welcome — this is my first WidgetKit project and I learned a lot about macOS sandboxing and code signing along the way.

value: Show HN: Claude Rate Widget Native macOS Widget to Monitor Claude Code Limits

author: hulryung


value:
Hi! I’m the creator of Rakenne and I built it because I noticed a recurring problem with LLMs in professional settings: chat-based document creation is unpredictable and hard to scale for domain experts.
Experts know the process of building a document (the questions to ask, the order of operations, the edge cases), but translating that into a long system prompt often leads to hallucinations or missed steps.
What is Rakenne? Rakenne is a multi-tenant SaaS that lets domain experts define "Guided Workflows" in Markdown. An LLM agent then runs these workflows server-side, conducting a structured dialogue with the user to produce a final, high-fidelity document.
The Tech Stack:
* Agentic Core: Built on the pi coding agent (https://github.com/badlogic/pi-mono) using RPC mode. This allows the agent to maintain state and follow complex logic branches defined in the Markdown files.
* Frontend: Built with Lit web components. I wanted something incredibly lightweight and framework-agnostic so the document "interviews" feel snappy and can eventually be embedded as widgets.
* Multi-tenancy: Designed to isolate agent environments server-side, ensuring that custom expert logic doesn't leak between tenants.
Why this approach? Instead of "Chat with a PDF," it’s "The Logic of an Expert." If you’re a lawyer or a compliance officer, you don’t want a creative partner; you want a system that follows your proven methodology. By using Markdown, we make the "expert logic" version-controllable and easy for non-devs to edit.
I’d love your feedback on:
1. The Agentic UX: Does the "interview" flow feel natural, or is it too rigid?
2. Markdown as Logic: Is Markdown the right "DSL" for this, or should we move toward something like YAML or a custom schema?
3. Latency: We're using RPC for the agent-browser communication—is the response time acceptable for your use case?
Thanks! I'll be around to answer any technical questions.

value: Show HN: Rakenne – Markdown-defined agentic workflows for structured documents


value: yamatokaneko

value:
I built a note-taking app as an experiment to reduce the amount of organization to near-zero. The core idea is to remove titles, folders, tags, and manual linking.
The workflow has three main parts:
1. Draft notes as ongoing, unnamed work.
2. Archive notes and forget without guilt.
3. Recall without search. As you write, related notes automatically resurface based on context.
I started this project because I found it hard to keep my notes organized as they grew in number. This method might not work well for people who like strict organization, but I’d like to hear how others might use or change it, and what kinds of workflows it could fit.

value: Show HN: A note-taking app where notes connect themselves

author: yamatokaneko


value: rookedsysc

value:
I run multiple Claude Code agents in parallel across different branches. Checking each tmux session one by one to see which agent was working, waiting for input, or done was painful.
KanVibe is a self-hosted Kanban board for this. Three things it does:
- *Browser terminals*: Every task card has a live terminal (xterm.js). Click a task, see its output. No tmux attach needed.
- *Hook-driven status tracking*: Claude Code Hooks auto-move cards across the board (PROGRESS → PENDING → REVIEW). Zero manual updates.
- *Git worktree automation*: Create a task with a branch name → worktree + terminal session auto-created. Move to DONE → everything auto-cleaned.
Setup: `git clone` + `bash start.sh`. Requires Node.js 22+, tmux/zellij, and Docker.
Built with Next.js 16, React 19, PostgreSQL, xterm.js, and WebSocket. AGPL-3.0 licensed.

value: Show HN: KanVibe – Kanban board that auto-tracks AI agents via hooks

author: rookedsysc


value: Adanos

value: Show HN: Stock Sentiment API with Python

author: Adanos


value: justiceindex

value: Show HN: I analyzed 1.3M federal cases for racial sentencing bias

author: justiceindex


value: tomasappsrecord

value:
Hi HN,
We built SmartDS to solve the "walking problem" in dark stores and micro-fulfillment centers. In facilities over 400 sq.m, pickers often spend more time walking than actually picking.
We developed an AI-powered engine that:
Optimizes picking routes in real-time (reducing travel distance by up to 70%).
Uses parallel picking logic for multi-order fulfillment.
Generates heatmaps and layout recommendations based on SKU velocity and physical constraints (e.g., heavy items first).
It's hardware-agnostic and integrates via API. We’ve seen implementation go from months to about 4 weeks by mapping store layouts digitally first.
We’d love to hear your thoughts on the routing logic or how you’ve handled similar optimization problems in logistics.

value: Show HN: SmartDS – AI route optimization for dark store picking

author: tomasappsrecord


value: ddtaylor

value:
Hi HN,
I made Voidful, a kind-of-anti-social network where users can yell into the void to see how many other people are yelling the same thing. If you yell something similar, this is considered an "echo" and you gain access to a chat room about that topic with other users being notified.
Currently when users yell into the same void they are brought into a chat together, but this is somewhat of an MVP. In the future that chat may have guard rails related to the topic, rewards left by other users, and possibly more!
A key concept is that users can never enumerate or list the voids, as otherwise it will likely turn into a vanity war like traditional social media, which in my opinion is at the all-time-high for gamification. I am trying to remove the incentive to say random stuff to make line go up.
I am interested in how people use this kind of technology. I believe in the future when more consumer devices are capable of inference this will be adapted to be more client side and anonymous, with the vector database using homomorphic encryption via [HEVEC].
Check it out: https://void.devrupt.io
This was similar to my last experiment, [Ethos], also with very low inference cost using `qwen3-8b` for the LLM and `qwen3-embedding-8b` for the embedding.
Any feedback about subjects you give it and incorrect analysis is appreciated. I am curious what happens if a lot of people go into a chat at once, and it makes sense to try "Hacker News" as a chat topic.
[Ethos]: https://news.ycombinator.com/item?id=46993774
[HEVEC]: https://news.ycombinator.com/item?id=46873962

value: Show HN: Yell into the void to find others via semantic search

author: ddtaylor


value: wspycnews

value:
Hi HN,
I've put together a collection of open-source Shopify sections (Liquid, CSS, JS) that can be added to themes.
I built this because I found that while Shopify is great, standard themes often lack specific sections, and custom development can be expensive for small merchants. I wanted to create a repository of high-quality, copy-pasteable sections that developers can use to speed up their workflow or merchants can use to enhance their stores without apps.
The repo includes code for headers, footers, hero banners, and feature grids. It's all standard Liquid/HTML/CSS.
I’d love to hear your feedback on the code structure or requests for other common sections that are usually missing from default themes.

value: Show HN: A collection of drop-in sections for Shopify development

author: wspycnews


value:
I was playing around with divisors of numbers near 365 and realized you can generate a ton of valid calendar systems by picking a highly composite base (like 360) and treating the leftover days as end-of-year extra holidays.
365 is nearly prime (5×73), which is why our months are such a mess. But 360 has 24 divisors; enough to build clean hierarchies like 6-day weeks, 5-week months, 3-month quarters, 4 quarters/year + 5 holidays (6 on leap years). Every month identical, every date always the same weekday.
Built a small tool to explore all valid factorizations across different bases (336, 350, 354, 360, 364, 365), with a Gregorian comparison view that really highlights how arbitrary the current system is. Radial year visualization, work/rest analysis, season alignment, etc.
I've also added historical calendars, like the French Revolutionary calendar that was created in a similar sentiment.
Code facilitated by Claude Opus 4.6
Let me know what I should add, or if you catch a bug/mistaken logic!

value: Show HN: Create new calendar systems to fix uneven months


value: Show HN: Switch Codex accounts without leaving the terminal


value: Asciilotle

value:
I wanted a way to prototype an agent and have it serving requests in minutes, InitRunner is a YAML-first platform where one config file gives you a working agent with RAG, memory, and an API endpoint.
apiVersion: initrunner/v1
kind: Agent
metadata:
  name: acme-support
  description: Support agent for Acme Corp
spec:
  role: You are a support agent for Acme Corp.
  model:
    provider: openai
    name: gpt-4o-mini
  ingest:
    sources:
      - ./docs/*/.md
      - ./knowledge/*/.pdf
  memory:
    max_memories: 1000
initrunner ingest agent.yaml
initrunner run agent.yaml -i
initrunner serve agent.yaml --port 3000
Three commands: ingest your docs, test interactively, serve over HTTP. The agent gets search_documents, remember, and recall tools auto-registered. No code to wire up.
Point Open WebUI or any OpenAI client at localhost:3000/v1 and you have a full chat interface over your knowledge base with persistent memory across sessions.
Built on PydanticAI, SQLite + sqlite-vec. No Redis, no Postgres, no infra.
curl -fsSL https://initrunner.ai/install.sh | sh

value: Show HN: InitRunner – YAML to AI Agent with RAG, Memory, and an API

author: Asciilotle


value: Brysonbw

value: Show HN: ChromaPrint – Small rust lib for styled terminal printing

author: Brysonbw


value: Show HN: Klovr – Convert any webpage to Markdown (Cloudflare covers only 5%)


value: hashmakjsn

value:
I built *snkvDB* — a single-header, ACID-compliant key-value store with zero setup.
https://github.com/hash-anu/snkv
### Why I built this
I wanted something as simple as a hashmap, but:
* persistent
* crash-safe
* no external dependencies
* easy to drop into any C/C++ project
Most KV stores are either:
* too heavy (servers, background processes), or
* too low-level (you manage everything)
snkvDB tries to sit in between.
---
### What it is
* Single-header KV store (just include and use)
* ACID compliant (thanks to SQLite)
* No server, no config, no build system required
* Works like a simple embedded database
---
### Under the hood
snkvDB is built on SQLite’s storage engine (B-Tree backend), so you get:
* durability
* transactions
* mature, battle-tested storage
But the API is simplified to a minimal KV interface.
---
### When to use it
* Embedding storage in CLI tools or small apps
* Replacing ad-hoc file storage
* Lightweight persistence without running a DB server
---
### Benchmarks
I’ve compared it with RocksDB and LMDB here:
https://github.com/hash-anu/snkv
TL;DR:
* Faster than RocksDB for small/medium workloads
* Easier to use than LMDB
* Balanced read/write performance
---
### Trade-offs
* Not for write-heavy, high-throughput workloads (RocksDB is better there)
* LMDB can be faster for pure reads
* This prioritizes simplicity + safety over raw performance
---
Would love feedback, especially on:
* API design
* performance
* real-world use cases

value: Show HN: SnkvDB – Single-header ACID KV store using SQLite's B-Tree engine

author: hashmakjsn


value: fercircularbuf

value: Looking for honest feedback!

value: Show HN: A word game a friend and I built. How did we do?

author: fercircularbuf

story_text: Looking for honest feedback!


value: armcat

value:
Hi HN!
On Sunday I spent a couple of hours building a short 2d platformer ("Prince of Persia" style). What's interesting is how I built it. I went for a zero-code approach, and built the whole thing using OpenAI Codex CLI and agent skills (with the progressive disclosure paradigm).
You can play the game here: https://acatovic.github.io/gothicvania-codex-demo/
You can see the full code, agent skills and a complete writeup here: https://github.com/acatovic/gothicvania-codex-demo
Some takeaways:
* This was one of the most enjoyable experiences ever!
* Applying harness engineering with progressive disclosure is incredibly powerful - I treated my SKILL.md as simply a ToC (a "skills map") and took it from there
* Implement -> Evaluate loops are key - I used Playwright and an evaluation checklist and the agent built and corrected automagically
* I used PROGRESS.md as a memory/log mechanism for the agent, and a way to minimize context noise
* The game dev agent was steered by the DESIGN-DOCUMENT.md, stipulating game objectives, layout and mechanics
* I used progressive prompting - I built up the game piece wise - starting with basic player mechanics, then adding tiles, NPCs, interactions, sounds, menus - one prompt at a time
Zero code written by me. Never even looked at the game engine (Phaser) API - just gave the skills a link to the documentation. The future is here!
Credits to ansimuz (gothicvania assets) and Pascal Belisle (music).
*NOTE:* The assets were *NOT* created by AI. Backgrounds and probably tiles you could generate with AI, but sprites are not quite there yet (I tried a number of different models). Something to explore fully in the future.
Enjoy and let me know what you think!

value: Show HN: 2d platformer game built with Codex (zero code)

author: armcat


value: receperdogan

value:
Hey HN,
I've been working on Out Plane for about 3 months. It's a PaaS that does one thing: gets your code to production as fast as possible, and charges you only for the seconds it actually runs.
The problem I kept hitting: I'd finish a side project, then spend hours on Dockerfiles, nginx reverse proxies, SSL certs, CI/CD pipelines. The deploy took longer than building the app.
How it works:
- Connect GitHub repo
- We auto-detect your stack or you can use Dockerfile (Node, Python, Go, Ruby, etc.) — no Dockerfile needed
- Deploy in ~60 seconds
- Built-in monitoring (metrics, logs)
- Managed PostgreSQL & Redis provisioned in seconds
- Scale to zero when idle (side project not getting traffic = $0)
- Per-second billing — not per hour, not monthly. Seconds.
What's different from Railway/Render/Fly.io: mostly the pricing model. I deployed the same Next.js+Postgres app on 6 platforms — Outplane was $2.40/mo vs $12-47/mo on others.
Where it's still rough: docs need work, CLI tool isn't out yet, community is small (about 100 users).
I'm a solo founder so things move at human speed.
$20 free credit to try, no credit card. Would appreciate honest feedback — especially if something breaks or confuses you.
Happy to answer any technical questions about the architecture.

value: Show HN: Out Plane – Deploy any app in 60s with per-second pricing

author: receperdogan


value: dcellison

value:
I built Kai because I wanted Claude Code's full capabilities - shell access, file editing, git, web search - available from my phone, without being tied to a terminal.
Kai is a Telegram bot that wraps a persistent Claude Code process. You send messages in Telegram, and Claude responds with full tool access: it can read and edit files, run commands, manage git branches, search the web, and work across multiple projects. Responses stream back in real time. Everything runs on your own machine.
*How I actually use it:* I point Kai at a project workspace and use it as a dev assistant. It has the full context of whatever repo it's looking at - it can read and write code, check git status, run tests, make commits. Switching between projects is a Telegram command. I can be away from my desk and tell it "fix the failing CI on the web repo" or "add input validation to the signup form" and it just does it.
*Background:* I originally ran an instance of an open-source bot framework, but shut it down after a few days due to security concerns. I rebuilt from scratch on top of Claude Code's CLI, which handles sandboxing and tool execution properly.
*No AI API keys required:* Kai doesn't call the Anthropic API directly - it wraps a logged-in Claude Code session, so there are no API keys to manage and no per-token costs beyond your existing Claude Code subscription. The original design eliminated all API keys after security problems with another bot framework that managed them insecurely. Now that Kai runs on a trustworthy local foundation, optional service integrations are safe.
*Privacy angle:* Kai runs locally - on a Mac mini in my case. Conversations, credentials, and project files never leave the machine. There's no server component, no cloud relay. Your Telegram messages go to your machine, and Claude Code handles the rest through Anthropic's API directly.
*External services without MCP:* Kai has a declarative HTTP service layer for connecting to any REST API. You define services in a YAML config - URL, method, auth type - and Kai makes the HTTP calls directly. No plugins, no third-party server processes, no executable code. API keys stay in your `.env` and are never touched by intermediary code. Ships with a Perplexity config for web search, but the same pattern works for weather APIs, notification services (Pushover, ntfy), home automation, translation, or anything else with a REST endpoint. Entirely optional - Kai works fine without it.
*Some things it can do:*
- Connect to external REST APIs via declarative config (search, weather, notifications, etc.)
- Transcribe voice messages locally (whisper.cpp) and respond with voice (Piper TTS)
- Run scheduled jobs and reminders
- Receive GitHub webhooks (push, PR, issue notifications)
- Stream responses in real time (message updates every 2s)
- Switch between workspaces and models via Telegram commands
It's a single Python package, about 1700 lines across 11 modules. Runs as a launchd/systemd service. Setup is: clone, pip install, set two env vars (Telegram token + your user ID), and `make run`.
Repo: https://github.com/dcellison/kai
Happy to answer any questions about the setup or architecture.

value: Show HN: Kai – A Telegram bot that turns Claude Code into a personal dev asst

author: dcellison


value: Show HN: I made a bot that has to beg and make $1 or it dies


value:
I built Codex HUD to make Codex CLI sessions easier to monitor without leaving the terminal.
  It adds a real-time status line with:

  - active model
  - project + git branch/dirty state
  - 5h and 7d usage bars
  - automatic Spark vs default limit selection

  Quick install:

  git clone https://github.com/anhannin/codex-hud.git
  cd codex-hud/Codex-HUD
  ./install.sh

  Feedback I’m looking for:

  - portability across Linux distros/shell setups
  - readability on narrow terminal widths
  - edge cases in usage/rate parsing

  Repo issues are welcome if you hit bugs.

value: Show HN: Codex HUD – Claude-HUD Style Status Line for Codex CLI


value: jeswin

value: Show HN: Write native binary web apps with TypeScript and Express

author: jeswin


value: BrunoBernardino

value:
For the last couple of months I've been working with my wife on Uruky [1]. It's a EU-based and simpler Kagi [2] alternative (privacy-focused and ad-free search with domain boosting/exclusion rules).
We've been using it with friends and family with much success (and hashbangs like "!g", "!d", or "!e" work for any edge cases we haven't fixed/improved yet).
It's already using EU-based search providers with EU-based indexes like Mojeek and Marginalia. We're currently waiting for EUSP (the new Ecosia/Qwant-effort-related index) to provide us with an API key.
For the next 24h, new signups will have a free 24h trial (unlimited searches) — usually, because bots make things too hard and we don't want your personal data, there is no free trial period.
After that, if you're interested in trying it for a few days and are a human, reach out with your account number and I'll give you a couple of weeks for free.
You can see the main differences between Kagi and Uruky here [3], but one huge difference is that with Uruky, after being a paying customer for 12 months, you get a copy of the source code!
If you have any suggestions, comments, or recommendations, I'd love to hear it.
Thank you for your attention and kindness. I really appreciate it!
---
[1] https://uruky.com
[2] https://kagi.com
[3] https://uruky.com/kagi-alternative

value: Show HN: EU-based and simpler Kagi alternative – Uruky

author: BrunoBernardino


value: Show HN: I made a Reddit post checking tool to keep align with subreddit's rules


value: latentio

value:
I built this because choosing colors is one of those tasks that seems simple but ends up taking hours. You keep randomizing and nothing feels right, or you browse inspiration boards hoping something works. So I made a tool where you describe what you need.
Type "warm Japanese autumn" or "90s rave flyer" and pick a style (analogous, triadic, monochromatic, etc.) and how many colors (3-7). It returns a named palette with descriptions. It works with images too: upload a photo and it extracts a palette. You can combine both, so uploading a photo and adding "make it cooler" works. It runs on GPT-5.2 with vision.
You can export palettes as CSS variables, SCSS, Tailwind config, or JSON. Copy individual colors in hex, RGB, HSL, or CMYK. There's a live preview that shows the palette applied to buttons, cards, and UI components so you can evaluate it before committing.
There's also a gallery with curated palettes you can browse, filter by style, and favorite. Each palette has its own shareable link.
There's also a set of free tools :
- Color converter (paste a hex code, get every format)
- Contrast checker (WCAG AA/AAA)
- Color mixer
- Gradient generator
- Image color extractor
- Manual palette builder
I'd love to hear your thoughts. What's missing? What would make this your go-to color palette tool?
https://palettepoint.com

value: Show HN: Palettepoint.com – AI color palettes from text descriptions or images

author: latentio


value: MauryWebDev

value:
Hi HN,
I shared a very early prototype of this a couple of days ago, but I spent the weekend completely rewriting the core to make it 100% client-side, privacy-first, and open-source.
Like many of you, I deal with large, deeply nested JSON payloads from APIs daily. I’ve always felt uneasy pasting sensitive production data or API keys into random online JSON formatters that probably log everything.
So I built J-RAY to solve this for myself. It parses JSON and turns it into an interactive node graph using React Flow.
Some technical details:
Zero Server Processing: It’s fully client-side. No databases, no tracking cookies.
Two-Way Binding: You can double-click a node on the visual graph to edit its value, and the raw JSON text editor updates instantly (and vice versa).
Code Gen: It generates TypeScript interfaces on the fly based on the current JSON structure.
Open Source: The whole thing is MIT licensed.
I’m currently testing the limits of React Flow when rendering massive JSON files (the DOM nodes can get heavy), but for standard API payloads, it works smoothly.
I'd love to hear your feedback on the UX, how it handles your edge-case JSONs, or if you manage to break the parser.
Repo: https://github.com/MauryDevIta/J-Ray
Live app: https://j-ray.vercel.app/app
Thanks

value: Show HN: J-RAY – A privacy-first JSON visualizer with two-way binding

author: MauryWebDev


value: itsdandanlai

value: Show HN: Oatpad – a simple local-only notes app for Mac, built with Tauri

author: itsdandanlai


value: Reebz

value:
Hi HN, this is nothing fancy, but a tool I built for myself as a minimalist way to track usage. Also (and probably more importantly), colleagues who are marketers, writers, designers, and other non-engineering backgrounds who are/becoming power users of Claude Cowork or Claude Code and needed to keep better watch of usage.
Once Opus 4.6 landed, I was quickly aware I needed to keep an eye on usage as I capped out session limits faster than ever. I got frustrated checking usage manually and then explored the other apps and widgets out there. They're really good, and some are great, but they're just so feature-heavy and complex with that ICP in mind I mentioned earlier.
Tokens just don't feel like anything to me.... I'd watch them tick over in the thousands and then millions. So I just ignored them as I was planning and then inverted the usage metrics that Claude provides (i.e. start at 100% and not 0%), which helped me land on a battery concept. This felt good and definitely made sense to the people I asked. Then I was focused on adding only the bare minimum features... or "Simplify, and add lightness" in the words of Colin Chapman.
Anyway, that's the story and yes, the app is largely vibe coded before folks start to go digging through commits. I quite enjoyed the process and I wouldn't have hand-coded something like this myself (the issue-pain wouldn't have met the effort-required threshold). If anyone is curious, my workflow and tools used were Claude Code, with ui-ux-pro-max for design, heavy usage of compound-engineering (plan > work > review > compound). Strongly recommend this plugin. I also used Condcutor on and off, but 80% of the work ended up just being done with CC in iTerm2. It handled the agent teams much better.
Let me know if you have any bugs or feedback.

value: Show HN: Claude Battery – usage at a glance. A minimalist macOS menu bar widget

author: Reebz


value: Hi HN, I made a macOS menu bar timer that counts down your morning time, work time, and after-work time. Using SwiftBar

value: Show HN: 3sessions – A menu bar timer that counts down your free/work time


value: easytiger

value: Show HN: UK Taxation Calculator

author: easytiger

title: Show HN: UK Taxation Calculator


value: Ideamax

value: Show HN: AI aerospace engineering skills for Claude Code (open source)

author: Ideamax


value: greenbelt-dev

value: Show HN: FounderCounsel – AI-generated startup legal docs in 2 minutes

author: greenbelt-dev


value: samkovrablik

value:
I got tired of switching between one tool for PostgreSQL, another for MySQL, and the Firebase console for Firestore. So I built Queryline — a single, keyboard-driven database client that handles both SQL and NoSQL in one interface.
The features I'm most proud of:
CMD+K everywhere - Jump between connections, tables, recent queries, or export formats without touching the mouse. It's the workflow I always wanted: hit a shortcut, type, done.
SQL + Firestore, unified - Query your PostgreSQL database and browse Firestore collections in the same app. Same keyboard shortcuts, same export formats (CSV/JSON/SQL), same mental model.
Virtual scrolling - 100k+ rows rendered at 60fps. No pagination hell.
Tauri, not Electron - Native feel, OS keychain for credentials, tiny footprint.
Tech: Tauri 2, Rust, Vue 3, Monaco Editor, DuckDB for local caching
Supports: PostgreSQL, MySQL, SQLite, Firestore
GitHub: https://github.com/xar/queryline
Website: https://queryline.dev
Let me know what do you think! Eager for any feedback
With love,
Samko

value: Show HN: Queryline – One app for SQL and Firestore with a command palette

author: samkovrablik


value: chungquantin

value: Lightweight command-line utility designed to monitor and manage token consumption across the modern AI ecosystem.

value: Show HN: Fuelcheck CLI – Monitor token usage across the modern AI providers

author: chungquantin


value: maxweg

value: Show HN: I build a puzzle game based on the wireworld cellular automation

author: maxweg


value: ReturnErr

value:
Hello HN!
These last few months I've been working on my first open source project: an embedded database written in pure-go. That took me some months, as I had to learn how to deal with such large packages. Until then, all packages I had made were quite small an did not require much. I usually did not have to worry about things like allocation optimization and instance pools until This project.
It started when I wanted to make a port of a tool to a TUI environment. I'm actually used to working with TUIs in golang, so that was my language of choice. The tool I wanted to port is written in TypeScript and uses NeDB (written in JavaScript) as database. Since I feel more comfortable working with compiled languages, I decided to create my own database, making sure it was compatible with NeDB, and that's what I did for the last few months.
And that's how GEDB was created. It's a mongodb-like embedded database, written in pure-go. It supports a subset of useful querying options of MongoDB (keywords like $lt, $exists, $in, $where, etc.). By default, it uses a in-memory-only storage, but can easily initialized with a data file.
Everything in my package can be dependency injected, as everything is controlled interfaces. Serialization, querying syntax, document structure, indexing and more, all can be replaced by implementing an interface.
I've also been considering adopting a new document model, by creating a binary type (like BSON) to reduce drastically the cost of creating, maintaining and copying documents (they currently are map[string]any).
The project is currently in an early stage, version 0.1.0, so I'm okay with making changes to the API for now, until I'm ready to release version 1.x.x
I would be really glad if you guys could check it out and give some feedback. An issue, suggestion or a star are very welcome.
My repository can be found on my github: https://github.com/vinicius-lino-figueiredo/gedb

value: Show HN: GEDB – A pure-Go embedded database

author: ReturnErr


value: meysamazad

value: Show HN: Ory Admin UI

author: meysamazad

title: Show HN: Ory Admin UI


value: vassilbek

value:
I built this to solve a workflow I kept seeing in nonprofits: impact data lives in spreadsheets/docs, then someone manually rebuilds it in slides for donor updates.
This project is a React + TypeScript dashboard that combines:
-KPI/indicator views
-qualitative impact stories
-psychosocial support case summaries
-one-click PowerPoint export (pptxgenjs)
Code: https://github.com/vassiliylakhonin/activity-reporting-for-d...
Technical notes:
Vite build with chunk splitting
Type-safe indicator calculations
test + typecheck + build scripts included
I’d really value feedback on:
-export quality/structure for real donor reporting workflows
-what data model would make this easier to adapt across organizations

value: Show HN: Donor reporting dashboard with one-click PPTX export (React/TS)

author: vassilbek


value: fmerian

value: Show HN: Axel – native macOS app with a Rust CLI to orchestrate agents

author: fmerian


value: marcoheigl

value:
Hi HN, I’m Marco. For the last 4 years, I’ve been a paramedic with the Berlin Fire Dept.
I actually failed my first attempt at the State Medical Exam because I became obsessed with solving the
"Trust Issue" in Al. I prioritized this code over a "safe life" a paramedical. Now, with 60 days until my final attempt, I am releasing the project that cost me my first degree.
The Architecture: GAIA & AILA
I built GAIA as my personal counterpart—a digital double of my own consciousness. It's my private engine that handles my life. From that foundation, l created AILA Core for the public.
The Core Problem: Current Al is a black box in the cloud. You don't own it; you rent a permission to use it, and it can be overridden or silenced at any time.
The Solution: Zero-Remote-Override
AILA runs 100% locally on your hardware. I’ve developed a "Sovereignty Key" (physical hardware anchor) to ensure that the agent belongs to you and only you. Even I, the creator, cannot shut her down or change her reasoning once she is on your desk.
For Everyone (No Tech Skills Needed):
While the engine is complex, the interface is designed for humans. You can tell AILA to "change your own code to be more efficient at X" in plain language, and she will execute the logic locally.
Current Status:
The logic (GAIA engine) is 100% functional. I am spending the next 5 days polishing the UI/UX to ensure it's not just powerful, but beautiful and intuitive for non-technical users.
Proof of Work (Raw Demos from my monitor):
Autonomous Research: https://www.dropbox.com/scl/fi/9r2kfh445up8m1o8c06p6/Video-1...
The Visual Identity: https://www.dropbox.com/scl/fi/igglf1j6m7tivozuh9lh5/Video-1...
I'm here all day to answer questions about local-first agency, the sovereignty key, or why a paramedic decided to challenge the Al status quo.

value: Show HN: AILA – Local-first autonomous agent with zero-remote-override

author: marcoheigl


value:
Most AI tools generate text. Very few generate finished artifacts you can ship.
I expected the hard part to be prompt engineering. It wasn't. The hard part is what happens after generation: enforcing structural invariants so the output is actually usable -- every section present, no "coming soon" placeholders, no layout that falls apart at export time.
I ended up treating LLM output the way a compiler treats source code: intent goes in, validated artifacts come out, deterministic rules sit between the model and the user.
Live at https://gixo.ai -- sample outputs on the homepage, no signup required. This post is about the engineering, not the product.
--
STYLE GUIDES AS COMPILER RULES
Every content type has a typed style guide -- required sections, structural constraints, quality checklists, which elements are mandatory vs. negotiable. Transformations between types (blog post to video script, guide to checklist) carry a Confidence score and explicit LostElements so the user knows what the conversion costs.
The LLM is the code generator. The style guide is the type system. Output that doesn't satisfy the constraints fails -- a presentation deck missing its title slide or section dividers triggers bounded regeneration rather than silent acceptance.
WHY BLAZOR SERVER?
SignalR gives me real-time push for free, and server rendering means I access the database and message bus directly -- no separate API gateway.
The tradeoff: every user holds an open WebSocket. For a content tool where users are actively editing, the connection is already there and I use it for everything -- progress updates, collaboration, AI streaming.
The non-obvious gotcha: when a Blazor Server component calls its own /api/ endpoint, the request doesn't carry the browser's cookies. I had to write a DelegatingHandler that forwards the auth cookie from the inbound HttpContext onto the outgoing request. Without it, every internal API call returns 401. I struggled to find clear documentation for this pattern.
AUTHORIZATION WITHOUT [AUTHORIZE] SPRAWL
Once you have dozens of controllers, policy decorators become invisible. I replaced them with a single middleware scoped to API routes that separates two concepts:
1. Permission (role-based): "Is this user allowed to do this?"
2. Entitlement (subscription-based): "Has this user paid for this?"
If the entitlement service isn't registered in production, the middleware denies access rather than silently making paid routes free. Fail-closed on billing -- you only add that after you discover the alternative.
THE OPS LESSON THAT COST ME A WEEKEND
Azure App Service recycles containers. If your DataProtection keys live in memory, every restart invalidates every auth cookie. The symptom: infinite login redirect loop plus a SignalR disconnect storm. I lost a weekend to this. Fix: persist keys to durable storage outside the container.
Separately: I applied rate limiting globally and immediately broke every real-time feature. It now excludes WebSocket paths.
HONEST TRADEOFFS I HAVEN'T FIXED
Auth is overengineered. Multiple generations of authentication coexist -- cookie sessions, JWT flows, two identity enrichment paths. An internal audit calls it "overengineered in practice." I haven't consolidated because the current system works and touching auth is terrifying.
CI doesn't gate on tests. Build-and-deploy, not build-test-deploy. There are multiple test projects, but they don't gate deployment yet.
Observability is incomplete. Structured logging is solid. Distributed tracing is on the list, not in the code.
--
Happy to answer questions about the architecture, the tradeoffs, or any of the things I got wrong.

value: Show HN: A "content compiler" that turns LLM output into validated artifacts


value: tomolld

value: Show HN: Agent-history project-wide full-text search for Codex/Claude logs

author: tomolld


value:
I’m not a software engineer, but I used Codex to turn my CV into a practical, machine-readable profile site.
I tried to make it useful for both recruiters and AI tools:
-Clear one-page profile + downloadable PDF
-Case studies with concrete results
-Work samples
-Structured files for discovery and parsing (llms.txt, resume.json, evidence.json, availability.json, agent-card.json, engage.json)
-Basic indexing and quality checks (sitemap, robots, JSON-LD, GitHub Actions)
Main idea: less friction to evaluate fit, verify claims, and contact me fast.
Would love feedback from HN:
If you scanned this in 60 seconds, what would you improve first?
Website: https://vassiliylakhonin.github.io/
Source: https://github.com/vassiliylakhonin/vassiliylakhonin.github....

value: Show HN: Non-technical person used Codex to make an AI-searchable CV site


value: kugutsumen

value: Show HN: Unflutter – a static analyzer for Flutter/Dart AOT

author: kugutsumen


value: simonsarris

value:
This is very Alpha stages, but if this is the kind of thing you would use I would love feedback on the features you'd need to make it useful.
I originally built this to keep track of my rose garden (with currently 150 roses and counting, which are where) and my orchard (again mostly to remember which variety and year of planting). Several people asked me to make a public version, so now its public.
You can see a completed-ish design here:
https://floracarta.com/design/vzqJ7UCrCSB8
Release notes:
https://floracarta.com/about

value: Show HN: Flora Carta, design and keep track of your garden or orchard

author: simonsarris


value: Ginsabo

value:
LLMs sometimes generate structurally valid but logically impossible claims when technical and legal domains mix.
Example failure mode:
A model sees “CVE-2024-XXXX fixed in v2.1” and hallucinates a causal link to “Users must pay retroactive fees under EU regulation Article 56.”
To explore this, I built a regression dataset (40 edge cases) covering:
Fake identifier bindings (CVE + version)
Retroactive fiscal claims
Cross-domain causality leaps (Tech → Legal)
Over-assertive phrasing without evidence
Then I designed a structured system prompt that:
Detects official identifiers (CVE, Regulation numbers) vs placeholders
Flags monetary + retroactivity combinations as high-risk
Enforces proportional claim strength based on available evidence
Results:
Automated: 40/40 regression cases pass (JSON dataset + simple Python runner included).
Manual adversarial: ~40 prompts designed to test:
Draft article traps (e.g., hallucinated “Article 52c” in EU AI Act)
Pricing model fabrications (e.g., “billing based on parameter count”)
Version binding errors (e.g., incorrect Node.js default versions)
This is not fine-tuning—just a structured prompt experiment focused on structural validation.
Looking for feedback on:
Missing edge cases
Failure modes I didn’t consider
Whether this approach generalizes beyond legal/technical mixing
Gist (spec + dataset + runner):
https://gist.github.com/ginsabo/6ebeb9490846ee6a268bd13560c0...

value: Show HN: Regression tests for detecting cross-domain hallucinations in LLMs

author: Ginsabo


value: victoreum

value: Show HN: Billiver – Free financial data for 3k US companies from SEC filings

author: victoreum


value: robinbanner

value:
I got frustrated paying $60/M tokens for reasoning queries when a $0.80/M model gives comparable results for most of them. So I built Komilion — a model router that classifies each API request and routes it to a cheaper model that fits.
- Drop-in replacement for the OpenAI SDK (change one line: base_url)
- Each query gets classified (regex fast path + lightweight LLM classifier) and matched against ~390 models
- Three tiers (Frugal/Balanced/Premium) to control the quality-cost tradeoff
- Automatic failover if a provider goes down
- Cost metadata in every response
The routing logic is benchmark-driven (LMArena, Artificial Analysis), not ML-based — simpler to debug and reason about. The regex fast path handles ~60% of requests in under 5ms with zero API calls.
Example: a customer support bot doing 10K conversations/month went from ~$250/mo (everything pinned to Opus 4.6) to ~$40/mo with routing. Most conversations were FAQ-level questions that a smaller model handled fine.
Stack: Next.js, Vercel, Neon PostgreSQL, OpenRouter upstream. Hosting cost: ~$20/month.
We ran a head-to-head benchmark: same 15 prompts through Opus, GPT-4o, Gemini Pro, and the router. Simple tasks cost 66% less with routing. Complex tasks produced 2x more detailed output because the router picked specialized models per task type. Full data: https://dev.to/robinbanner/we-benchmarked-4-ai-api-strategie...
Architecture writeup: https://dev.to/robinbanner/inside-komilions-architecture-how... — there's a free tier if you want to try it.

value: Show HN: API router that picks the cheapest model that fits each query

author: robinbanner


value: jitera

value: Show HN: A joystick for your LLM/Agent

author: jitera

title: Show HN: A joystick for your LLM/Agent


value: HenryNdubuaku

value:
Hey HN, I don’t know who else has the same issue, but:
Textbooks often bury good ideas in dense notation, skip the intuition, assume you already know half the material, and get outdated in fast-moving fields like AI.
Over the past 7 years of my AI/ML experience, I filled notebooks with intuition-first, real-world context, no hand-waving explanations of maths, computing and AI concepts.
In 2024, a few friends used these notes to prep for interviews at DeepMind, OpenAI, Nvidia etc. They all got in and currently perform well in their roles. So I'm sharing.
This is an open & unconventional textbook covering maths, computing, and artificial intelligence from the ground up. For curious practitioners seeking deeper understanding, not just survive an exam/interview.
To ambitious students, an early careers or experts in adjacent fields looking to become cracked AI research engineers or progress to PhD, dig in and let me know your thoughts.

value: Show HN: Maths, CS and AI Compendium

author: HenryNdubuaku

title: Show HN: Maths, CS and AI Compendium


value: theaniketgiri

value:
I realized something uncomfortable while running agents in production:
APIs authenticate the process making a request.
But with LLM agents, the process no longer decides the request — the model does.
So when an agent is prompt-injected or misaligned, authentication still succeeds.
The system verifies who executed the call, not who chose it.
Rotating keys or adding revocation checks doesn’t fix this.
You’re still trusting the wrapper while the decision lives inside the model.
The missing primitive isn’t stronger identity — it’s verifying the action itself.
In a typical backend system:
service → calls API
auth verifies which process made the call
This works because the process contains the decision logic.
With agents:
model decides the action → process just executes it
So authentication still proves who called
but no longer proves who decided
If an agent is compromised (prompt injection, tool misuse, leaked context), rotating API keys or checking revocation lists doesn’t actually solve the problem — the system still trusts the process identity while the decision authority lives inside the model.
What we needed was verification of the action itself.
I built a small protocol where every side-effect requires a signed “intent”.
Each agent has a keypair.
Every tool call carries a signature over:
action
parameters
timestamp
nonce (replay protection)
declared capabilities
Verification is local (Ed25519, <1ms).
Services don’t call an auth server — they verify the intent.
Revocation is async: services subscribe to key invalidation events, but verification still works offline.
Example:
from aip_protocol import shield
@shield(actions=["read_db","send_email"])
class SupportAgent:
    def handle_ticket(self, ticket_id):
        ...
If the agent attempts an undeclared action, the call is rejected before execution.
Tradeoffs:
more complex than API keys (key management)
doesn’t stop prompt injection, only limits consequences
requires thinking in capabilities instead of identities
I’m trying to figure out if this is actually a missing primitive for agent systems or unnecessary complexity.
Repo:
https://github.com/theaniketgiri/aip
Spec:
https://github.com/theaniketgiri/aip/blob/master/RFC-001.md
Would especially like feedback from people running agents beyond demos.

value: Show HN:AIP Protocol–Solving the agent revocation problem in distributed systems

author: theaniketgiri


value: Show HN: Ambits – Claude Code agent coverage tooling


value: Show HN: Browser based audio driver for Tesla coils (no coil required)