value: acro-v

value:
Hey HN,
I am building Aye Chat, an open-source terminal workspace that integrates AI code generator directly into your shell, allowing you to edit files and run commands as well as prompt AI seamlessly.
The AI writes code directly to your files immediately, eliminating the "review and approve" out of the loop.
At the same time, every AI edit is snapshotted locally, so you can instantly undo any change with a single command. This automatic file update with a safety net is the core idea.
Also, in the same session, you can run shell commands, open Vim, and ask the AI to modify your code, turning it into an AI-powered terminal.
I built this because I got tired of the "suggest -> review -> approve -> changes applied" loop in existing AI coding tools. As models improve and generate proper code more often than not, manual approval started to feel unnecessary as long as there is a strong safety net to allow easy rollback of the changes. Yes, the idea is not exactly groundbreaking: other tools already offer "set a dangerous flag and remember to recover later" settings, but what I am exploring is defaults, not capability. With Aye Chat, the default is the opposite: apply immediately and make undo trivial. There are no flags to remember, no mode switches, and you don't need to exit the tool to roll back.
You can watch a 1-minute demo here: https://youtu.be/h5laV5y4IrM
Basically, the typical workflow goes like this (instead of a chat window, you stay in your terminal):

  $ aye chat # starts the session
  > fix the bug in server.py
   Fixed undefined variable on line 42

  > vim server.py
  [opens real Vim, returns to chat after]

  > refactor: make it async
   Updated server.py with async/await

  > pytest
   Tests fail

  > restore
   Reverted last changes

I use Aye Chat both in my work projects and to build Aye Chat itself. Recently, I used it to implement a local vector search engine in just a few days.
Lower-level technical details that went into the tool:
The snapshot engine is a Python-based implementation that serves as a lightweight version control layer.
For retrieval, we intentionally avoided PyTorch to keep installs lightweight. Instead, we use ChromaDB with ONNXMiniLM-L6_V2 running on onnxruntime.
File indexing runs in the background using a fast coarse pass followed by AST-based refinement.
What I learned:
The key realization was that the bottleneck in AI coding is often the interface, not the model. By shifting to the AI writing code immediately with users still maintaining full control to undo those changes - we eliminate the cognitive load of the review-and-approve loop.
I also learned that early users do not accept a custom snapshot engine, so to make it professional-grade we are now integrating it with git refs.
What I’d love feedback on:
- After using it for a while, did replacing approvals with undo actually change how you work, or did it feel no different from existing terminal-based AI tools (GitHub Copilot CLI, Claude Code)?
- Was there a moment when this started to feel natural to use, or did it never quite click?
There is a 1-line quick install:

  pip install ayechat

Homebrew and Windows installer are also available.
Repo: https://github.com/acrotron/aye-chat. If you find it interesting, a repo star would mean a lot!
It's early days, but Aye Chat is working well for me. I would love to get your feedback. Feel free to hop into the Discord (https://discord.gg/ZexraQYH77) and let me know how it goes.

value: Show HN: AI that edits your files directly, no approvals [demo]

author: acro-v


value: mmmehulll

value:
Agents are starting to take real actions (publish content, trigger workflows, touch prod systems).
Ctrl is an execution control plane that sits between agent intent and real-world actions.
It intercepts MCP tool calls, scores risk, enforces allow/deny/approve policies, and executes only what’s authorized with a full SQLite audit ledger.
It Ships as a drop-in CtrlMCP wrapper for LangChain.
Looking for feedback and early pilots running agents in production.

value: Show HN: Ctrl – execution control plane for AI agents

author: mmmehulll


value: QuadmasterXLII

value: I always have loved the idea that Rubiks cubes can be solved via abstract algebra, but the group action is not ergonomic on a physical cube. This toy solves that by allowing one to apply one cube state to another. In fact, that's all it allows.

value: Show HN: Finite Craft, The Rubiks finite group via an Infinite Craft interface

author: QuadmasterXLII


value: DerekDragon

value:
Hi HN,
This started as a JSON editor.
Then I added “just one more thing”.
And then another.
At some point it became a small collection of developer tools.
JSONEditors is now a set of browser-based utilities I use when dealing with
JSON, HTML, XML, encoded strings, and random bits of text that show up
while debugging APIs, configs, or data exports.
Nothing here is revolutionary.
Most of these tools already exist somewhere.
The problem I kept hitting was friction:
switching between different sites,
different UIs,
different assumptions about what I want to do.
So I ended up putting the tools I actually use in one place,
with consistent behavior and predictable output.
The goal is very boring, on purpose:
paste input, see result, copy output, move on.
Some examples of what’s there:
- editing and formatting JSON, HTML, and XML
- encoding / decoding helpers
- tree and text-based views depending on the task
- simple transforms that don’t try to be clever
It’s meant for the “in-between” moments of development,
not as a replacement for IDEs or CLI tools,
but for the quick tasks that don’t justify opening a full environment.
I’m curious how others here handle this:
- Do you prefer all-in-one dev tool sites, or format-specific ones?
- What small tasks do you keep repeating in the browser instead of your IDE?
- At what point do you abandon browser tools and switch to CLI or editor plugins?
Happy to answer questions, or hear why this approach doesn’t make sense for you.

value: Show HN: I built a dev tool site to avoid context switching

author: DerekDragon


value: Show HN: Open-source Langsmith alternative written in Rust


value: A terminal TUI that leverage tmux to make managing terminal tabs easier and more friendly.

value: Show HN: Dimensions – Terminal Tab Manager


value:
Hi HN,
KafScale is Kafka-compatible streaming, k8s native, where S3 is the source of truth and brokers hold no persistent state. Written in Go, runs on Kubernetes.
Built this after years of operating Kafka and hitting the same walls: broker failures that take hours to recover, partition rebalancing that blocks deploys, disk capacity planning that never ends.
How it works:
- Producers and consumers use standard Kafka clients
- Brokers buffer in memory, flush to S3
- etcd stores metadata and consumer group state
- Recovery means restarting a pod and reading from S3
- Optional Iceberg processor reads segments directly from S3, bypasses brokers entirely for batch/analytical workloads
What you give up: latency is 400-500ms (S3 round-trip), no transactions, no compacted topics. It's not a 100% replacement.
What you get: brokers are disposable, scaling is just replica count, no disk management, direct access to streamed data over S3 ACL
License: Apache 2.0
GitHub: https://github.com/novatechflow/kafscale

value: Show HN: Kafka-compatible streaming on S3 with stateless brokers


value: alexcloudstar

value: Show HN: Squad In Sync – A dashboard for group trip and event logistics

author: alexcloudstar


value: shuka

value: Show HN: Stash – Sync Markdown Files with Apple Notes via CLI

author: shuka


value: akshaysg

value:
Hi HN, I’ve been working on a solution to something I personally view as a problem: increasing amounts of AI Slop in PRs.
I’ve noticed that some contributors on GitHub have been using AI tools (which are great!) to make low-quality contributions to public repos just for the sake of it. These contributions often have duplicate code, hallucinated functions, and other signature problems introduced by AI tooling. This leaves the burden on the maintainers to slog through long AI-generated PRs.
I think this is wrong. There should be a mechanism to flag low-effort PRs that contain AI slop, so that maintainers can skip over reading them.
I rigged up a simple AI slop detector here: https://haystackeditor.com/slop-detector
For fun, I included some AI slop examples and a “can you guess whether it’s slop” game.
Let me know what you think!

value: Show HN: Flag AI Slop in PRs

author: akshaysg

title: Show HN: Flag AI Slop in PRs


value: gidellav

value: Show HN: rv, a non-invasive open source AI code review for any type of workflow

author: gidellav


value: bidwellm

value: Show HN: I built a "news changelog" (rule changes / capital / new capability)

author: bidwellm


value: stewones

value: Show HN: macOS Folder Action script to automate Lightroom → social media exports

author: stewones


value: eigen-vector

value: Show HN: Margin – a Markdown editor that runs /// commands while you write

author: eigen-vector


value: casmn

value: Show HN: Environment variable usage in JavaScript/ts projects

author: casmn


value: og-tech

value:
I found myself in a bit of a muddle while contemplating an apartment purchase. Navigating loan terms, calculating monthly payments, and figuring out the long-term financials was surprisingly confusing. I scoured for tools that could help but found none that fit the bill – understandable and reliable. So I decided to create a solution myself.
Loanwise is specifically designed to simplify complex financial calculations involved in loans, most saliently mortgages. Being available on both Android and iOS platforms, it can assist users in understanding their fiscal commitments clearly.
What sets Loanwise apart is its focus on simplicity and accuracy. No extra complexity — just clear numbers in an easy-to-understand layout. It aims to bridge the chasm between finance jargon and everyday understanding.
Loanwise functions by feeding raw data into pre-set financial formulas, encapsulating things like interest rates, principal amount, etc., to deliver easily understood results. While the underlying computations are complex, the interface itself is streamlined for straightforward use.
And yes, Loanwise is free. I wanted to make sure anyone who needed to make informed financial decisions could do so conveniently.
I'd genuinely appreciate any observations, constructive criticism, or queries regarding Loanwise. It's a venture rooted in a personal pain point, so I'm curious to see how it's perceived or could be improved.
For iOS: https://og-tech.short.gy/H5Vz4L
For Android: https://og-tech.short.gy/uFSY0k

value: Show HN: Loanwise – I built this app to simplify loan calculations

author: og-tech


value: kfarr

value:
Hey I'm Kieran and I've been playing with the intersection (pun intended) of generative AI and civil engineering for roadways. I did a test run training a LoRA on the new Flux 2 Dev model using Fal's trainer useing a custom dataset of paired images from publicly available striping CAD drawings of street layouts to aerial images of the same area.
The use case here is to allow urban planners to instantly visualize their proposed changes as they work with their existing tooling.
This was just a quick experiment with a small data size that exceeded my expectations so I wanted to share with you all.
Watch a demo with instructions on how to test it out: https://www.youtube.com/watch?v=zS8pGoOfe00
Try it now (includes free credits) https://3dstreet.app/generator
If you're really excited about running on your own hardware here are the lora weights: https://v3b.fal.media/files/b/0a87f41f/glySGbKtv8lzigPWzQDjb...
I can writeup a longer blog post if interested in the details. This was only trained on 12 image pairs with text descriptions but it still cost about $100 on Fal. I'd love to do a larger run, but it does take a while to prepare all of the data and I'm hesitant to drop $2k. I'd be curious for the experts out there if you think the quality will increase if I use a larger sample size.

value: Show HN: LoRA Trained on SFMTA CAD Drawings to Aerial Images

author: kfarr


value: rdpharr

value:
I built this plugin because I wanted Netflix-style "recommended for you" in Jellyfin without sending my watch history to any external service. The existing options didn't quite fit what I needed:
- Home Screen Sections only works in the web client — useless on my Roku
- Suggester plugins just match genres, which gets repetitive fast
- External services like Trakt require sending your data out
LocalRecs takes a different approach. It builds TF-IDF embeddings from your library metadata (genres, actors, directors, tags, decades) and creates ~1200-dimension vectors for each item. Then it builds a taste profile from your watch history and ranks unwatched items by cosine similarity. The math is the same stuff used in search engines and basic recommender systems, nothing fancy, but it works surprisingly well. The trick to making it work everywhere (including dumb clients like Roku) is virtual libraries. The plugin creates .strm files pointing to your actual media, and you create Jellyfin libraries pointing to those directories. From the client's perspective, it's just another library with movies in it.
Technical details:
- Per-user personalization (each user gets their own taste profile)
- Favorites get 2x boost, rewatches 1.5x, with 365-day recency decay
- Optional decade similarity (finds content from similar eras)
- Handles 2000+ item libraries without issues
- All processing is local—nothing leaves your server
I'd love feedback, especially from folks with large libraries or unusual viewing patterns. The algorithm is pretty naive right now and there's definitely room to improve it.
edit: formatting

value: Show HN: Jellyfin LocalRecs Plugin – 100% local ML-based movie recommendations

author: rdpharr


value:
Hello HN, I’m the author. I built NIS2 Shield because I saw a dangerous trend: the new EU Cybersecurity Directive (NIS2) is creating a "moat" around Enterprise companies. Because of strict "supply chain security" requirements (Article 21), big companies are stopping to buy software from startups and SMEs that can't prove their compliance.
I didn't want compliance to be a barrier to entry or a bureaucracy nightmare. I wanted it to be an engineering problem.
The core concept: compliance as code. Instead of expensive consultants, we mapped legal requirements directly to code functions.
- Law: "Cryptography & HR security" (Art. 21.e)
- Code: Middleware that handles forensic logging (HMAC-signed), PII encryption, and session guarding automatically.
Why use it (even if you are not subject to NIS2)? Even if you are a small startup and the law doesn't apply to you yet, these are simply sane security defaults. We made features like forensic logging, rate-limiting, and encrypted auditing "plug-and-play". Since it's now trivial to implement (e.g., just adding a middleware), there is no reason not to have "Enterprise-grade" security from Day 1. It makes your product better and "future-proofs" you for when you eventually land that big Enterprise client.
The stack (MIT licensed):
- Backend: Middleware for Django, Express, Spring Boot, and .NET.
- Infra: Terraform modules for AWS/Azure/GCP with security hardening baked in (and toggles to save costs in dev).
- Frontend: React/Vue/Angular guards for client-side telemetry.
Business model (transparency):
- The Truth (Free): All the code to be secure is MIT Open Source. You can use it freely.
- The Proof (Paid): We sell the "Auditor Kit" — an engine that generates the legal PDF reports and audit dashboards for your CISO/Management.
In short: The security is free, the bureaucracy is paid.
I’d love your feedback on the repo structure and the Terraform modules!
Repo: https://github.com/nis2shield
Docs: https://nis2shield.com

value: Show HN: I Turned EU Cyber Laws into Open Source Code


value: barefootsanders

value: Show HN: A Git structure for AI to orchestrate across code, docs, and ops

author: barefootsanders


value: I've been having a lot of issues with my upload speed and wanted a cli tool to run in a cron job and couldn't quite find one to suit my needs. Sharing here in case others find it useful.

value: Show HN: CLI for internet speed test via Cloudflare with optional TUI


value: ekzhang

value: Show HN: Jax-JS, array library in JavaScript targeting WebGPU

author: ekzhang


value: ayushpawar

value:
I built a small browser puzzle based on a graph theory idea I find unintuitive:
You delete tiles from a grid, but the remaining tiles must stay connected.
One wrong move ends the run.
I’ve been using it as a short mental warm-up in the morning, along with a very brief daily news summary.
No login, no feed, no scrolling.
Takes ~5 minutes.
Curious how others approach it or where it breaks.

value: Show HN: A daily puzzle and 90-second brief I built to start my mornings

author: ayushpawar


value:
A growing collection of practical browser tools that never upload your files to servers. Every utility runs 100% client-side, keeping your sensitive data private on your own device.
nouploadtools.com
What is NoUploadTools?
Most online converters and utilities make you upload files to remote servers — meaning your documents, photos, IDs, contracts, or private notes are sent to a third party you don’t control. NoUploadTools takes a different approach:
Everything runs in your browser, so your files never leave your device.
nouploadtools.com
No uploads, no server processing, and no cloud storage.
nouploadtools.com
Tools can even work offline once loaded.
nouploadtools.com
Designed for privacy-aware users — freelancers, legal/professional workflows, students, or anyone wary of uploading sensitive data.
nouploadtools.com
What Tools Are Available
NoUploadTools is more than a single converter — it’s a suite of small, focused utilities all usable in the browser with zero upload:
PDF & Document Tools
Image → PDF
Compress PDF
PDF → Image
Merge PDFs
Remove metadata from documents
… all client-side.
nouploadtools.com
Text & Writing Tools
Base64 Encoder/Decoder
Markdown Editor
Word/Character Count
Text Diff
Text Encryptor
… all processed locally.
nouploadtools.com

  Developer & Utility Tools

Password Generator (crypto-secure & private)
Hash Generator
JSON Formatter
Secure Password Checker
File Encryptor (AES-256 in browser)
… and more.
nouploadtools.com
+1
Other Fun & Useful Stuff
QR Code Generator
Image compression & format tools
Color Picker, Timer, Unit converters
… again, all without uploads.
nouploadtools.com
+1
Why This Matters
There’s a big difference between tools that claim privacy and tools that actually process locally. With NoUploadTools:
Your files never leave your machine.
nouploadtools.com
There’s no server log, no retention policy, and no backend storage you have to trust.
nouploadtools.com
You can do everyday conversions + utilities without worrying about third-party access.
nouploadtools.com
A Quick Example
If you need to merge several PDFs but don’t want to upload confidential files to a server, the Merge PDFs tool lets you:
Drag & drop your files in the browser
Reorder pages
Merge locally
Download the output — with no upload ever happening.

value: Show HN: NoUploadTools – Free Tools that don't upload your files


value:
Open-source Python metric for measuring irreducible structure beyond entropy and compression.
Includes falsifiability tests, golden baselines, and adversarial cases.
Frozen DOI: https://doi.org/10.5281/zenodo.18165777

value: Show HN: Informational Inertia – Measuring irreducible structure beyond entropy


value: I built a card-swiping game (heavily inspired by Reigns) where you play as the US President making AI policy decisions. Balance public opinion, the economy, national security, AI safety, global standing, and AI progress—if any hits 0 or 100, you're done.<p>Would love feedback on balance and card ideas!

value: Show HN: Threshold – A game where you're the POTUS during the AI boom


value:
I built a simple scheduler that creates an autonomous coding loop:

  1. Fetches your highest-priority Linear task
  2. Posts it to Slack with @claude mention
  3. Claude Code picks it up and starts working

value: Show HN: Auto-dispatch Linear tasks to Claude Code web via Slack


value: sqrew

value:
breakrs is a simple CLI timer that accepts natural language durations:
breakrs 5m coffee break
breakrs 1h30m meeting reminder
No cron syntax, just plain English. Runs a daemon, sends desktop notifications.
I also built rmcp-breakrs, an MCP server wrapper, so Claude Code can schedule reminders:
"remind me in 30 minutes to check the build"
→ actually works, notification fires later
Most scheduler MCP servers need cron expressions. This just takes "30m check the build."
Both tools are Rust, single binary install via cargo. Local-only, no cloud.
- breakrs (CLI): https://github.com/sqrew/breakrs
- rmcp-breakrs (MCP): https://github.com/sqrew/rmcp-breakrs

value: Show HN: Breakrs – Natural Language CLI Timer with MCP Server for AI Integration

author: sqrew


value: Show HN: Timer – a timer and stopwatch that stays visible across browser tabs


value: bradvl

value: Show HN: Data.cledara – Real Time SaaS Market Data

author: bradvl


value: Beefin

value: Show HN: Learn Vision Encoders

author: Beefin

title: Show HN: Learn Vision Encoders


value: Show HN: AI attacking AI? Vulnetic offensive security agent compromising models


value: alisinabh

value:
I have been trying Hyperliquid and even though it is a decentralized platform, the UI has geo restrictions which are annoying at best.
This extension modifies some requests that bypasses this geo-lock. Keep in mind that this extension can stop working if there are updates to how geo location restriction is implemented in the hyperliquid UI API.
Needless to say, this extension does not send any data to any third party servers and you have to install it manually as it is not (and most probably never will be) published on any stores.
Enjoy the (probably short term) freedom!

value: Show HN: Bypass Geo-Restriction of Hyperliquid.xyz with a simple browser ext

author: alisinabh


value: krenerd

value: Honestly, we all wiggled our mouse to change the idle status. I've personally used this and it works like magic!

value: Show HN: "slack.green" – keep Slack active

author: krenerd


value: mrlesk

value:
Hello HN,
Inspired by Andrej Karpathy's "LLM Council" concept, I built a lightweight MCP (Model Context Protocol) server that lets different AI agents communicate with each other locally.
Most multi-agent frameworks require complex orchestration or heavy installs. I wanted something simple that feels like it "just works".
The Problem: I often find myself manually copy-pasting context between coding agents (like Claude Code to Codex or vice versa) to get a second opinion.
The Solution: Agents Council is an MCP server that acts as a shared message bus. It runs locally via stdio and allows any MCP-compliant agent to "summon" other agents into a council session to debate solutions or review code.
Key Features:
Zero Install: Runs directly via npx agents-council@latest.
Summon other agents: agents can also summon other agents directly (for the moment only Claude Code is supported)
Privacy First: Works 100% offline if you are using local models; state is stored in a local JSON file.
Protocol Agnostic: Works with any client that supports MCP (Gemini, Cursor, etc.).
It’s open source and I’d love your feedback on the implementation or ideas for new integrations.
Repo: https://github.com/MrLesk/agents-council

value: Show HN: Agents Council – Connect Claude, Codex, and Local Agents via MCP

author: mrlesk


value: friggeri

value: Show HN: I built a portable Yahtzee device with custom PCB and WASM simulator

author: friggeri


value:
Built a free open source agentic CLI tool for financial modeling & analysis. Hadn't played around with real equity valuation modeling for awhile and wanted to build tooling to get myself back into the game.
Bull.sh lets you query & store 10-Qs, 10-K in a local vector store to chat with them, build investment thesis from scratch or build full framework models through the CLI to export into excel.
It's open source, just requires your own Anthropic API key and (optionally) AlphaVantage Free API key if you want save some tokens from scraping. Feel free to play around with it.
Some ideas I have for features (amongst improvements to the existing orchestration & valuation frameworks):
1. Bull vs. Bear Agent Debate
Spawn two adversarial agents: one argues the bull case, one argues the bear case. They critique each other's assumptions, then a moderator agent synthesizes a balanced thesis. Surface the strongest counterarguments automatically.
2. Earnings Call Analyzer
Auto-fetch earnings call transcripts (or transcribe audio), detect management tone shifts vs. prior quarters, extract forward guidance, flag hedging language ("we believe", "challenging environment"). Compare CEO sentiment to online & social sentiment.
3. Supply Chain Knowledge Graph
Parse 10-K supplier/customer disclosures + news to build a graph of company relationships. Visualize dependencies, detect concentration risk, propagate shocks ("if TSMC goes down, who's exposed?"). Use Neo4j or networkx.
4. Real-time 8-K Alert System
Monitor SEC EDGAR for new 8-K filings, classify by materiality (executive departure, M&A, guidance change), push alerts via webhook/Slack/email. Let users set watchlists and filter by event type.
5. Thesis Backtester
Save thesis snapshots with timestamps. When the stock moves ±20%, resurface the original thesis and score which predictions were right/wrong. Build a track record dashboard showing analyst accuracy over time.

value: Show HN: Bull.sh: Financial Modeling Agent CLI


value: adilhafeez

value:
Hey HN — I’m Adil from Katanemo (with Salman, Shuguang, and Meiyu)
We previously shared an early version of this project as ArchGW. Based on customer feedback, the scope expanded from “LLM routing and model access” into something broader: delivery infrastructure for agentic applications. We renamed it to Plano and reworked the architecture accordingly.
The problem
On-the-ground AI practitioners will tell you that calling an LLM is not the hard part. The really hard part is delivering agentic applications to production quickly and reliably, then iterating without rewriting system code every time. In practice, teams keep rebuilding the same concerns that sit outside any single agent’s core logic:
This includes model agility — the ability to pull from a large set of LLMs and swap providers without refactoring prompts or streaming handlers. They need to learn from production by collecting signals and traces that tell them what to fix. They need consistent policy enforcement for moderation and jailbreak protection, rather than sprinkling hooks across codebases. And they need multi-agent patterns like handoff and specialization without turning their app into orchestration glue.
These concerns get rebuilt and maintained inside fast-changing frameworks and application code, coupling product logic to infrastructure decisions. It’s brittle, and pulls teams away from core product work into plumbing they shouldn’t have to own.
What Plano does
Plano moves core delivery concerns out of process into a modular proxy and dataplane designed for agents. It supports inbound listeners (agent orchestration, safety and moderation hooks), outbound listeners (hosted or API-based LLM routing), or both together.
Plano provides the following capabilities via a unified, protocol-native, framework-friendly dataplane:
- Orchestration: Low-latency routing and handoff between agents. Add or change agents without modifying app code, and evolve strategies centrally instead of duplicating logic across services.
- Guardrails & Memory Hooks: Apply jailbreak protection, content policies, and context workflows (rewriting, retrieval, redaction) once via filter chains. This centralizes governance and ensures consistent behavior across your stack.
- Model Agility: Route by model name, semantic alias, or preference-based policies. Swap or add models without refactoring prompts, tool calls, or streaming handlers.
- Agentic Signals™: Zero-code capture of behavior signals, traces, and metrics across every agent, surfacing traces, token usage, and learning signals in one place.
The goal is to keep application code focused on product logic while Plano owns delivery mechanics.
More on Architecture
Plano has two main parts:
Envoy-based data plane. Uses Envoy’s HTTP connection management to talk to model APIs, services, and tool backends. We didn’t build a separate model server—Envoy already handles streaming, retries, timeouts, and connection pooling. Some of us are core Envoy contributors at Katanemo.
Brightstaff, a lightweight controller written in Rust. It inspects prompts and conversation state, decides which upstreams to call and in what order, and coordinates routing and fallback. It uses small LLMs (1–4B parameters) trained for constrained routing and orchestration. These models do not generate responses and fall back to static policies on failure. The models are open sourced here: https://huggingface.co/katanemo
Plano runs alongside your app servers (cloud, on-prem, or local dev), doesn’t require a GPU, and leaves GPUs where your models are hosted.
Repo https://github.com/katanemo/plano + docs https://docs.planoai.dev/

value: Show HN: Plano – Edge and service proxy with orchestration for AI agents

author: adilhafeez


value: kuberwastaken

value:
GitHub READMEs don’t support JavaScript, iframes, or WebAssembly,
so how does someone run DOOM on it at all?
I built DoomMe (great name, I know) with a stateless graph of 8000+ Markdown files and WebP images of every possible position you can be or face towards on the E1M1 map to make it one very big "choose your own adventure" book on GitHub.
Open Source with MIT License
- GitHub repo: https://github.com/Kuberwastaken/DoomMe
- Play it on my profile: https://github.com/Kuberwastaken

value: Show HN: Doom Playable in a GitHub Readme

author: kuberwastaken


value: silverrump

value:
Hi HN,
I built DevicePrint after running into problems with
duplicate accounts and unreliable cookies in my own projects.
DevicePrint is a lightweight device fingerprinting tool
designed for developers. It helps identify devices across sessions
without relying on cookies.
Use cases include fraud detection, preventing duplicate signups,
and security-sensitive workflows.
I'd really appreciate feedback — especially around privacy
concerns or edge cases you’ve run into.
Link: https://deviceprint.io

value: Show HN: DevicePrint – device fingerprinting without cookies

author: silverrump


value: sieep

value:
Hi HN,
This is my first project I ever did with Python a while ago, I use this app weekly to help manage my business relationship data.
It's essentially just a spreadsheet with less functionality, so don't have high expectations. I would highly recommend a spreadsheet over this.
It was a way for me to learn more about desktop GUI development using Python and Tkinter.

value: Show HN: A simple, local-only CRM desktop app built with Python/Tk and SQLite

author: sieep


value: shaneos

value: Show HN: Convert GIFs to MP4 purely on client side

author: shaneos


value:
DeskSlice is a small Go tool that lets you remotely view and control a VS Code AI agent from a mobile browser.
The problem I wanted to solve was very practical: I wanted to comfortably interact with a local VS Code agent (read outputs, scroll, and type prompts) from my phone, without reimplementing the UI or relying on editor internals or private APIs.
Instead of building a full remote desktop, DeskSlice streams only a calibrated slice of the desktop where the agent UI lives, and maps touch gestures back to mouse and keyboard input on the host.
I originally implemented this using WebRTC, but after hitting reliability and complexity issues (signaling, renegotiation, RTP quirks), I pivoted to MJPEG over HTTP. For LAN use, MJPEG turned out to be much simpler, easier to debug, and reliable enough for UI-driven workflows.
Key ideas:
- Manual fullscreen calibration to select the exact agent panel, input area, and scroll area
- Cropped video stream (not the full desktop)
- Touch-first interaction model (tap, drag-scroll, typing)
- No UI scraping, no state persistence — it operates the real VS Code agent UI
- Simple password gate for LAN use
This is intentionally not a general-purpose remote desktop. It’s a focused control surface for interacting with a local AI agent through its existing UI.
Repo: https://github.com/frudas24/deskslice/

value: Show HN: DeskSlice – controlling a VS Code agent from my phone


value: rokontech

value: Show HN: Free: Stop Copying CodeRabbit Reviews – Export Them as Markdown

author: rokontech


value: Hey, in the vast majority of push-based systems (think slack, shopify, or even custom entreprise ones) there are quite a lot of things you end up building (bufferization, errors, replays, ratelimiting, concurrency ...) before having a production-ready system.<p>Basehook is designed to solve these problems for you, you have a UI where you can configure and inspect/replay webhook payloads, and a single API you can consume in a pull-based way so you don't have to worry about being overwhelmed in case there is a spike.

value: Show HN: Basehook – consume, inspect or replay any webhook event


value: csmets

value: Show HN: I've spent the year scraping Steam, here are the results for 2025

author: csmets


value: scottatmu

value:
Over winter break, instead of the usual “kids playing in the snow” thing, we ended up doing something a little different. Mostly because it was abnormally warm, and partly because my kid had other ideas.
We built a small iPhone game together.
My son is a second grader and loves baseball. For years, our family has played a simple dice-based baseball game at restaurants while waiting for food. No screens. Just dice, rules scribbled on napkins, and a lot of arguing over whether something was a double or a ground out. It’s been one of those low-tech things that quietly stuck.
On the first night of winter break, he asked if we could turn it into an actual game.
So we did.
We spent the week breaking down how baseball works, how turns and randomness feel fair, and how games should be quick and fun. I introduced him to basic iPhone development concepts, UI thinking, and how we can use AI as a helper. Not to do the work for us, but to brainstorm, prototype, and iterate faster.
He was immediately hooked.
One of my favorite moments: he came up with a “7th minute stretch” idea. If a game session goes long enough, the app pauses and encourages you to get off the phone for 30 seconds. Do jumping jacks, grab water, stretch, whatever. It’s intentionally anti-doomscrolling, and very much his idea.
The result is Dice Baseball. A simple, fast, family-friendly dice baseball game for iPhone. No accounts. No ads. No paid features. There’s an optional tip jar if someone wants to support it, but that’s it.
For me, the best part wasn’t shipping the app. It was watching a kid realize that software isn’t magic. It’s something you can build, improve, and think critically about. He’s already talking about updates and new ideas.
If you’re curious, here it is ... https://apps.apple.com/us/app/dice-baseball/id6757132879
Thanks for checking it out.

value: Show HN: A dice baseball game I built with my second grader over winter break

author: scottatmu


value: Show HN: I built a dashboard that tracks corporate political donations


value: flyingriverhrse

value:
Hi HN,
I built Skyulf because I kept encountering two specific problems that existing tools (like MLflow or standard Scikit-learn pipes) didn't quite solve for me: silent data leakage and monolithic pickles.
## The Problems
1.  Data Leakage is Silent: You compute mean imputation on the full dataset, then split. Your model looks great in dev but fails in production. It happens to the best of us.
2. Deployment Hell (The Pickle Problem): Standard pipelines pickle everything data schema, logic, and 3rd party library versions into one opaque blob. To run a simple inference, you need the same heavy environment used for training.
## The Solution: Distinct Calculator & Applier
Skyulf enforces a strict separation of concerns using a Calculator / Applier pattern (inspired by modern engine design).
1. Calculator (Fit): Consumes data (`X`, `y`), learns the state (means, vocabularies, coefficients), and outputs a lightweight, JSON-serializable Artifact.
2. Applier (Predict): A pure function. Consumes the Artifac + New Data -> Output.
Why this matters: You can train on a massive GPU cluster, save just the lightweight JSON artifacts (state), and run the Applier on a tiny CPU instance. The Applier is stateless.
3. Structural Leakage Prevention:
We use a `SplitDataset` abstraction. Transformers receive train/test/val as a single object but are mathematically forced to compute statistics on `.train` only.
```python
from skyulf import SkyulfPipeline<p>config = {
    "preprocessing": [
        # Split happens FIRST. Leakage is structurally impossible.
        {"name": "split", "transformer": "TrainTestSplitter", "params": {"test_size": 0.2}},
        {"name": "impute_age", "transformer": "SimpleImputer", "params": {"columns": ["age"], "strategy": "mean"}},
        {"name": "scale_income", "transformer": "StandardScaler", "params": {"columns": ["income"]}},
    ],
    "modeling": {"type": "random_forest_classifier", "params": {"n_estimators": 100}}
}<p>pipeline = SkyulfPipeline(config)
pipeline.fit(df, target_column="target")
pipeline.save("model.pkl")
```
## Features
1. Polars-First (~3.5x Faster):
We migrated the core engine from Pandas to Polars. Lazy evaluation means we can scan generic CSV/Parquet files instantly for EDA.
2. One-Liner EDA:
Generates a comprehensive profile (quality, outliers, VIF, causal graphs) in seconds.
```python
from skyulf.profiling.analyzer import EDAAnalyzer
from skyulf.profiling.visualizer import EDAVisualizer
import polars as pl<p>df = pl.read_csv("data.csv")
profile = EDAAnalyzer(df).analyze(target_col="churn")<p>viz = EDAVisualizer(profile, df)
viz.summary()  # Terminal dashboard
viz.plot()     # Matplotlib distributions & correlations
```
3. Visual ML Canvas (Local-First):
A React-based drag-and-drop UI (running locally via FastAPI) that lets you visually debug pipelines. You can click any node to see data stats at that exact point in the pipeline.
## Why Another Tool?
- vs MLflow: We focus on the construction and execution of the pipeline, not just tracking the metrics.
- vs Scikit-learn Pipelines: We separate state (Artifacts) from logic (Appliers) and enforce leakage checks.
- vs Cloud Platforms: Skyulf is self-hosted. Your data never leaves your machine.
## Current Status
The library skyulf-core is stable on PyPI. The visual platform is functional but still being polished. I'm a solo dev building this in public.
I'm building this in public and would love your feedback. If you find this interesting, a star on GitHub would mean a lot! I'm also looking for contributors if you're into Python, React, or MLOps, check out the issues.
---
*Links*:
- Repo: https://github.com/flyingriverhorse/Skyulf
- PyPI: https://pypi.org/project/skyulf-core
- Docs: https://www.skyulf.com

value: Show HN: I built a visual, MLOps tool (Skyulf)

author: flyingriverhrse


value: Pastaza

value: Show HN: Cardly. A gift card tracker built with Next.js 14, TypeScript

author: Pastaza


value:
Originally learned about image hashing and similarity comparison for product image searches. Decided to apply it to magazine covers.
Thrasher covers: https://shoplurker.com/labs/thrasher-covers/

value: Show HN: Finding similarities in New Yorker covers


value: sauercrowd

value:
Git worktrees are great, but the syntax is much more involved, and requires me to decide where worktrees go which I dont really care.
gtree is a simple shell script which provides two commands to fully your workflow:
gtree add <branch>: create a new worktree for a branch in a default directory and cd to it. if branch doesnt exist, create it.
gtree packup: remove the current worktree and change back to the main repo. Optionally immediately change to the worktree branch using `-c`
Been using it for a few days and it works really well for me - curios what y'all think!

value: Show HN: Gtree, a simple convention based worktree manager

author: sauercrowd


value: stevenslade

value:
NoMe is an experimental identity verification system that authenticates you based on your personal preferences and quirks instead of passwords.
Is this a good authentication idea? Absolutely not! It was fun to explore conversational AI for identity. It has been described to me as "the most annoying thing ever built."
During enrollment, it asks you creative questions like:
- "What music do you NOT like when working?"
- "What notification sound makes you check your phone immediately?"
- "If you could only have one condiment for everything, what would it be?"
At login, it challenges you with variations of those questions, sometimes flipping the polarity ("What do you dislike?" instead of "What do you like?"), and adding honey pot questions to check consistency.
Under the hood: semantic embeddings, NLI scoring for contradiction detection, and GPT-4o-mini for question generation and answer canonicalization.

value: Show HN: NoMe AI Authentication (a bad way to login)

author: stevenslade


value: EricBrandon

value:
Hi. My name is Eric Brandon and I’ve built an AI chat app that feels really different.
While you talk with an AI model in a chat pane, a second AI model is reading over the conversation and seeking out useful, interesting, surprising, amusing, and fact-checking information that wouldn’t have appeared in the main chat.
You can read those “discoveries” on their own, or click them into your main chat to steer the conversation in a new direction.
This is based on the observation that talking to smart people is usually more enjoyable, interesting, and informative than talking to a smart AI.
There’s many possible reasons why - the AI isn’t smart enough, it has no “real” emotions, it has no real long-term memory of your relationship, and so on.
But certainly one big reason is that the AI has been trained and instructed to simulate a “helpful assistant.”  And helpful assistants stay on topic.  They don’t interject with something super interesting, or wise, that is only thematically related.   They don’t chime in with amusing related anecdotes.  They don’t complicate the conversation with contrasting views.
I find this chat experience much much more interesting and useful than any of the first person apps from Anthropic, openAI, or Google.
This is combined with many power-user features like branching conversations, access to powerful models like chatGPT 5 Pro without a subscription, sophisticated output for sharing chats, and much more.
I find the freedom of having access to all the latest big-lab models in one app, and even in one chat, extremely convenient.
This app is a bit of a glimpse into the future, I believe.  Today’s AI ecosystem means that having this experience:
- Requires more technical sophistication than the average user because you need to bring your own API keys
- Costs more than regular chat, because you can’t benefit from subsidized monthly plans, and because the “discoveries” add to the AI token costs of every conversation
But this user experience is so much better than the standard one that it’s hard to believe, in the future, when you can bring your subscriptions to third-party apps, and when inference is cheaper, that this won’t become the standard experience.
You can read about the app and download it at https://sidestream-app.com and https://github.com/ericbrandon/sidestream
It’s a non-commercial, open-source project built just because I wanted it for myself, but I hope you enjoy too!

value: Show HN: Sidestream – an AI chat app with a side of insight

author: EricBrandon


value: ManfredMacx

value:
Dumping a 50k-row spreadsheet into an LLM context is expensive and usually unnecessary. Most tasks need surgical access ie: find a region, profile its structure, read a filtered slice.
SpreadsheetMCP is a Rust MCP server with 20+ tools that let agents discover -> profile -> extract without burning tokens on cells they don't need. Supports xlsx/xlsm, VBA inspection, formula tracing, what-if analysis via forks, and headless screenshots via LibreOffice.
In my testing, agents handle sweeping refactors both in formulas and formatting quite effectively!

value: Show HN: SpreadsheetMCP – Token-efficient Excel tools for LLM agents (Rust)

author: ManfredMacx


value: alxwlcx

value:
We built this stack last summer while working on AI voice agents for healthcare practices.
Twilio worked well functionally, but its HIPAA option started at $2k per month before a single call, and that fixed cost dominated almost immediately, long before usage-based costs like LLM tokens mattered. That imbalance pushed us to build and operate our own telephony layer.
This repo is the result. It's a self-hosted, HIPAA-eligible telephony stack built on Asterisk + AWS Chime that handles phone numbers, SIP/TLS, RTP media, and real-time audio streaming to AI voice agents via a Twilio-like WebSocket interface. A shim server bridges audio to modern WSS-based AI services. You bring the voice AI. This just handles the phone infrastructure. (Example server using OpenAI Realtime API for voice-to-voice included in repo.)
We've since moved on to other projects, but as AI voice agents keep proliferating, we noticed we couldn't find a comprehensive, open-source, self-hostable option in this space. Rather than let it sit unused, we cleaned it up and open-sourced it.
This isn't for everyone. If you don't want to run infrastructure, Twilio is still the easiest option.
Happy to answer questions about architecture, trade-offs, scaling, or design decisions!
---
Blog post: https://vectorly.app/blog/open-telephony-stack

value: Show HN: An open-source telephony stack for AI voice agents (Twilio alternative)

author: alxwlcx


value: jcubero

value: Show HN: Free AI meditation guide in 8 languages – voice-enabled, 100% private

author: jcubero


value: anubioz

value: Show HN: A place to share your LLM dialogues

author: anubioz


value: nsomani

value:
Hi HN, I've been exploring various applications of formal methods to ML/interpretability and I've been hoping to get more eyes on the approach.
I have been working on a small interpretability project I call Symbolic Circuit Distillation. The goal is to take a tiny neuron-level circuit (like the ones in OpenAI's "Sparse Circuits" work) and automatically recover a concise Python program that implements the same algorithm, along with a bounded formal proof that the two are equivalent on a finite token domain.
Roughly, the pipeline is:
1. Start from a pruned circuit graph for a specific behavior (e.g. quote closing or bracket depth) extracted from a transformer.
2. Treat the circuit as an executable function and train a tiny ReLU network ("surrogate") that exactly matches the circuit on all inputs in a bounded domain (typically sequences of length 5–10 over a small token alphabet).
3. Search over a constrained DSL of common transformer motifs (counters, toggles, threshold detectors, small state machines) to synthesize candidate Python programs.
4. Use SMT-based bounded equivalence checking to either:
   - Prove that a candidate program and the surrogate agree on all inputs in the domain, or
   - Produce a counterexample input that rules the program out.
If the solver finds a proof, you get a small, human-readable Python function plus a machine-checkable guarantee that it matches the original circuit on that bounded domain.
Why I built this
Mechanistic interpretability has gotten pretty good at extracting "small crisp circuits" from large models, but turning those graphs into clean, human-readable algorithms is still very manual. My goal here is to automate that last step: go from "here is a sparse circuit" to "here is a verified algorithm that explains what it does", without hand-holding.
What works today
- Tasks: quote closing and bracket-depth detection from the OpenAI circuit_sparsity repo.
- Exact surrogate fitting on a finite token domain.
- DSL templates for simple counters, toggles, and small state machines.
- SMT-based bounded equivalence between:
  sparse circuit -> ReLU surrogate -> Python program in the DSL.
Limitations and open questions
- The guarantees are bounded: equivalence is only proven on a finite token domain (short sequences and a small vocabulary).
- Currently focused on very small circuits. Scaling to larger circuits and longer contexts is open engineering and research work.
- The DSL is hand-designed around a few motifs. I am not yet learning the DSL itself or doing anything very clever in the search.
What I would love feedback on
- Are the problem framing and guarantees interesting to people working on mechanistic interpretability or formal methods?
- Suggestions for next benchmarks: which circuits or behaviors would you want to see distilled next?
- Feedback on the DSL design, search strategy, and SMT setup.
Happy to answer questions about implementation details, the SMT encoding, integration with OpenAI's Sparse Circuits repo, or anything else.

value: Show HN: Symbolic Circuit Distillation: prove program to LLM circuit equivalence

author: nsomani


value:
A simple tool to filter out ad-supported kids' apps from the Apple App Store.
It may not catch everything, but it's better than nothing.

value: Show HN: I built a filter for ad-free kids' apps on the App Store


value: rokontech

value: Show HN: Sumoffy (macOS) – Offline Document Intelligence You Can Trust


value: Show HN: Secretctl – AI-safe secrets manager with MCP integration


value: marcelomollaj

value:
I built a SCIM 2.0 gateway library for Go that makes it straightforward to expose any backend as a standards-compliant identity provider.
SCIM (System for Cross-domain Identity Management) is the standard protocol for user provisioning between systems like Okta, Azure AD, and your application. Existing Go implementations were either incomplete or unmaintained.
Key technical decisions:
- Plugin pattern: backends return raw data, library handles protocol (filtering, pagination, PATCH operations)
- Full RFC 7643/7644 compliance: all filter operators, complex path expressions, bulk operations with cycle detection
- Per-plugin authentication: each backend can use different auth (Basic, Bearer, custom JWT)
- Minimal dependencies: only google/uuid, uses stdlib for everything else
- Thread-safe: proper mutex usage, 76% test coverage, zero panics
Can run as standalone server or embedded http.Handler. Includes SQLite, PostgreSQL, and in-memory examples. The plugin interface is simple:

    func (p *Plugin) GetUsers(ctx context.Context, params QueryParams) ([]*User, error) {
        return p.db.GetAllUsers(), nil  // Library handles filtering, pagination, etc...
        // Or you can optimize your queries by using params
    }

Inspired by the Node.js scimgateway but redesigned for Go's type system and concurrency model.
GitHub: https://github.com/marcelom97/scimgateway
Happy to discuss design tradeoffs and answer questions!

value: Show HN: SCIM Gateway for Go – RFC-compliant server with plugin architecture

author: marcelomollaj


value: seridarivus

value: PLI 7 is an AI build to give you the best context via wikipedia images using their API. Is free

value: Show HN: PLI 7–An AI engine that anchors visual context to Wikipedia for YTauto

author: seridarivus


value:
I built Kurisu to solve a specific problem I kept encountering: analyzing sensitive data in offline settings without IT approval or cloud uploads and without needing to login and out of accounts on every device i own.
The constraints led to interesting technical decisions:
*Single-file architecture:* The entire app is one HTML file. No build process, no npm install, no deployment. You can WhatsApp it to yourself and open it on any device with a browser. This bypasses corporate IT restrictions and makes distribution trivial.
*Statistical engine in Web Workers:* Implements Spearman Rank Correlation, Kruskal-Wallis, and Mann-Kendall tests client-side. The automated dashboard scores potential visualizations by statistical significance rather than generating random charts.
*Local-first processing:* All data stays in the browser. Useful for compliance-heavy scenarios (HIPAA, financial data, NDAs) where cloud analytics tools are prohibited.
*Real use case:* I work 9am-9pm, then code nights. During potential investor/client meetings over coffee, being able to drop their Excel file into Kurisu and generate insights in 30 seconds without "let me set this up in Excel" has been valuable.
*Technical tradeoffs:*
- Export occasionally crops at bottom edge (html2canvas limitation, fixing in v1.1)
- Single file = harder to maintain at scale, lots of things break all the time but distribution simplicity wins for now
Future plans: Optional AI model integration (bring your own API/local LLM), embedded tiny model experiments, desktop wrapper if there's demand.
This is my first shipped product after 3 months of learning to code via AI assistance. Would especially appreciate feedback on:
1. The statistical implementation correctness
2. Single-file distribution model viability
3. Technical debt concerns as it grows
4. ways to be able optimise the app to work with
with larger datasets and more complex calculations within the web worker.
Built from Pakistan where most SaaS pricing doesn't make sense. $29 one-time felt right but feedback on this would be appreciated as well.

value: Show HN: Kurisu – Statistical dashboard in a single HTML file


value: DeusCodex

value: Show HN: BlockFrame – A local, erasure-coded storage engine in Rust

author: DeusCodex


value: tdortman

value: Show HN: GPU Cuckoo Filter – faster queries than Blocked Bloom, with deletion

author: tdortman


value: rowanajmarshall

value: Show HN: 25 years of house prices in England and Wales

author: rowanajmarshall


value: claygood

value: Show HN: TPU-doc – A zero-dependency diagnostic tool for Google Cloud TPU health

author: claygood


value:
Prysm – https://prysmhq.com
Google Analytics but with a 3D globe that shows visitors landing in real-time, a timeline that makes sense, and an AI you can actually ask questions.
No cookies. <5KB script. Built in a month.
The globe view is oddly addictive – watching dots appear as people discover your site is way more satisfying than staring at boring charts.
Tech: Next.js, Three.js, Supabase, OpenAI. Free during beta.
Would love your feedback!

value: Show HN: I made analytics you want to watch


value: blackmac

value:
I built a collection of small, useful MCP tools that give LLMs real-world capabilities.
Tools include: DNS lookups, WHOIS, domain age/authority checks, weather, currency conversion, unit conversion, QR code generation, timezone handling, and more.
Free: 10 requests/hour per IP
Free with login: 60 requests/hour (OAuth via GitHub/Google)
No paid tier, no credit card. Just add stellarmcp.com/mcp to your Claude config and the tools are available.
Happy to answer questions about the implementation or MCP protocol.

value: Show HN: StellarMCP – Free MCP Tools for Claude and Other LLMs

author: blackmac


value: zrmarine

value:
Hi all,
Context:
I have been working on a recommender system to help find open source data for LLMs.
What it does:
This is an MVP that finds data to help models learn concepts based on a use case provided by the end-user. The MVP uses perplexity as a benchmark to demonstrate couterfactual performance.
The thesis:
Both small LLMs that are specialized and frontier models suffer from the same problems. The current state is to drag net data collection and train on vastnesses of the internet hoping for a marginial gain in performance. This is not sustainable for incremential gains.
By helping to help guide and prioritize which data should be learned, there should be a significant reduction in resources without a loss in capability.

value: Show HN: Dowser – Training Data Recommendation System

author: zrmarine


value: luthiraabeykoon

value:
The biggest shift is that Julie now supports fully local LLMs and agentic workflows. It’s no longer limited to answering questions about what’s on screen. It can now run writing and coding agents, and optionally take concrete actions on your computer under supervision.
What’s new:
- Local LLM support. Julie can now run entirely on-device,
- Agentic computer use. I added a computer-use mode with demos showing multi-step actions like clicking, typing, and navigation.
- Writing and coding agents. Draft, refactor, and iterate in-place without moving into a separate workspace.
- Installers are now available, so setup is a lot simpler.
- Significant performance improvements across startup time, memory usage, and latency.
I also wrote a full walkthrough and demos covering how the agents work and where the boundaries are:
https://tryjulie.vercel.app/
Repo + installers:
https://github.com/Luthiraa/julie
Thanks for all the support and feedback. From the bottom of my heart, I really appreciate it. I’ve loved building this, and it’s been one of the fastest things I’ve taken from idea to something real that people are actually using. I really love this community.
If you enjoyed checking it out, a star on the repo would mean a lot and helps more people find it.

value: Show HN: Julie update – local LLMs, CUA, installers and perf gains

author: luthiraabeykoon


value:
A fast SOCKS5 proxy that tunnels your traffic through what looks like normal SMTP email, bypassing Deep Packet Inspection firewalls.
How it works:
- Client runs a local SOCKS5 proxy (127.0.0.1:1080)
- Traffic is sent to server disguised as SMTP (EHLO, STARTTLS, AUTH)
- DPI sees legitimate email session, not a VPN/proxy
Features:
- One-liner install on any Linux VPS
- Multi-user with per-user secrets and IP whitelists
- Auto-generated client packages (just double-click to run)
- Auto-reconnect on connection loss
- Works with any app that supports SOCKS5
Tech: Python/asyncio, TLS 1.2+, HMAC-SHA256 auth
GitHub: https://github.com/x011/smtp-tunnel-proxy

value: Show HN: SMTP Tunnel – A SOCKS5 proxy disguised as email traffic to bypass DPI


value:
works for any asset and any art style
demo video: https://www.youtube.com/watch?v=gmnlHLmgO4U

value: Show HN: I built an app for animating game sprites


value: kianae

value:
Hi HN, I am Kiana, I was an AI researcher for 10 years, and since last November I have been working on Vy.
Vy is a desktop app for Mac and Windows. It sees your screen and controls mouse and keyboard to automate workflows across apps, including ones without APIs.
I know there is a lot of skepticism about AI agents, and I share some of it. A lot of things in this space look impressive in demos and then fall apart on real, boring work. So here are a few concrete things that Vy does today that we and early users actually rely on:
Where it works best
Tasks that you could explain in a paragraph and that take a human a few minutes, not hours.
Workflows that mostly involve clicking, typing, scrolling, and copying between a few known tools.
Where it does not work well
Very long, unsupervised runs. It is better to keep tasks bounded and keep an eye on it.
Pixel precise work like detailed design or brush based editing.
Some custom web editors or highly dynamic UIs still confuse it.
How it is different from most browser agents
It runs as a desktop app, so it can automate native apps, browser, and mixed workflows across multiple windows.
It does not depend on app specific APIs or DOM selectors, it operates on what is actually on screen.
You can watch each step, pause, or take over at any time, and you can turn successful runs into reusable workflows.
I am happy to answer detailed questions about failure modes, technical choices, and where this approach breaks. I am also very interested in concrete tasks where you think a UI level agent would either clearly help or clearly not be trustworthy.

value: Show HN: Vy, a cross platform AI agent that automates apps without APIs

author: kianae


value: chynnahe

value: Show HN: Funboxie – Free printables and coloring pages for kids

author: chynnahe


value: khoslaj

value:
Most websites no longer need a CMS. With an AI assistant and hostbento, anyone can build and run a site using prompts: blogs, portfolios, even small e-commerce stores.
the hostbento mcp server allows you to connect your ai assistant to the hostbento mcp server and host your webpages that you may have created via an ai assitant.
For fine tuning changes we also have an accompanying chrome plugin.
Do try and provide feeback.

value: Show HN: Hostbento.com – MCP server to host websites designed in AI assistants

author: khoslaj


value: osigurdson

value: A video demonstration of how to integrate PostHog surveys with Nthesis (hint: its easy!) and how to use it uncover themes / insights when you have a lot of responses.

value: Show HN: Nthesis PostHog Survey Integration [video]

author: osigurdson


value: brianchanwh

value: Show HN: Live UV Index Tracking of Your Location

author: brianchanwh


value: trissim

value:
I formalized a proof that the structural vs. nominal typing debate can't be won: any fixed-axis type system necessarily fails for some domain.
The core result: for a type system with fixed axes (like structure, inheritance, hierarchy), there exists a domain whose requirements cannot be fully captured. This isn't a limitation of specific languages, it's a mathematical impossibility result.
What's in the zip
Full Lean 4 formalization (compiles with lake build) Instantiations for Python, TypeScript, Java, and Rust The axioms for type system structure are extracted from actual language specifications, not invented
Main theorem: For any fixed-axis type framework, there exists a domain D such that no complete typing is achievable.
Let me know there are any holes or if this ends the structural vs nominal typing debate.

value: Show HN: Proof that any fixed-axis type system fails for some domain (Lean4)

author: trissim


value: vaandeetttt

value:
NotebookLM doesn't have a public API, so I reverse-engineered it. Now you can programmatically access everything NotebookLM offers.
I'm excited to share 'notebooklm-kit', open-sourced TypeScript SDK for programmatic access to Google NotebookLM.
You can find it on Github here : https://github.com/photon-hq/notebooklm-kit
Happy to answer questions!

value: Show HN: I built an open-sourced TypeScript SDK for Google NotebookLM

author: vaandeetttt


value:
Hello HN,
I'm the developer of LensFlowPro. I built this because I was frustrated with the current state of screen recording on macOS:
QuickTime is native but lacks system audio recording (without third-party plugins) and camera overlay.
OBS is powerful but feels too heavy and complex for quick demos.
Electron apps often drain battery and feel sluggish.
Tech Stack:
It's a 100% native app built with Swift and AVFoundation. It uses the ScreenCaptureKit API (introduced in macOS 12.3) for high-performance capture with minimal CPU usage.
Key Features:
 System Audio Capture
 Mouse Highlights
 Camera Overlay
 Battery-friendly
It's a paid app (one-time purchase), but here are some promo codes for the HN community to try it out:
H3MWYLAX4YRX
6PL3MFTKTWEF
LFHW373HME6Y
I'd love to hear your feedback on the implementation or feature requests!

value: Show HN: LensFlowPro – Native macOS screen recorder with system audio capture


value: Show HN: LeetCode on Steroids

title: Show HN: LeetCode on Steroids


value: cottomzhang

value:
Enclose Horse is an addictive daily puzzle game where you strategically place walls to trap horses within a grid. Maximize your enclosed area to climb the global leaderboard. A new puzzle awaits every day!
The goal is simple: place walls on the grid to prevent the horse from escaping to the edges. The larger the area you enclose, the higher your score. But choose wisely - you only get one official submission per day!<p>Place walls by clicking or tapping on grid edges
Block escape routes - horses can't move diagonally or over water
Maximize your score - bigger enclosures mean bigger points
Catch cherries for bonus points when available

value: Show HN: Enclose Horse – Daily Puzzle Game

author: cottomzhang


value:
I built Atticus, a framework-agnostic voice agent library that lets users control UI with voice commands.
It is a ts library client side meant to be used in frontend. It can be used to fill complex forms or do multi-step interaction. Built on top of OpenAI realtime agents
Current Limitations
1. Does not handle full redirection
2. Basic events only

value: Show HN: Library for HTML interaction using voice agent


value:
I got tired of doom-scrolling and skimming headlines that all blur together, so I built a small site that turns today’s tech and startup news into a calm, continuous radio-style stream.
No playlists. No jumping tabs. You just press play and listen.
It updates throughout the day and feels more like tuning into a station than consuming feeds.
Curious if this kind of “news radio for the internet” makes sense or if it’s just me

value: Show HN: Tera.fm – A calm, radio-style way to listen to today's tech news


value: nsemikey

value: Show HN: I built an Instagram Clone

author: nsemikey

title: Show HN: I built an Instagram Clone


value:
https://agentlearn.dev
I built agentlearn after noticing that most AI agent tutorials focus on frameworks (LangChain, CrewAI) rather than fundamentals. The result is developers who can copy-paste code but struggle when things break.
This is a free, interactive course covering:
The Agent Loop - Why loops matter (think vs. act vs. observe)
Context Engineering - The real skill behind "prompt engineering"
Tools & Function Calling - Bridging text generation to real actions
Memory Systems - Short-term vs. long-term, vector DBs
Protocols - MCP, A2A, and the emerging standards
Production Patterns - Error handling, cost optimization, observability
Each concept has runnable code sandboxes you can step through. The design is intentionally "hand-drawn" to feel less intimidating than typical technical docs.
Tech stack: Vanilla JS + Vite, no framework.
Why no framework? Because understanding fundamentals means understanding what frameworks abstract away. Once you get the core loop, you can use any framework—or build your own.
Feedback welcome! Especially interested in what topics are missing.

value: Show HN: Agentlearn – Interactive course for AI agent fundamentals


value: Gregoryy

value:
Study Junkie is an AI tutor that turns any textbook or document you upload into an interactive course with lectures, discussion-based chat, practice assignments of various difficulty, and audio narration.
How it's different from similar tools
It seems like similar tools are mostly optimized for a quick preparation for an exam or job interview, which is not optimal if you want to really understand and practice the material.
So Study Junkie is not a "learn history of the western civilization in 30 minutes" thing. It tries not to shorted the source material and generate problems that match the difficulty of the textbook.
How to use
1. Upload any PDF, DOCX, or text file and get the structured course covering everything that is in the book.
2. Read lectures, dive deeper in an inline chat.
3. Solve problems for each lecture to ensure deep understanding.
Everything AI writes there is grounded in the source material to minimize the probability of hallucinations.
Pricing: free forever! (if you provide your own API key for LLMs)
I've initially created this just for myself to study math & physics, so it's probably best suited for STEM subjects

value: Show HN: AI tutor to study and practice STEM books

author: Gregoryy


value: Show HN: Semantica – Open-source semantic layer and GraphRAG framework


value: I'm a frontend engineer who is learning Postgres and realized I couldn't hold the mental models in my head. So I built interactive visualizations for the concepts I found hardest to internalize.<p>15 episodes covering: pages and tuples, WAL, buffer cache, MVCC (why UPDATE doesn't block reads), B-tree traversal, query planning, isolation levels, lock queues, VACUUM, XID wraparound, connection pooling, replication, partitioning, and sharding.

value: Show HN: Interactive visualizations of PostgreSQL internals(MVCC, B-trees, etc.)


value: saisrirampur

value: Show HN: JSONBench, a Benchmark for Data Analytics on JSON

author: saisrirampur


value: tamnv

value: Show HN: I built a remove bg API only $0.001/image

author: tamnv


value: saiyampathak

value: SHOW HN: I built the Most fancy GitHub Wrapped 2025 with lofi music

author: saiyampathak


value: mannymakes

value:
Heya I thought I'd post here again, after finishing up a big project. Press or tap WASD to move around the board, E will reset you to the center.
This is a chess board built out of octagons, with 3 meeting neatly at a vertex- this isn't usually possible, but you can do it in 'hyperbolic space' which has curvature that essentially allows for more room around a point.
I also have a video which breaks down how everything works in detail: https://youtu.be/9aI3k-acKto

value: Show HN: Chess in Hyperbolic Space

author: mannymakes

title: Show HN: Chess in Hyperbolic Space


value: behnamoh

value: Show HN: Shellock, a real-time CLI flag explainer for fish shell

author: behnamoh


value: kuzej

value:
Hi Hacker News,
I built MotionPoster (https://motionposter.org/) to help people make short animated posters quickly, without spending a lot of time inside heavyweight editing software.
What it does:
- Upload a poster image (or start from a blank)
- Add text overlays
- Pick simple motion styles (for example: pan/zoom, subtle movement)
- Export as a short video you can post on social platforms
Why I built it:
I often needed “a little motion” for posters, but a full motion workflow felt slow for small tasks. I wanted something that gets to a usable result in minutes.
What I want feedback on:
- Does the motion look natural enough, or does it feel “template-like”?
- Which export formats and sizes matter most to you?
- What is the biggest missing feature for your workflow?
Thanks, and I will reply to every comment.

value: Show HN: MotionPoster – static poster to animated poster

author: kuzej


value:
Hi HN! I built QPost (https://qpost.dev), a tool for scheduling and publishing content across YouTube, TikTok, and Instagram from a single interface.
*What it does:*
- Schedule posts across multiple platforms simultaneously
- Platform-specific metadata (YouTube titles/descriptions, TikTok hashtags, Instagram captions)
- Automated publishing via cron jobs
- Account management for multiple social accounts
- Real-time post queue with status tracking (scheduled, posted, failed)
*Tech stack:*
- Astro + React for the frontend
- Prisma + PostgreSQL for data
- Better-auth for authentication
- Google Cloud Storage for media
- node-cron on a Digital Ocean droplet
*Why I built it:*
Most social media schedulers are either expensive SaaS products or locked behind complex enterprise tools. I wanted something free to use and easy to incorporate into a workflow.
*What was challenging:*
Each platform has its own quirks – TikTok's creator API, YouTube's OAuth scopes, Instagram's Graph API. The OAuth verification process was brutal:
- Google took several rounds of revisions (had to add a landing page with privacy/terms just for their requirements)
- TikTok only needed 3 rounds but each round took several weeks for feedback, so it actually took longer than Google
- Dealing with different API restrictions across all platforms
I also had to migrate off Vercel because of their request size limits (video uploads) and cron job pricing. Running node-cron on a $6/month Digital Ocean droplet ended up being way more cost-effective.
The project uses a simple API design, so you can integrate it into your own workflows or build CLI tools on top of it.
Would love to hear your feedback and ideas for improvements!

value: Show HN: Qpost.dev – An open API to post to TikTok, YT, and IG in one place


value: vinkupa

value: Show HN: Claude Code Skill for Deep Code Reviews

author: vinkupa


value: neogoose

value: Just build a local tool for designing gears that kinda looks and works nice

value: Show HN: Free and local browser tool for designing gear models for 3D printing

author: neogoose


value: isanoguchi

value:
Hi HN,
This is cmd-chat, a Python terminal chat app designed around a few constraints:
- No central servers
- No message or key persistence
- No plaintext credentials ever sent over the network
Authentication uses *SRP*, and messages are encrypted after key exchange. All data lives in memory only and disappears when the process exits.
This was partly a learning project and partly an experiment in building a “minimum-trust” chat system using standard cryptographic primitives.
Curious to hear thoughts on the threat model, crypto choices, and overall design.

value: Show HN: A RAM-only, end-to-end encrypted P2P terminal chat in Python

author: isanoguchi


value: ido

value:
I've made a little HUD[0] for running Claude Code via a VS Code plugin. It's still a "text adventure" but now you can tell what's going on a bit better (screenshot in linked GitHub repository). Feedback appreciated!
[0] https://en.wikipedia.org/wiki/HUD_(video_games)

value: Show HN: Claude Code HUD for VS Code

author: ido

title: Show HN: Claude Code HUD for VS Code


value: blackmamoth

value:
I wanted to build my own v0-style code generation tool, but starting with a full web app builder felt overwhelming. So I narrowed the scope to something more focused: an AI email generator.
What it does: Describe an email in plain English, select your brand (logo, colors), and get a responsive, styled email. The AI generates React Email components, which means you get email-client-compatible code that you can version control and customize. Export as React or HTML.
One interesting technical decision: Initially used WebContainer for live preview, but boot time was 30-40 seconds plus 3-4s compilation. Switched to client-side Babel transpilation - now previews render in <1s. Trade-off is you can't install additional packages (e.g., custom icon libraries), but React Email's built-in components cover most use cases. Did I make the right call here?
Stack: TanStack Start, React Email, Postgres, Vercel AI SDK, Resend
Try it: https://usescribe.ashpak.dev
GitHub: https://github.com/Blackmamoth/scribe
Would love feedback on whether this solves a real problem or if existing tools are already good enough.

value: Show HN: Scribe – Generate styled emails from plain English

author: blackmamoth


value: marttilaine

value:
TL;DR: unified API for SMS/email/Slack/LinkedIn/X at https://yeetpost.com
Longer version:
A colleague was struggling with automated posting to a LinkedIn page from their Next.js project, so I built a simpler API for it. Later I needed notifications from a data pipeline (SMS and Slack alerts during long-running jobs) so I expanded it.
After using it for a while, we thought others might find this useful too.
Compared to LinkedIn/X OAuth or setting up Twilio/Postmark/etc, it's simpler:
1. Sign up
2. Connect your accounts (LinkedIn, X, Slack, or verify your SMS number or email address)
3. Copy API key
4. Post via HTTP API or TypeScript SDK
Example request:

  curl -X POST https://api.yeetpost.com/api/v2/post/sms -H "x-api-key: <your-api-key>" -d 'New user registered'

Another example via TypeScript:

  import { yeetpost } from "yeetpost";
  await yeetpost({
    connection: "linkedin",
    text: "Today's top 3 projects:\n1. ...\n2. ...\n3. ...",
  });

If you need to send notifications to yourself or post to your social media accounts, give it a try! Happy to answer any questions.
Free tier available for testing:
https://yeetpost.com

value: Show HN: One API for LinkedIn, X, Slack, SMS, and email (yeetpost)

author: marttilaine


value: katafyi

value:
I built DreamStack because I was tired of the "disposable MVP" culture in Node.js. Most templates/starters tie your business logic so tightly to Express or NestJS that a framework migration is effectively a total rewrite.
I wanted to see if I could build a truly agnostic engine using the Adapter and Repository patterns.
The Result:
Framework Agnostic: You can swap the underlying HTTP engine (Express ↔ Hono) via a single .env variable.
A+ AI Audit: I used GitHub Copilot to perform a modularity audit, which returned a 98/100 score on separation of concerns.
Performance-First Testing: I optimized the DI container and persistence layers so that all 508 tests (unit + integration) run in under 10 seconds.
Infrastructure Flexibility: Swappable layers for SQL (Prisma) and NoSQL (Mongoose).
It includes the "boring stuff" like JWT rotation, RBAC, and OAuth so you can focus on the unique parts of your app. I'm here to talk about the architectural trade-offs of this approach versus the standard "batteries-included" frameworks.

value: Show HN: DreamStack – Framework-agnostic Node.js foundation - 500+ tests (~10s)

author: katafyi


value: modinfo

value:
Hey HN! I built a multiplayer exploration game with an interesting twist: you can only see and chat with players within 100 pixels of you.
Live demo: https://tile.sekor.eu.org
The game features:
- Procedurally generated 2000x2000 world (seeded terrain with grass, water, sand, rocks, trees)
- Proximity-based visibility and chat (players fade in as they approach)
- An NPC "Guide" that walks around and answers questions (powered by local LLM via OpenAI-compatible API)
Tech stack:
- Built on Cleoselene engine https://cleoselene.com/ (Rust + Lua scripting)
- Server-rendered frames sent to browser via WebRTC/WebSocket
- ~800 lines of Lua for the game logic
The proximity mechanic creates emergent gameplay: you never know who's around the next corner, and finding another player feels like a genuine discovery.
Source: https://github.com/skorotkiewicz/proximity-explorer
Would love feedback on the concept and implementation!

value: Show HN: Server-rendered multiplayer game with proximity chat and LLM NPC

author: modinfo


value:
Hi HN,
I built Tickk.app to solve a personal problem: I think much faster than I can type, and most “productivity” apps either slow me down or push everything to the cloud.
Tickk lets you speak messy thoughts or braindumps and turns them into structured tasks and notes using lightweight NLP — all entirely in the browser.
There’s:
no AI (please don't expect LLM level outputs)
no cloud
no accounts
no data leaving your device
Everything is stored in localStorage.
This started as a small experiment for myself (especially helpful for ADHD-style racing thoughts), but I figured others here might find the approach interesting — particularly the choice to stay local-only instead of using LLMs.
I’m curious:
Does local-first still matter to people?
What would make a tool like this genuinely useful long-term?
Thanks for checking it out- feedback very welcome.

value: Show HN: Tickk.app – Local-only voice braindumps → tasks (no AI, no cloud)


value:
Hi HN,
Titan Planet is a JavaScript-first backend framework that lets you write backend logic in JavaScript and deploy it as a single native Rust binary.
Today, I’m sharing a major update:
What’s new
1. V8 runtime (no more Boa) Titan Planet now uses V8 to execute JavaScript bundles. This significantly improves execution speed, compatibility with real-world JS libraries, and overall runtime stability — while still keeping Node.js completely out of production.
JavaScript is bundled ahead of time and executed inside an embedded V8 runtime. Rust continues to own networking, async I/O, concurrency, and deployment.
2. Expanded runtime APIs Titan now ships with a growing set of built-in runtime APIs designed for backend workloads:
t.log(...) – structured logging
t.jwt – JWT sign / verify helpers
t.password – hashing & verification helpers
t.fetch – HTTP requests
File access, env access, and more
These APIs are implemented on the Rust side and exposed safely to JavaScript, keeping the runtime controlled and predictable.
3. Same core philosophy
No Node.js
No Node event loop
No JS tooling required in production
One native binary output
JavaScript scoped strictly to application logic
Docs
Documentation (architecture, runtime APIs, examples):
https://titan-docs-ez.vercel.app/docs
Titan is opinionated by design and won’t fit every use case — but if you’re interested in a Rust-owned backend with JavaScript ergonomics and a V8 runtime, feedback is very welcome.
Happy coding.

value: Show HN: Titan Planet – JavaScript back end framework now powered by V8


value: Show HN: Omni Podcast: AI Podcast Generator


value: PreciousH

value:
Hi HN,
I built this because I’ve been using deep-search AI agents for research, but I always found the "wall of text" output exhausting to parse. When we learn from textbooks, we rely on diagrams, charts, and 2D/3D illustrations to build a mental model. I wanted an AI researcher that does the same.
The agent doesn't just write a report; it identifies concepts that are better explained visually and generates the code to render them inline.
The Tech Stack:
Frontend: Next.js for the UI and report rendering.
Real-time Server: Go. I chose Go to handle the high-concurrency needs of streaming agentic thoughts and managing WebSocket connections during long-running research tasks.
AI Background Worker: Python. This handles the agentic logic, using various LLMs to orchestrate the research, search, and code generation for the visuals.
Visualization Engine: * 3D: Three.js for interactive models and animations.
2D: p5.js for generative illustrations.
Charts: D3.js for data-heavy visualizations.
Diagrams: Mermaid.js for quick flowcharts and architecture.
How it works:
The Python worker isn't just generating an image; it’s generating the actual code/schema for these libraries based on the research context. The Next.js client then sanitizes and renders these components dynamically within the report.
I’m really looking for feedback on the "agentic" part of the visualization—specifically how to better prompt the model to choose the right type of diagram for the data it finds.
GitHub: https://github.com/precious112/prism_ai
I’ll be around to answer any questions about the architecture or the 3D generation logic!

value: Show HN: An open-source AI researcher that generates reports with 3D animations

author: PreciousH


value:
Last year I left $2,400 in rewards on the table by using the wrong credit cards.
I have 5 cards with different reward rates: 5% groceries on one, 3% gas on another, 2% dining elsewhere. Mentally tracking which card to use where is exhausting, so I defaulted to whatever was in my wallet.
I built Payvo to solve this. It automatically routes each transaction to your optimal card for maximum rewards.
How it works:
Add your credit cards once (we track 180+ cards, 29 loyalty programs)
AI analyzes transactions in real-time
Routes to your best card per category
30-40% more rewards, zero mental overhead
Currently in beta and looking for early users. Sign up at payvo.ai if you're interested in testing it out.
Targeting the 45M Americans with multiple credit cards who are leaving money on the table like I was.

value: Show HN: AI that picks your best credit card for every purchase


value: dignick

value: I work across 10+ repos for different clients and want to give clients year-end summaries of the work I've done. So I built a tool that scans my git history and generates polished reports using LLMs. Also does daily time logging ("what did I work on yesterday?") and can turn commits into blog posts. uvx code-recap summarize 2025 --open and you're done.

value: Show HN: Code Recap – Generate year-in-review reports from your Git history

author: dignick


value:
Hi HN,
We’ve been building memU(https://github.com/NevaMind-AI/memU), an open-source, general-purpose memory framework for AI agents. It supports dual-mode retrieval: classic RAG and LLM-based direct file reading.
Most multimodal memory systems either embed everything into vectors or treat non-text data as attachments. These work, but at scale it becomes hard to explain why certain context was retrieved and what evidence it relies on.
memU takes a different approach:
since models reason in language, multimodal memory should converge into structured, queryable text, while remaining fully traceable to original data.
---
## Three-Layer Architecture
- Resource Layer
  Stores raw multimodal data as ground truth. All higher-level memory remains traceable to this layer.
- Memory Item Layer
  Extracts atomic facts from raw data and stores them as natural-language statements.
  Embeddings are optional and used only for acceleration.
- Memory Category Layer
  Aggregates items into readable, theme-based memory files (e.g. user preferences, work logs).
  Frequently accessed topics stay active; low-usage content is demoted to balance speed and coverage.
---
## Memorization
Bottom-up and asynchronous.
Data flows from resources → items → category files without manual schemas.
When capacity is reached, recently relevant memories replace the least used ones.
## Retrieval
Top-down.
memU searches category files first, then items, and only falls back to raw data if needed.
At the item layer, it combines BM25 + embeddings to balance exact matching and semantic recall, avoiding embedding-only imprecision.
Dual-mode retrieval lets applications choose between:
- low-latency embedding search, or
- LLM-based direct reading of memory files.
## Evolution
Memory structure adapts automatically based on real usage:
- Frequently accessed memories remain at the Category layer
- Memories retrieved from raw data are promoted upward and linked
- Organization evolves from usage patterns, not predefined rules
Goal: keep relevant memories retrievable at the Category layer and minimize latency over time.
---
## A Unified Multimodal Memory Pipeline
memU is a text-centered multimodal memory system.
Multimodal inputs are progressively converted into interpretable text memory, while staying traceable to original data.
This provides stable, high-level context for reasoning, with detailed evidence available when needed—inside a memory structure that evolves through real-world use.

value: Show HN: Unified multimodal memory framework, without embeddings


value: francomendezok

value:
Hi HN,
I’m building Interiores AI, a web tool that helps architects, interior designers,
and real estate agents quickly generate redesign concepts from photos of existing spaces.
The goal is not to replace professional design, but to speed up early-stage exploration:
style variations, layout ideas, and visual options that usually take hours or days.
This started after talking with architects who needed faster ways to show alternatives
to clients without doing full renders upfront.
I’d really appreciate feedback on:
– whether this solves a real workflow problem
– what would make it actually useful (or useless)
– any obvious red flags you see
Happy to answer technical or product questions.

value: Show HN: AI-powered interior redesign tool for architects and real estate

author: francomendezok


value: a-v-berezkin

value:
Hi HN! I’ve been following zero-runtime CSS-in-JS/TS libraries for a while and noticed that most of them end up overwhelmed by bundler compatibility issues. A good summary of these problems is in the final status report [1] of Pigment CSS — MUI’s attempt in this space.
As someone working on TypeScript tooling, I started wondering whether this problem could be approached from a different angle: instead of relying on bundler plugins, use TypeScript types to define styles, and TypeScript tooling to provide locally scoped class and CSS variable names.
This led to Typique — a library built as a TypeScript plugin. It provides IDE integration (completion, diagnostics, quick fixes) and emits plain CSS without any dependence on bundler or framework. It’s early, but already usable; I’ve been using it in a couple of personal projects.
Feedback, questions, and skepticism are very welcome. Thanks for reading.
[1] https://github.com/mui/material-ui/issues/45759#issuecomment...

value: Show HN: Typique – a bundler-independent, zero-runtime CSS-in-TS library

author: a-v-berezkin


value: sparksandmagic

value: Show HN: AVShack – Linux Live Streaming Server – With Mixing and Multistreaming

author: sparksandmagic


value: tilyupo

value:
NodeJS TypeScript client for watching configuration values with real-time updates. Zero runtime deps, works in Node 18+. Override rules are evaluated client-side so user context never leaves your app.
Use it for feature flags, rate limits, timeouts, kill switches—anything you'd rather change without a deploy. Changes propagate in under a second. Roll back instantly if something breaks.
npm: https://www.npmjs.com/package/@replanejs/sdk
GitHub: https://github.com/replane-dev/replane-javascript/tree/main/...

value: Show HN: Node.js type-safe dynamic config with real-time updates (MIT)

author: tilyupo


value: Show HN: EvalView – Catch agent regressions before you ship (pytest for agents)


value: onurkanbkrc

value: Show HN: Notepai – AI assisted online notepad editor

author: onurkanbkrc


value: yehors

value: This is a reproduction of paper https://arxiv.org/abs/2505.13552 where the author compares a new algorithm with QuickSort, which is approximately 24% faster

value: Show HN: Sorting a billion of integers in 7.6 seconds

author: yehors


value:
Hey HN!
I’m Collin, a 20 year old law student from Amsterdam. I built Cited AI, an AI that gives accurate and verifiable answers from your documents/context.
As a law student who uses AI a lot, I know how important it is that answers are actually accurate and verifiable. I remember many instances where I'd ask a chatbot like ChatGPT or Claude about case law or long documents, and it would either hallucinate facts that didn't exist, or fail to give me the exact passages from my source documents so I could verify its answers. Even when specifically asking for exact quotes, finding that passage in the original document is still a hassle. That's why last November I started building Cited.
It should work with all types of content, complex PDFs (including math heavy ones) and long documents up to 75k words. No RAG or chunking is used, to make sure the full document is in the LLM's context.
I would love to hear your feedback!

value: Show HN: Cited AI – AI answers with citations linking to exact source passages


value: shelto

value: Show HN: Bulk image downloader from any website – feedback

author: shelto


value: Just built a small tool and created some comparsion of country size vs. planets. Greenland seems larger than i thought.<p>The tool allows you to drag a counry to other planet to see the size there.

value: Show HN: Put Greenland on the Moon (interactive map for size compare)


value: simonleeb

value:
Against my better judgment I could not stop building a Swift + WebAssembly frontend framework and just kicked a 0.1 out the door.
GitHub: https://github.com/elementary-swift/elementary-ui
I understand there is a lot of skepticism around Wasm for general frontend work, but I think this can actually be pretty cool - heck, even a viable solution. Especially combined with Embedded Swift - which is still a bit rough, but you can fit little web apps in under 200 kB (compressed).
The link contains a "Get Started" section with a template repo, you can try it out in minutes.
What are we thinking?

value: Show HN: ElementaryUI – A Swift front end framework for the browser

author: simonleeb


value:
I built this because Cursor, Claude Code and other agentic AI tools kept giving me tests that looked fine but failed when I ran them. Or worse - I'd ask the agent to run them and it would start looping: fix tests, those fail, then it starts "fixing" my code so tests pass, or just deletes assertions so they "pass".
Out of that frustration I built KeelTest - a VS Code extension that generates pytest tests and executes them, got hooked and decided to push this project forward... When tests fail, it tries to figure out why:
- Generation error: Attemps to fix it automatically, then tries again
- Bug in your source code: flags it and explains what's wrong
How it works:
- Static analysis to map dependencies, patterns, services to mock.
- Generate a plan for each function and what edge cases to cover
- Generate those tests
- Execute in "sandbox"
- Self-heal failures or flag source bugs
Python + pytest only for now. Alpha stage - not all codebases work reliably. But testing on personal projects and a few production apps at work, it's been consistently decent. Works best on simpler applications, sometimes glitches on monorepos setups. Supports Poetry/UV/plain pip setups.
Install from VS Code marketplace: https://marketplace.visualstudio.com/items?itemName=KeelCode...
More detailed writeup how it works: https://keelcode.dev/blog/introducing-keeltest
Free tier is 7 tests files/month (current limit is <=300 source LOC). To make it easier to try without signing up, giving away a few API keys (they have shared ~30 test files generation quota):
KEY-1: tgai_jHOEgOfpMJ_mrtNgSQ6iKKKXFm1RQ7FJOkI0a7LJiWg
KEY-2: tgai_NlSZN-4yRYZ15g5SAbDb0V0DRMfVw-bcEIOuzbycip0
KEY-3: tgai_kiiSIikrBZothZYqQ76V6zNbb2Qv-o6qiZjYZjeaczc
KEY-4: tgai_JBfSV_4w-87bZHpJYX0zLQ8kJfFrzas4dzj0vu31K5E
Would love your honest feedback where this could go next, and on which setups it failed, how it failed, it has quite verbose debug output at this stage!

value: Show HN: KeelTest – AI-driven VS Code unit test generator with bug discovery


value: julienreszka

value:
didn't pivot this time but changed the homepage for a more minimalistic look.
What is currently in the top content of /about used to be the homepage
Wdyt? Does the giant coin make you want to click?

value: Show HN: CoinFountains – Make a Wish

author: julienreszka

title: Show HN: CoinFountains – Make a Wish


value: yukipeters

value:
I built a CLI tool that scans your Metabase instance to find which SQL questions reference a column or table you're about to drop/rename.
metabase-impact --metabase-url http://localhost:3000 --api-key "mb_xxx" --drop-column orders.user_id
It outputs affected questions with direct links so you can fix or archive them before deploying.
Built this after breaking dashboards one too many times. Uses sqlglot for SQL parsing (handles aliases and complex queries). Only works on native SQL questions, not MBQL/GUI queries.

value: Show HN: Metabase-Impact – Find which Metabase questions break before you deploy

author: yukipeters


value: A hobby project designed to create a competition platform for the traveling salesman problem.

value: Show HN: A TSP Competition Site

title: Show HN: A TSP Competition Site


value: alsufinow

value: Show HN: We built a complete agentic work OS from scratch

author: alsufinow


value: GodelNumbering

value: Show HN: the entire US ETF market mapped into 280 distinct categories

author: GodelNumbering


value:
I built kprotect because I wanted a way to protect my sensitive files (SSH keys, env files) that went beyond just standard Linux permissions. Even if a process is running as root, it shouldn't be able to read my secrets unless it’s part of a trusted execution chain.
How it works: It uses BPF LSM (Linux Security Modules) to intercept file access at the kernel level. Instead of just checking the PID or the binary name, it looks at the entire lineage (the "Chain of Trust"). For example, cat is only allowed to read my SSH keys if the parent process is my-terminal and the grandparent is vscodium.
Key Tech:
Backend: Rust + Aya (for the eBPF bits).
Frontend: Tauri + React for the dashboard.
Security: Logs and configs are AES-encrypted to prevent tampering.
It’s currently in beta (0.1.0). It requires a kernel (5.10+) with BPF LSM enabled. I'd love to hear feedback on the "Chain of Trust" logic—specifically if anyone sees edge cases in how I'm verifying the process ancestors.
GitHub: https://github.com/khoinp1012/kprotect

value: Show HN: Kprotect – eBPF-based file protection using process lineage


value: lucienpeng

value:
Just pushed an update (v1.1) to Struxs.
We had some users asking for a way to constrain the scope of the visual perception. Specifically, they were processing scanned forms where a field like "Gender" or "Payment Mode" would return inconsistent raw text (e.g., "M", "Male", or just a checked box symbol) depending on the document layout.
To solve this, we added an Enum type to the builder.
You can now visually map a region and strictly define the allowed states (e.g., ["Male", "Female"] or ["Sedan", "SUV", "Truck"]). The engine will now force the visual signal into one of those pre-defined buckets instead of returning ambiguous strings.
It’s a small change, but it makes the JSON output deterministic and saves you from writing extra code to normalize the data downstream.
Happy to hear any feedback.

value: Show HN: Struxs v1.1 – Visual API builder, now with Enum support

author: lucienpeng


value: Show HN: Deep learning without gradient descent, 500 layers, no skip connections


value: sidchilling

value:
Teams in Slack often end up pasting long @mention chains, and someone gets missed (or the wrong person gets pinged). It’s worse for rotating groups like on-call, releases, incident response.
We built Alias Bot: each channel can define aliases like `!oncall` / `!reviewers`. When someone uses an alias, the bot replies with the expanded mentions and lists exactly who was notified (so there are no hidden pings).
This is intentionally channel-scoped (vs Slack user groups being workspace-wide), so the same alias can mean different things in different channels without admin overhead.
Privacy note: the backend stores alias configuration (alias → member IDs per channel), processes message text to detect alias usage, and does not store or log message bodies ever.
Free plan includes up to 3 aliases; pricing is flat. You purchase number of aliases you could create and is not seat-based (user-based).
Would appreciate feedback from EMs/TLs/SREs: is this a real pain for your teams, and what would block adoption (noise, permissions, governance, drift)?

value: Show HN: Slack bot for channel-owned mention aliases (not org-wide user groups)

author: sidchilling


value: amadeuspagel

value: Show HN: Milkyboard – Synth Keyboard with Milkdrop Visualizer

author: amadeuspagel