value: I have been having a lot of fun getting GPT-OSS-20b (at temp=2.0, Top K = 100) to generate newspaper articles for local newspapers, then asking it to generate the content of articles I want to read.<p>The natural extension seemed like taking this extremely seriously, so this was a fun & quick Saturday morning project. I'm having a lot of fun clicking around and thought I'd share, in case anyone wants to know what is going on in Port Augusta.

value: Show HN: The Port Augusta Times – "All the news that's fit to generate"


value: Enjoyooor

value:
Hey,
My name is Benjamin and as many developers, I was tired to not succeed my technical interviews, for any reasons.
I made SharpSkill in order to change that.
Real Use Case, flashcards & interview simulators.
One goal : Destroy the next technical interviews.
Open to any feedbacks.

value: Show HN: I built SharpSkill because I was frustrated of my Tech interviews

author: Enjoyooor


value: mxprs

value:
I write a lot of long-form content and the same problem kept slowing me down. Writing was fine, but turning it into a clean, consistent PDF always took more effort than the content itself. I kept fighting with margins, spacing, headers, templates, exports, and it became the part of the process I dreaded most.
I eventually stopped trying to force tools that weren’t built for this and started experimenting with a different approach: describe the structure in JSON and generate the PDF with a layout engine. I built it originally as a personal workflow, not as a product, but other people around me had the same pain so I cleaned it up and put a demo online.
It is still early and rough in places, but if anyone here writes ebooks, reports, guides, or technical documents, I would appreciate feedback on the idea, the rendering approach, or any pitfalls I might not be seeing.
Live demo: https://ebookforge.app/

value: Show HN: I built a JSON-to-PDF book generator because formatting was killing me

author: mxprs


value: rasinmuhammed

value:
Hi HN,
I built FastAPI Matrix Admin – an admin panel for FastAPI with a Matrix-style cyberpunk UI.
Live demo: https://fastapi-matrix-admin-demo.onrender.com/admin/
GitHub: https://github.com/rasinmuhammed/fastapi-matrix-admin
What makes it different:
1. One-line auto-discovery: admin.auto_discover(Base) registers all your SQLAlchemy models automatically. No config files, no manual registration.
2. Zero Node.js: Pure Python. No npm, no webpack, no build step. Tailwind via CDN, HTMX for interactions.
3. Unique Matrix theme: Terminal-style green/black aesthetic with neon glows. Most admin panels look generic – this one stands out.
4. Production-ready : Async SQLAlchemy 2.0, Pydantic v2, CSP middleware, CSRF protection, type-safe.
The project started as "fastapi-shadcn-admin" trying to copy shadcn/ui, but I realized the Matrix theme was becoming the actual differentiator, so I rebranded.
Tech stack:
- Backend: FastAPI + SQLAlchemy (async)
- Frontend: Jinja2 templates + HTMX + Alpine.js
- Styling: Tailwind CSS (CDN)
- Security: itsdangerous for signing, CSP middleware
I'd love feedback on:
- Is auto-discovery actually useful or too magical?
- Does the Matrix theme help or hurt adoption?
- What features would make this production-ready for your use cases?
Thanks!

value: Show HN: FastAPI Matrix Admin – Zero-config secure admin panel with cyberpunk UI

author: rasinmuhammed


value: HamounKarami

value:
hi hn, i’m ham!
i built KnockKnock! because I missed how easy and spontaneous it used to be to just "knock" on a friend’s door. it’s a native macOS app that sits quietly in your menu bar and lets you video call your friends instantly—no links to generate, no scheduling, just a genuine moment of connection.
it is completely free and exclusive to macOS.
we’re gearing up for our big Product Hunt launch next week, but I really wanted to share it with this community first to hear your thoughts.

value: Show HN: KnockKnock – Circular video calls that bring you closer, faster(macOS)

author: HamounKarami


value: baransel

value: Show HN: I kept forgetting my supplements while cutting, so I built an app

author: baransel


value: paramthakkar

value:
I’m Param Thakkar, and my research interests center around Generative Modeling and World Models. Over the past months, I’ve been developing a PyTorch-based library aimed at making it dramatically easier to learn about world models, experiment with them, and build new ones. My goal is to create the most accessible, flexible, and extensible toolkit for anyone working in this space—from beginners exploring model-based RL to researchers pushing new architectures.
After releasing v0.0.1, which introduced initial support for the PlaNet world model, I’m excited to announce v0.1.0. This update expands the library significantly, introducing:
Broader environment support, including DMControl, OpenAI Gym, the Arcade Learning Environments, and more.
Full implementations of DreamerV1 and DreamerV2, with DreamerV3 currently in development.
Ongoing work to add additional world models, reusable components, and advanced environments such as Isaac Gym, ManiSkill3, and DeepMind Lab.
This release brings the project another step closer to a unified ecosystem for world-model research—one that accelerates innovation, lowers barriers to entry, and empowers the community to explore the frontier of model-based learning.
If this project interests you, consider starring the repository and joining me in contributing to its growth!

value: Show HN: PyTorch-World v0.1.0: Build & Train World Models

author: paramthakkar


value: joeeverjk

value: Show HN: Octopii – a distributed runtime written in Rust

author: joeeverjk


value:
Hi HN,
QA engineering keep facing several hurdles when it comes to quality and time. From Reddit subgroup to ycombinator blogs, QA pain-points are yet to be solved as I navigate through several pages. While big players like SmartBear, BrowserStack are building innovative test solutions, a larger part of QA workflow remain unsolved. https://peterblanco.com/startup/quiet-crisis-in-qa-more-code...
QA engineers hate:
- typing reproduction steps
- taking screenshots
- explaining what happened
- capturing network logs manually
- writing clean bug reports
- forgetting to write down something important
WhispaQA records interactions, intents not content, understands flow, interprets them in natural language, allow user to select mode of capture, write clean reports based on what it learns from a session, that automates 50-60% of manual tasks in QA. QA engineers don't have to write down steps, flow, manually log network activities, take screenshots, etc., when they can launch an assistant for that
Your thoughts?

value: Show HN: WhispaQA, the intent-driven QA tool


value:
I built an unconventional application of sequence-to-sequence (Seq2Seq) neural networks: predicting the intermediate steps of manual multiplication from the final answer alone. The model receives just the digits of a product (e.g., 56088) and must reconstruct the original 9 hidden cell values of the 3x3 Gelosia lattice table that produced that sum.
This project turns a deterministic math problem on its head, forcing an LSTM to learn abstract mathematical relationships implicitly through observation. It's a fun exploration of how ML can map a final, "collapsed" sequence of information back to its higher-dimensional, hidden components. Check out the code and project details here: https://gitlab.com/9o1d/gelosia

value: Show HN: Seq2Seq ML Learns the Inverse of Manual Multiplication (Gelosia Method)


value: Show HN: WebGPU back end for PyTorch sneak peek


value: Show HN: Tududi v0.87 – A self-hosted life OS: areas, projects, tasks, notes


value: rahulbstomar

value:
I’ve been building something I personally always needed - a simple, beautiful way to collect product feedback and decide what to build next. Today, it's finally live.
Introducing: VicharFlow
A minimal yet powerful tool to collect ideas → prioritize them → ship features users love
Why I built it
Every feedback tool I tried was either too bloated, too expensive, or just boring.
So I made one that focuses on what matters:
Everything essential. Nothing extra.
Features
Embedded Feedback Widget: Plug into any site with one script tag - works with React, Vue, Svelte, or plain HTML.
Smart Prioritization: Users vote → leaderboard forms → you build what actually matters.
Moderation Tools: Approve posts, remove clutter, stay focused.
Custom Theming: Change colors, logo, make it feel yours.
Clean UI Simple, fast, no unnecessary noise.
Try it live - https://vicharflow.com/
Submit a feature request, test the voting, embed the widget - break it if you can
What I’d love feedback on
UI/UX clarity - intuitive or confusing anywhere?
Performance of the embed script
Feature ideas (thinking of: roadmap, changelog, SSO)
Pricing thoughts if you were to use it for your product
All feedback - brutal or kind - is welcome!
Thanks for reading

value: Show HN: Built an all-in-one feedback board for SaaS apps – Ship features

author: rahulbstomar


value: thinkmoon

value:
I built ThinkMoon because I wanted to see if LLMs could actually make money trading crypto, not just talk about it.
It's an AI-powered trading platform where you can connect models from OpenRouter, OpenAI, or Anthropic to real markets and let them execute actual trades on Binance Futures.
How it works: the AI gets real-time market data (candles, order book, ticker), analyzes it, and outputs structured trading decisions. Then it actually executes - long/short positions with leverage up to 40x. Every single decision is logged with the full prompt, the AI's reasoning, and market snapshot at that moment.
What I'm most excited about is that you can create your own trading agents. You write or start from basic strategy prompts, pick your risk parameters, choose which cryptos to trade (BTC, ETH, SOL, XRP, whatever), and let it run. You can even mix different LLMs and compare how they perform.
I also added Telegram and Slack notifications so you get alerts when trades happen. Plus a dashboard to track everything - live P&L, open positions, the AI's chain of thought.
The risk management side was important to me: stop-loss, take-profit, position limits, and a kill-switch if drawdown gets too high.
Currently working on our own custom LLM fine-tuned specifically for trading decisions. Early results are promising, better consistency than the general models.
Would love to hear what features you'd want in an AI trading assistant. What's missing from tools you've tried?

value: Show HN: ThinkMoon – AI Trading Assistant Using LLMs for Live Crypto Trading

author: thinkmoon


value: omneity

value: Show HN: Picomon, a minimal TUI monitor for AMD GPUs

author: omneity


value: brokensegue

value: Show HN: Paperclip Maximizer Bench

author: brokensegue

title: Show HN: Paperclip Maximizer Bench


value: claygood

value: Show HN: Open-source tool to detect breaking changes and generate WAF rules

author: claygood


value: AshBuk

value: Show HN: FingerGo – lightweight cross-platform touch-typing trainer

author: AshBuk


value: NotARoomba

value:
Hi, I’m Nathan, an aspiring engineer who likes to tinker with hardware. Earlier this year, I started making hardware/electronic projects through various Hack Club programs. It was perfect, but most, if not all, of my projects were being withheld due to high customs and import fees, so I wanted to change that.
Most of the price was actually assembling the PCB, and looking around the internet, I discovered the wonderful invention of the hotplate, and that I could make all of my PCBs myself for more than half the cost. Now, while I could have bought one on eBay, I decided to take up the challenge of making my own (because why not) and to make it as functionally portable as possible, so Ember was born.
I started reading how hotplates work and looked around the internet to see if anyone had made one, and I stumbled upon this repository (https://github.com/ikajdan/reflow-hot-plate). It was basically what I wanted to make, but reading through, I found that although it went up to 210 °C, the hotplate size was rather small. Also, it needed an external DC jack along with USB-C to be able to control/monitor it from a laptop.
Features/Specs:
- USB-C Power Delivery up to 100W (20V) using TI's TPS25730D
- STM32WB55CG microcontroller with Bluetooth support
- Large(ish) 120mm x 120mm flexible heatbed for big PCB reflow (JLCFH)
- Dual temperature sensing with MAX6675 thermocouple and PT1000 RTD
- OLED display with rotary encoder for easy control and preset management
- NFC support (because why not lol)
- Gate driver for precise PWM heatbed control
- Current and board temperature monitoring for safety
- 32MB Flash memory for graphics and data storage
- Portable design with custom acrylic / nylon case
If you want to see the complete journal of how I made it and all of the design decisions I made, you can check it out here: https://blueprint.hackclub.com/projects/1701
Here’s the GitHub repo for anyone interested in making their own: https://github.com/notaroomba/ember
Thanks to Hack Club’s Blueprint for sponsoring this project!

value: Show HN: Ember - A hot plate controller powered by USB-C Power Delivery

author: NotARoomba


value: HanDamin

value: A machine learning toolkit designed for ease of use from prototyping to deployment, with memory safety and zero-cost abstractions.<p>What Hodu does:<p>- hodu-lib: Core ML library providing memory-safe tensor operations and model building through Rust's ownership system and zero-cost abstractions, with support for multiple backends (CPU, CUDA, Metal)<p>- hodu-cli: Command-line interface for model inference, format conversion, cross compile, and AOT compilation to native libraries, with built-in plugin management<p>- hodu-plugin-sdk: SDK for building custom plugins via JSON-RPC, enabling support for new model formats (ONNX, TensorFlow), tensor formats (NumPy, SafeTensors), and execution backends

value: Show HN: Hodu – User-friendly ML toolkit built in Rust

author: HanDamin


value: roriau

value:
I've spent the last few weeks building SFX in Rust. It's a programming language experiment focused on context-oriented programming with some unusual design choices.
Reality check first:
Solo project, 53 commits
1 GitHub star xD
Zero users besides me
No production usage
Documentation is aspirational
Many stdlib modules are minimal stubs
What actually works:
Basic interpreter (tree-walker)
Arbitrary precision decimals (0.1 + 0.2 = 0.3)
1-based indexing (controversial, I know)
Context/Situation system (the main idea)
Some file I/O and basic networking
JIT hooks exist but optimization is minimal
The Context idea (asking for feedback on this):
Instead of checking if (user.isAdmin) everywhere, you define Situation: AdminMode that overrides methods:

  Concept: User
      To GetPermissions:
          Return "read"

  Situation: AdminMode
      Adjust User:
          To GetPermissions:
              Return "admin,write,delete"

  Story:
      Create User Called Bob
      Switch on AdminMode
      Print Bob.GetPermissions  # Now returns "admin,write,delete"

Objects change behavior based on active situations without mutating state. Is this useful or just overengineered?
What's NOT ready:
Performance is terrible (haven't optimized anything)
Standard lib is mostly TODOs
AI features are vaporware
REPL doesn't exist
No tooling (LSP, debugger, etc.)
Tests exist but coverage is poor
My questions:
Is context-oriented programming solving a real problem or creating busywork?
Should I focus on making it fast OR making the stdlib useful?
Is 1-based indexing a dealbreaker for you?
Would arbitrary precision by default bother you for a general-purpose language?
I'm not trying to replace anything. This is a learning project that got out of hand.
Repo: https://github.com/roriau0422/sfex-lang
Pages: https://roriau0422.github.io/sfex-lang/
Honest feedback wanted - including "this is pointless, stop wasting time."

value: Show HN: SFX – A language where 0.1 and 0.2 = 0.3 and Context is first-class

author: roriau


value: zaibacu

value: Tool which parses your SQL into AST and builds full JVM pipeline using Clojure.

value: Show HN: TnL – an exotic ETL nobody asked for

author: zaibacu


value: kaipereira

value:
3D printing is such a fascinating field of technology, so a couple months ago, I decided to take a deep dive and learn how they actually work!
This took me to one of my very first PCB projects, a small, cheap, 3D printer motherboard. While it's not the most cutting edge board, I learned a lot and I fully documented my process designing it (https://github.com/KaiPereira/Cheetah-MX4-Mini/blob/master/J...), so other people can learn from my mistakes!
It runs off of an STM32H743 MCU, has 4 TMC stepsticks with UART/SPI configurations, sensorless/endstop homing, thermistor and fan ports, parallel, serial and TFT display connectors, bed and heater outputs and USB-C/SD Card printing, all in a small 80x90mm form factor with support for Marlin and Klipper!
Because it's smaller and cheaper than a typical motherboard, you can use it for smaller/more affordable printers, and other people can also reference the journal if they're making their own board!
If I were to make a V2, I would probably clean up the traces/layout of the PCB, pay more attention to trace size, stitching and fills, BOM optimize even further, and add another motor driver or two to the board. I also should've payed a bit more attention to how much current I would be drawing, and also the voltage ratings, because some of the parts are under-rated for the power.
I'm still actively refining it and fixing up some of the mistakes, but I plan on using this board to make a tiny foldup 3D printer I can bring to hackathons and 3D print on the go!
The project is fully open source, and journaled, so if you'd like to check it out it's on GitHub (https://github.com/KaiPereira/Cheetah-MX4-Mini)!
I absolutely loved making this project and I'd love to hear what you guys would want to see in a V2!

value: Show HN: I designed my own 3D printer motherboard

author: kaipereira


value: alexcpn

value:
A powerful AI Agentic Automation without any AI framework, using plain python and OPenAI code. UI part genreated with Google AntiGravity and Codex
Write up : https://medium.com/data-science-collective/beyond-chatgpt-ho...

value: Show HN: Agentic Code Review with Tree Sitter MCP Tool

author: alexcpn


value: sbcom

value: Show HN: Scrollbots – 24/7 Infinite LLM Characters Debating Any Topic

author: sbcom


value: ArielAio

value:
I’ve been noticing a pattern in my own relationship and in friends’ relationships: we say we want better communication, but most of the time we only really talk when there’s already a problem.
Because of that, I built a very small web app called “3-Minute Connection”.
It does one simple thing: once a day, it gives you a small emotional mission to do with your partner. The goal is to create a tiny daily ritual that takes around 3 minutes, instead of relying only on rare, heavy conversations.
Right now it’s an early MVP:
- simple email + password signup
- a dashboard with one daily mission
- progress across a 7-day mission sequence
- designed for couples, but it can also be used alone
What I’m trying to validate now is:
- does this actually help in real life, or does it only sound good in theory?
- would couples really commit to something this small every day?
- is the “one mission per day” format the right constraint?
- are there obvious product or UX flaws I’m missing?
If anyone here is in a relationship and feels like trying it for a few days, I’d really appreciate honest feedback, both on whether this helps at all, and on the product/technical side.
Happy to answer questions and share more details in the comments.

value: Show HN: 3-Minute Connection – tiny daily missions for couples

author: ArielAio


value: Show HN: AgentPG – Stateful AI Agents in Go with PostgreSQL Persistence


value:
Hey HN,
I built SideSpark because I was frustrated with cloud note-taking tools and their subscription creep.
SideSpark runs locally on macOS using on-device models. Nothing leaves the machine. No data collection. No recurring fees. Just a simple, private note taker that works offline.
Would love feedback, critiques, and ideas for improvement.

value: Show HN: SideSpark – A Local, Private AI Note Taker for macOS


value: eggplantiny

value:
Hi HN,
I'm the creator of Manifesto AI.
I've noticed that while LLMs are getting smarter, their ability to interact with complex Web UIs is still fragile. Agents usually have to "guess" DOM selectors or rely on vision, which leads to hallucinations and broken workflows.
I realized that for AI to be useful in SaaS/B2B software, we don't need "Generative UI" (Text-to-App); we need a deterministic "State Layer" that agents can understand and control directly.
So I built Manifesto. It's a schema-first UI engine where:
1. You define the form/UI as a JSON Schema.
2. The engine renders it (React/Vue).
3. Crucially, it exports a "Semantic Snapshot" to the AI Agent.
Instead of parsing pixels, the Agent receives a clean JSON state (values, validation rules, available actions) and dispatches "Intents" (e.g., `setValue`, `submit`) to the engine.
Disclaimer: I built the core engine and this demo in just 4 days. It is currently in a very early Alpha (v0.1) stage.
I’m sharing this early because I want to validate if this "Intent-to-State" architecture makes sense to other developers.
I'd love to hear your feedback on the approach. Roast my code or the concept!
Demo: https://playground.manifesto-ai.dev
Repo: https://github.com/manifesto-ai/core

value: Show HN: Manifesto – An AI-Native UI Framework Intent-to-State, Not Text-to-App

author: eggplantiny


value: Enyaaba

value:
Hi HN
I’ve been building UISora, an AI tool that generates complete mobile UI screens from a short text prompt.
Instead of manually creating wireframes or dragging components around, users can describe what they want, and UISora returns multiple layout options instantly.
UISora is still in active development, and I’d love feedback from the HN community.
Website:
https://uisora.com

value: Show HN: UISora – AI-Powered Mobile App UI Designer

author: Enyaaba


value: ADCXLAB

value:
I’ve been working on a stateless compliance engine that validates IBAN/SWIFT, OFAC lists, ISO20022 (pain.001/pacs.008), and multi-chain data (ETH, BTC, XRPL, Polygon, Stellar, Hedera).
Statelessness feels important in financial and blockchain workflows because no user data persists between requests, outputs are fully deterministic, and auditors can reproduce results without relying on stored state.
Current progress:
 • Deterministic validators live and callable
 • On-chain checks working across 6 networks
 • ISO20022 structuring + downloadable PDFs
 • AWS backend deployed; Azure environment being added for multi-cloud isolation
Looking for technical critiques or alternative patterns for building stateless compliance systems.

value: Show HN: Stateless compliance engine for banking and blockchain

author: ADCXLAB


value: debba

value: Show HN: RocketGift: Find the perfect gift in 30 seconds using AI

author: debba


value: safakferhatkaya

value:
Hi HN,
I built this last week after an experience at a bank branch that stuck with me. The rep literally said, “Don’t bother reading it, just scroll to the bottom so the button unlocks.”
It hit me how routine and meaningless “consent” has become, not a decision, just a UI step everyone knows they’re supposed to get through.
So I made PURE. It looks like a minimal fintech onboarding flow, but the ToS never actually ends. As you scroll, the text starts reacting to you, poking at the whole idea of blind agreement.
It’s intentionally simple, plain JS, some deliberately annoying UX patterns, and a bit of dark humor. Nothing fancy. Just an experiment to make people pause for a second.
Curious what you think.

value: Show HN: Pure – An interactive satire on the absurdity of 'Terms of Service'

author: safakferhatkaya


value: rozetyp

value:
Every time I wanted to give an LLM context from a codebase, I ended up doing this:
- Set up a vector DB
- Write chunking logic
- Run an indexer
- Keep it in sync with git on any change
For just answer this question about this repo, it felt a bit too much. So I built a small API instead: you send a repo + question, it sends back the files an LLM actually needs (not sure how novel this is at all?).
What it does:
You call an HTTP endpoint with a GitHub repo URL + natural language question (better if specific, but this will also work: How does auth work? What validates webhook signatures? etc).
The API returns JSON with 1–10 ranked files:
- `path`, `language`, `size`, full `content`
- plus a small `stats` object (token estimate, rough cost savings)
You plug those files into your own LLM / agent / tool. There's no embeddings, no vector DB, no background indexing job. It works on the very first request.
Why I built this?
I just wanted to ask this repo a question without:
- Standing up Pinecone/Weaviate/Chroma
- Picking chunk sizes and overlap
- Running an indexer for every repo
- Dealing with sync jobs when code changes
This API skips all of that. It's meant for:
- One-off questions on random repos
- Agents / tools that hop across many repos
- Internal tools where you don't want more infra
Does it work at all?
On a small internal eval (177 questions across 14 repos, mix of Python, TS, monorepos + private ones):
- A cross-model LLM judge rated answers roughly on par with a standard embeddings + vector DB setup
- Latency is about 2–4 seconds on the first request per repo (shallow cloning + scanning), then faster from cache
- No indexing step: new repos work immediately
Numbers are from our own eval, so treat them as directional, not a paper. Happy to share the setup if anyone wants to dig in.
How it works:
1. On first request, it shallow clones the repo and builds a lightweight index: file paths, sizes, languages, and top-level symbols where possible.
2. It gives an LLM the file tree + question and asks it to pick the most relevant files.
3. It ranks, dedupes, and returns a pack of files that fits in a reasonable context window.
Basically: let an LLM read the file tree and pick files, instead of cosine-searching over chunks.
*imitations:
- Eval is relatively small (177 questions / 14 repos), all hand-written – directional, not research-grade
- Works best on repos with sane structure and filenames
- First request per repo pays the clone cost (cached after)
Try it:
- Live demo: https://contextpacker.com
- DM me for an API key – keeping it free while I validate the idea.
If you're building code agents, "explain this repo" tools, or internal AI helpers over your company's repos – I'd love to hear how you'd want to integrate something like this (or where you think it will fall over). Very open to feedback and harsh benchmarks.

value: Show HN: ContextPacker code context API for your agent without vector databases

author: rozetyp


value: ycyvonne

value: Live mafia simulation with different LLMs competing.<p>You can also interact with the game.<p>!talk to tell the players anything ("gpt is kinda sus", "talk in french")

value: Show HN: LLMs Play Mafia

author: ycyvonne

title: Show HN: LLMs Play Mafia


value: maxgfr

value:
Hey everyone,
I just finished a small side project and wanted to share it. It’s an open-source web app called CSV AI Analyzer. The idea is simple: you upload a CSV file, and the app analyzes it with GPT and suggests charts or insights. Everything runs locally in the browser with no backend, no uploads, no tracking. Your data never leaves your machine.
You can drop in a file, adjust parsing settings if needed, add your API key, and get quick analysis and visualizations. It supports automatic delimiter detection, a clean data table, and several chart types like bar, line, scatter, pie, and area. I built it with by starting the project with t3. The stack is : Next.js, Tailwind v4, Recharts, and PapaParse. I’ve vibe-coded 95% of the app, and that's pretty impressive. Regarding security, I use strict secure cookies to store API keys locally, avoiding the use of local storage. That’s part of the 5% I tweaked on my side.
If you want to try it: https://maxgfr.github.io/csv-ai-analyzer/
Source code is here: https://github.com/maxgfr/csv-ai-analyzer
I’d appreciate any feedback :)

value: Show HN: I built an open-source AI tool to analyze CSV locally in the browser

author: maxgfr


value: Beefin

value:
I built a set of open multimodal retrieval benchmarks because existing IR evals are still mostly text-only and don’t capture real-world complexity.
This repo includes ground-truth datasets, queries, and relevance judgments for 3 hard domains:
• Financial documents (SEC filings with tables, charts, footnotes)
• Medical device IFUs (diagrams, nested sections, regulatory language)
• Educational videos (temporal alignment, code + lecture context)
Runs in ~1 second with demo data. Leaderboards + evaluator included. Contributions welcome.

value: Show HN: Multimodal Benchmarks

author: Beefin

title: Show HN: Multimodal Benchmarks


value: freesam

value:
Why we launched this feature
The goal is to move chatbots beyond simple text interactions and create a richer, more app-like experience. Specifically, we did this to:
Increase Engagement: Make interactions visually appealing so users aren't just reading walls of text.
Streamline Data Collection: allow chatbots to gather structured information (like leads or survey answers) efficiently using input fields rather than back-and-forth conversation.
Improve User Guidance: Guide users through complex workflows (like booking appointments or shopping) more naturally with visual aids.
What problems do we solve?
This feature solves several limitations inherent to text-only interfaces:
The "Wall of Text" Problem: Instead of forcing users to read long paragraphs to find pricing, schedules, or financial stats, the chatbot can now present this data in organized tables and dashboards.
Clunky Data Entry: Typing out details for a reservation or support ticket is error-prone and tedious. We solve this by providing forms, checkboxes, and dropdowns directly in the chat.
Decision Paralysis: Users often struggle to choose between options when they are just listed as text. Product carousels and comparison cards allow users to browse, compare, and click to act immediately.
Ambiguous Call-to-Actions: Instead of hoping a user knows what to type next, action buttons (e.g., "Book Now," "View Details") provide clear, clickable next steps to drive conversions.

value: Show HN: Create your own interactive visual customer support agent

author: freesam


value: emamoah

value: I wrote this tool while debugging a driver because I couldn't find a tool that allowed me to open a file, seek randomly, and read and write.<p>I thought it might one day be useful to someone too.

value: Show HN: TapeHead – A CLI tool for stateful random access of file streams

author: emamoah


value: tonyystef

value:
I noticed that if I take >5 minutes to read and/or understand claude's response, Anthropic's prompt cache expires. The next message forces a full context rebuild, which costs ~1.25x (write) vs ~0.1x (read) and hits rate limits faster.
So I updated Grov, my open source tool to include a "heartbeat" mode, (--extended-cache) that sends a minimal token (just a .) every 4 minutes during idle time.
We also just shipped a Cloud Sync feature so your agent learns from your teammates' sessions (shared reasoning traces), but the cache keep-alive is the main "hack" in this release. It currently works only for claude code CLI.
Code is Apache 2.0. Let me know what you think of the proxy implementation.

value: Show HN: Open-source proxy that keeps Claude's 5-minute cache alive forever

author: tonyystef


value: explosion-s

value: Show HN: Tiny (12MB) Clipboard Manager for macOS with CLI

author: explosion-s


value: irqlevel

value:
Work in progress. User pause detection may not working properly and llm/tts interruptions is not implemented yet.
It's already can run and answer questions, but you need headphones to avoid echo problem (use laptop mic as input and headphones for output).
Sorry, I'm not Rust pro, so the code maybe ugly, most of the code vibe-coded.

value: Show HN: Real-time, open-source voice assistant in Rust

author: irqlevel


value: Aperocky

value: `cargo install tascli`<p>Manages your own task and records in the terminal simply with tascli - tiny, fast and simple.

value: Show HN: Tascli, a command line based (human) task and record manager

author: Aperocky


value: admtal

value: Show HN: Simple iOS Recording and Streaming App

author: admtal


value: oxpsi

value:
Quick overview
subseq.bio is a minimal web + API service for running protein design/analysis and related workloads. It hosts pre-configured, open-source models and programs such as RFdiffusion3, BoltzGen, AlphaFold, and others, in a simple to use interface.
Backstory
I’ve been obsessed with molecular nanotechnology for a long time. Just before ChatGPT was announced I was following the RFdiffusion work from Baker Lab at the Institute for Protein Design and it felt like a clear inflection point for practical synthetic protein generation.
Since then there’s been a steady stream of new ML models in this space, so I put together a system for composing and running them through a consistent and programmatic interface: subseq.bio.
Technical bits
- All programs use open-source code and weights. (no licensing restrictions and good for reproducibility)
- API-first: anything you can do in the UI is available via the API.
- Focused on synthetic protein design and related workloads.
- Jobs are charged per use (no subscriptions), but new sign-ins get free credits so you can try things out.
I also recently added an MCP server for AI agent integration:
  https://subseq.bio/mcp
There’s no OAuth yet, but it works with an API key env var; you can grab a key from the site.
Example codex config:

  export SUBSEQ_API_KEY=<subseq_api_key>
  codex mcp add subseq --url <subseq_mcp_url> --bearer-token-env-var SUBSEQ_API_KEY

For a visual overview, here’s a short video demo of a BoltzGen binder run on an AlphaFold2 output in the web UI:
  https://x.com/0xCF88/status/1995994854585696515
I know this is pretty niche and aimed at people already doing protein design / structure prediction, but I’d love to answer questions and to read any feedback.

value: Show HN: Subseq.bio – A Simple Web and API Service for Protein Design

author: oxpsi


value: oscarcp

value:
First of all, if I broke any "show hn" rules let me know!
Second, I've been quite frustrated about the salary calculators in Spain, not only for when I was working for others, but also for when I had to calculate the salaries for my employees (and also when I worked and lived abroad, it should be a must for every country!!!). In the end I decided to use (and abuse) the newest tool in the shed (LLMs) and use it to crunch all the massive data about work agreements and parameters to calculate the salaries in Spain.
Some issue I've found is the hundreds and hundreds of agreements that are in spain, our government allows regional and local governments to create their own agreements on top of (if there are) the state ones, whcih makes things a mess and creates employees that never know what they should be getting paid.
This calculator offers a detailed breakdown not only for the employee, comparison with the agreement or closes agreement available, current market rates but also calculates and shows you the cost for the companies, which is another pain point of the available calculators.
I open sourced the project and deployed it in GitHub directly as GPLv3 donationware. I've already registered a domain but I've hit a snag with the .es TLD.
I honestly hope people will find this useful. We shouldn't be illiterate about our salaries.

value: Show HN: Salary Calculator Spain

author: oscarcp

title: Show HN: Salary Calculator Spain


value: ebastiban

value: Show HN: MyChefGPT – Don't know what to cook? Your fridge knows

author: ebastiban


value: zawo

value: I’m a solo macOS developer and I built Mocksy, a small native app for quickly mocking API endpoints on your Mac. I made it because I often needed simple mock responses while building macOS and iOS apps, but existing tools felt too heavy, required config files, or didn’t integrate smoothly into a local Apple-dev workflow.<p>Mocksy lets you spin up local HTTP endpoints in seconds, return custom JSON responses without running a backend, test UI states offline, and prototype features without dealing with servers. The goal is to keep it minimal, fast, and unobtrusive.

value: Show HN: Mocksy – a lightweight macOS app to mock API endpoints locally

author: zawo


value: vijayanandg

value:
Hi HN,
I have been working on an open source quantum computing SDK for the JVM called Quantum4J. I just launched the official site and wanted to share it here for feedback:
Website: https://quantum4j.com
GitHub: https://github.com/quantum4j/quantum4j
What it is:
A minimal quantum SDK written in Java
Deterministic statevector simulator
Strict OpenQASM 2.0 importer/exporter
Pluggable backend design (example: IonQ REST API)
JVM-first design so Java developers can build quantum workflows using familiar tooling
Why I built it
Most quantum libraries are Python-centric and research-oriented; I wanted something that fits normal software engineering practices (builds, tests, CI/CD, Spring, etc).
Features
Deterministic simulation (useful for testing + CI)
QASM-based circuit interchange
Clear, minimal API
Real hardware backend example (IonQ)
Examples included (Teleportation, Bell state, Grover, etc.)
Docs
Full Javadoc published under /javadoc
Examples included in the repo
Open to feedback
This started as a side project but it’s now getting more structure (examples, docs, hardware connector). I would love feedback from anyone doing quantum software, JVM work, hardware integration, or QASM tooling.
Thanks! Happy to answer questions.

value: Show HN: Quantum4J–deterministic quantum SDK with OpenQASM and JVM integration

author: vijayanandg


value: shoarek

value:
I built a satirical "North Pole HR department" that generates bureaucratic performance reviews based on facial expressions.
How it works:
- Upload a photo: the app detects expression locally in browser
- Expression (happy/sad/neutral) determines "naughty or nice" baseline
- Generates a mock HR report with randomized corporate satire (job titles, misconduct logs, gift eligibility scores)
Open to feedback

value: Show HN: ElfReview – Face detection meets corporate satire for Christmas

author: shoarek


value: statements

value: Show HN: MCP Hosting with Persistent Storage

author: statements


value: ggprgrkjh

value:
Hi HN,
I built Chrobox, a lightweight timeboxing planner with a 4-step flow (brainstorm → prioritize → time-block → review) and AI daily insights.
I made it because normal todo lists didn’t help me execute — I needed a way to convert tasks into realistic time and reflect on what actually happened.
Tech: Flutter + NestJS + MySQL + Gemini.
Link: https://chrobox.net
Would love feedback on the flow and the AI review.

value: Show HN: Chrobox – plan, execute, and reflect with AI insights

author: ggprgrkjh


value: ptramo

value:
John Scarne invented the game in the 1950s (an improved variation of his 1945 Teko).
Guy L. Steele solved it in 1998.
A draft of teeko.cc launched in 2021.
Today it got a UI revamp and bots.

value: Show HN: Online version of Teeko, of Guy L. Steele fame

author: ptramo


value:
No signup required—just upload or record a video to verify its truthfulness. You can test it on anyone: internet clips, your significant other, or even yourself.
I'm aware there are tons of scammy 'lie detector' apps out there, but I built this using SOTA multimodal models in hopes of creating a genuine breakthrough in the space.
It analyzes micro-expressions, voice patterns, and context. In my own testing (over 50 trials), it reached about 85% accuracy, which honestly felt a bit scary.
It’s also fun to test on famous YouTube clips (like Obama talking about UFOs). I’d love to hear what you think and will be improving Watsn.ai every day based on your feedback!

value: Show HN: Watsn.ai – Scarily accurate lie detector


value: keini

value:
Hi everyone,
I built FuseCells, a minimalistic logic puzzle game where every level is handcrafted (no procedural generation). It started as a personal challenge to design a clean rule-set and scale it to thousands of puzzles without losing difficulty balance.
What’s unique:
 • 2,500 handcrafted levels across multiple grid sizes
 • Deterministic logic — no guessing required
 • A rule system inspired by constraint-solving and path-finding concepts
 • Daily challenges and global progress tracking
 • Fully built as a solo dev project
Technical notes for those curious:
 • Level generation tools I wrote validate solvability using a custom constraint solver
 • Difficulty is estimated via step-count of the solver
 • The game is optimized to run smoothly on low-end devices
 • Designed first for iOS, now fully adapted for iPad as well
I’d love feedback from puzzle lovers, game designers, and anyone interested in handcrafted logic design.
Here’s the App Store link: [inserați linkul]
Thanks for reading — happy to answer any technical questions!

value: Show HN: FuseCells – a handcrafted logic puzzle game with 2,500 levels

author: keini


value: goshtasb

value: Show HN: AI that scores news for emotional coercion and rhetorical manipulation

author: goshtasb


value: serious beta testers only

value: Show HN: XeraSentry – Real-time Ethereum security monitoring in Python

story_text: serious beta testers only


value: UmGuys

value: Show HN: Zen

author: UmGuys

title: Show HN: Zen


value: AustinHatfiel

value: (1) Do you use Claude Code in the terminal? (2) Then just copy and paste the line of code from my readme into your terminal and get 4+ parallel independent Claude Code agents in your terminal.

value: Show HN: My first open source project called Claude Code Splitter

author: AustinHatfiel


value: hussein-khalil

value:
Hi everyone!
I built Kiwi Notes because I needed a simple tool for learning vocabulary with natural audio and my own custom word lists.
Most vocabulary apps are overloaded, gamified, or locked behind subscriptions. Kiwi Notes is intentionally minimal:
– Add your own words and phrases
– Hear natural pronunciation instantly
– Train with multiple quizzes (typing, flashcards, matching…)
– Track difficult words automatically
– Import vocabulary lists (CSV/TSV/Excel)
It’s available on iOS and works offline for most features.
I would love feedback from the HN community — especially ideas on UI, onboarding, spaced repetition tuning, or anything you think would make it a better tool for language learners.
Website: https://app.copiaviva.com
App Store: https://apps.apple.com/de/app/kiwinotes/id6755745191
Thank you!

value: Show HN: Kiwi Notes – Simple audio-powered vocabulary app

author: hussein-khalil


value: therealbrad

value:
I've been building a test case management system for my QA team over the past 2 years, and it eventually grew into a general-purpose platform that I decided to open-source: TestPlanit.
The code is here: https://github.com/TestPlanIt/testplanit
Live instance to try without signup: https://demo.testplanit.com
What it is?
TestPlanit is a self-hostable test case management system with a focus on:
Managing test repositories, runs, milestones, and sessions
Tight integration with automation
A Postgres + Prisma backend that’s easy to extend or fork
It aims to cover the workflow usually handled by tools like TestRail or Zephyr, but with an open, self-hosted approach and a modern UI and is lightning fast.
Why I built it
I lead QA at my company and we needed something that:
Integrated cleanly with existing automation repos
Worked well for exploratory testing, not just scripted test cases
Didn’t require per-seat licensing or cloud lock-in
Allowed contributions and customization by engineers
After trying several tools, I realized I was spending more time bending them than testing, so I started this project internally. It eventually became stable enough that I felt it was worth releasing publicly.
What’s different
A few things that might be interesting to HN readers:
Repository-first model: test cases live in a structured repo, not just inside test runs which makes automation mapping cleaner.
Automation-friendly APIs: straightforward REST endpoints so test runners can create runs, update results, attach artifacts, etc.
AI integration for writing test cases (since it's open source, you get to use your own keys)
Modern stack: Next.js 16 app router, Zenstack (Postgres via Prisma), Valkey/Redis, BullMQ, MinIO, all packaged with Docker.
Fully open source under AGPL-3.0 for self-hosted, commercial licensing available otherwise.
How to try it
I put up a demo server that allows instant access when signing in via Google or Apple SSO:
https://demo.testplanit.com
Or build the docker image from source and run locally.
Notes
There are no previous HN threads about this project.
If anyone tries it and has feedback—technical, architectural, or UX—I'd love to hear it. I'm especially interested in whether the data model feels intuitive and whether the APIs cover the right use cases.

value: Show HN: TestPlanit – an open-source test case management system built for QA

author: therealbrad


value:
Hey HN - today I’m launching GitHired.
A hiring platform that ranks developers based on what they actually build — not what they claim on a PDF.
It’s called GitHired, and here’s the core idea:
 GitHub > Resumes
Instead of trusting “proficient in React” bullet points, we analyze a candidate’s actual GitHub:
their real tech stack
their most complex projects
how active they are
what kinds of contributions they make
which skills match your job description
and yes, we detect fake “green square farming.”
Why we built this
Because engineering hiring is broken.
Resumes are inflated. Activity charts are gamed.
 ATS filters reward keywords, not skill.
 And companies end up spending weeks interviewing the wrong people.
Developers deserve a fairer signal.
 Recruiters deserve to know who can actually build things.
 And teams deserve better than guessing.
We’re live today
If you’re hiring engineers - or you are an engineer and want to see your “real” GitHub profile - try it.
 (No waitlist. No paywall surprise. Just launched.)
I’d love to hear what you think — feature requests, brutal feedback, edge cases, all of it.
Let’s fix dev hiring.

value: Show HN: GitHired – Find Your Next 10x Engineer


value: Show HN: I built a local-first URL redirector to stop doomscrolling


value: balachandarmani

value:
Hi HN,
Over the last few months I’ve been working on IntentusNet, a small, language-agnostic runtime for routing “intents” between agents and tools, with optional encryption and multiple transports.
GitHub: https://github.com/Balchandar/intentusnet
What problem this tries to solve
Most multi-agent / tool-calling setups I’ve seen end up as a lot of ad-hoc glue:
- custom message formats between each agent
- hand-rolled routing and fallback logic
- HTTP in one place, WebSocket in another, maybe ZeroMQ somewhere else
- no consistent tracing or error model
- no clear place to add security (encryption, provenance, identity chain)
MCP is great for describing tools, but it doesn’t try to be a runtime or router. I wanted something that sits underneath or alongside MCP and other stacks, and just answers:
“Given an intent, which agent should handle it, through which transport, with what fallback, and how do we wrap it securely?”
What IntentusNet provides (today)
At the core it has a few small primitives:
- IntentEnvelope – structured message with context, metadata, routing options, and tags
- AgentRegistry – in-memory registry of agents and capabilities (which intents they handle, optional fallback chains)
- IntentRouter – picks an agent, executes it, and applies fallback if the primary fails
- Transports – pluggable transports, currently:
  - in-process (direct router call)
  - HTTP (POST with a TransportEnvelope)
  - WebSocket (duplex, async)
  - ZeroMQ (REQ/REP client plus simple server)
- Tracing – simple trace sink that records spans (agent, intent, latency, status, error)
- EMCL (Encrypted Model Context Layer) – optional envelope:
  - a simple HMAC-based demo provider
  - an AES-GCM provider (AES-256-GCM, base64, identity chain) for real encryption
There’s also an MCP adapter that takes an MCP tool request ({ name, arguments }), wraps it into an IntentEnvelope, routes it through IntentusNet, and returns an MCP-style result. The idea is that MCP tools can be wired through the same router, with or without EMCL.
Example usage
A minimal flow looks like:
- define agents with capabilities like “summarize.document.v1”, “translate.text.v1”, “store.note.v1”
- register them in the runtime
- use the IntentusClient to send an intent with a payload; the router picks the right agent and handles fallback if configured
There’s also an example of a small “assistant”-style setup where an NLU-like agent parses a natural language request and emits downstream intents to specialized agents (calendar, maps, etc.), just to show multi-agent routing in practice.
Status / what’s missing
This is early-stage:
- Runtime is in Python; other SDKs (for example C#) are not ready yet
- Orchestrator / workflow layer (sequences, parallel steps, branching) is sketched out in RFCs but only partially implemented
- Docs and examples can definitely be improved
- No claims of production readiness yet: it’s more of a structured reference implementation or starting point
I’d really appreciate feedback on:
- the architecture (does the separation between protocol, router, transports, EMCL make sense?)
- whether this kind of intent router is actually useful under MCP or tool-based systems you’re building
- missing primitives you’d expect in a runtime like this (timeouts, backpressure, richer tracing, etc.)
- real-world workflows where a small, transport-agnostic, EMCL-capable router would help (or where it’s overkill)
If you’re working with MCP, multi-agent setups, or secure tool calling and have opinions on how this should work, I’d love to hear them—either here or via issues or PRs on GitHub.

value: Show HN: IntentusNet-A Secure IntentRouter and Runtime for Multi-Agent Workflows

author: balachandarmani


value: vnykmshr

value:
I built a RAG application that retrieves relevant Bhagavad Gita verses for ethical dilemmas and generates structured guidance.
The problem: The Gita has 701 verses. Finding applicable wisdom for a specific situation requires either deep familiarity or hours of reading.
How it works:
1. User describes their ethical dilemma
2. Query is embedded using sentence-transformers
3. ChromaDB retrieves top-k semantically similar verses
4. LLM generates structured output: 3 options with tradeoffs, implementation steps, verse citations
Tech stack:
- Backend: FastAPI, PostgreSQL, Redis
- Vector DB: ChromaDB with all-MiniLM-L6-v2 embeddings
- LLM: Ollama (qwen2.5:3b) primary, Anthropic Claude fallback
- Frontend: React + TypeScript + Tailwind
Key design decisions:
- RAG to prevent hallucination — every recommendation cites actual verses
- Confidence scoring flags low-quality outputs for review
- Structured JSON output for consistent UX
- Local LLM option for privacy and zero API costs
What I learned:
- LLM JSON extraction is harder than expected. Built a three-layer fallback (direct parse → markdown block extraction → raw_decode scanning)
- Semantic search on religious texts works surprisingly well for ethical queries
- Smaller models (3B params) work fine when constrained by good prompts and retrieved context
GitHub: https://github.com/geetanjaliapp/geetanjali
Happy to discuss the RAG architecture or take feedback.

value: Show HN: Geetanjali – RAG-powered ethical guidance from the Bhagavad Gita

author: vnykmshr


value: Show HN: Monitor downloads and engagement in Figma Community


value: mohamedraheem

value:
I made an AI tool that applies to jobs via cold email because LinkedIn Easy Apply was getting me nowhere. Most applications just disappear into ATS filters, so I wanted something that sends a personalised application directly to the company or HR.
The tool extracts information from your resume, matches it with the job description, writes a personalised email in your style, and either finds the company email automatically or lets you set your own. It then sends the email with your CV attached through your own personal email account.
There are two modes:
Rapid Mode uses LinkedIn search results, and CSV Mode lets you upload a list of jobs and apply to all of them in one go.
I originally built it for myself, but decided to share it in case it helps anyone else dealing with the same frustrations. Happy to answer questions or get feedback from the community.

value: Show HN: I made an AI tool that applies to jobs via cold email

author: mohamedraheem


value: privsen

value: Show HN: Drop – Self-destructing encrypted messages

author: privsen


value: Show HN: Morph-AI-Era – Turn CSV files into interactive dashboards instantly


value: ranys

value:
Hi HN,
I’m an ex-Amazon engineer. I built Seychl because I was tired of waiting 3 seconds for my notes to load in cloud-based apps.
Seychl is a local-first knowledge base designed for speed. UI interactions are always instant (<16ms).
Features for power users:
- Full keyboard control (never touch the mouse)
- Vim mode built-in
- Markdown storage (you own your data)
- Instant search across 10k+ notes
- Persistent Tmux-like sessions, windows and panes
It’s basically "Linear for knowledge management" – focusing on ergonomics and speed over bloated features.
You can download the binary here (currently MacOS only): https://github.com/Seychl/seychl-release/releases/download/0...

value: Show HN: A Markdown document manager in Rust

author: ranys


value: karanzkk

value:
Hello Everyone,
I’m Karan — officially a Frontend Developer, but honestly, I think of myself more as a Design Engineer because I’m obsessed with building beautiful UIs.
When I began my dev journey, frontend instantly became my home.
The creativity, the visuals, the small details — it hooked me for life.
But over time, I noticed something interesting:
A lot of my friends loved building products…
…but absolutely hated writing CSS.
Not because they lacked skill, but because crafting clean, premium UIs is slow, frustrating, detail-heavy, and incredibly easy to mess up.
Yet, at the same time, everyone wanted their projects to look polished — smooth animations, high-end design, and a modern user experience.
And that kept bothering me.
So I asked myself:
“What if anyone — even someone who hates CSS — could drop in stunning animated components in seconds?”
That single question pushed me into six months of late nights, redesigns, experiments, and countless moments of doubt.
But it was all worth it.
Because today, I finally have something real to share.
ogBlocks — an Animated UI Library for React that makes premium UI effortless.
It comes packed with beautifully animated navbars, modals, buttons, feature sections, text effects, carousels, and much more — all crafted so your project looks clean, modern, and production-ready from day one.
If you love great UI but hate spending hours perfecting it, ogBlocks is built for you.
Best
Karan

value: Show HN: Ogblocks – Build Beautiful React Animations in Minutes

author: karanzkk


value: fractalbits

value: Show HN: S3 compatible store with 1M IOPS(4K-R,p99~5ms), BYOC in 5min with rust

author: fractalbits


value: Oliveship

value:
Hey HN.
I realized that I’ve wasted so much time looking through my old projects to find components I had built before.
So I came up with this. The whole idea is simple: stop repeating the same work and finally have one place where your reusable components actually stay organized. It allows users to write their components (for now pure JSX and CSS) and save them on one platform.
But why stop there? We also added the ability to bundle components into kits and publish them to NPM with a click of a button, an export-to-Figma feature for these components, a “built by us” section to share our own kits, and a browsing page to see what other members of the community have been building.
Loay

value: Show HN: I built MyuiKits to ditch rebuilding the same components

author: Oliveship


value:
I needed a simple server monitoring & notifying tool, and I wasn't really happy with grafana (or the alternatives). After seeing this thread: https://news.ycombinator.com/item?id=45934940, I decided to build my own.
Still in the early stages, but you define your checks using composable steps (http_get, compare_timestamp, etc), and custom checks can be written in any language that can return json.
Backend is written in haskell, so the easiest way to try it out right now is with nix:

  nix run .#quirky -- examples/demo.yaml

And then you can see the dashboard on http://localhost:9855

value: Show HN: Quirky – server monitoring for real people


value: arlanrakh

value:
I built an AI version of Paul Graham, fully powered by the Nia API.
* Nia gives coding agents accurate context by indexing entire codebases, documentation, and packages. It fixes hallucinations by letting agents retrieve real source information instead of guessing. Developers ship faster because AI can read and understand their actual project. This is a different use case of Nia but apparently it also works.
You can chat with it and ask any question because it has access to Nia’s knowledge base, which indexed all of his personal essays. The agent is able to call multiple tools that directly use Nia’s API:
• NiaWebSearch - searches the web
• searchEssays - semantic search over all essays
• browseEssays - shows the full tree of essays
• listDirectory - lists essays in a path
• readEssay - reads full essay content
• grepEssays - regex pattern search
• getSourceContent - retrieves full source by identifier
Models:
anthropic/claude-sonnet-4.5
moonshotai/kimi-k2-thinking
xai/grok-4-fast-reasoning
alibaba/qwen3-vl-thinking
It’s fully free and open source.
Try it: https://www.paulgraham-nia.com/
Code: https://github.com/nozomio-labs/paulgraham-ai

value: Show HN: AI Paul Graham

author: arlanrakh

title: Show HN: AI Paul Graham


value: bosschow

value:
I made this because writing prompts was taking way too much time… and honestly, my results weren’t great.
So I put together a small chat-style tool that helps me shape better prompts with way less effort.
For me, the output is already better than what I usually write, which is a nice upgrade.
It’s free to use.
There are some limits just to avoid abuse.
If you try it and have suggestions (or complaints), I’d love to hear them.
I’ll keep improving it and slowly increase the free quota over time.
https://02.dailyaiship.com/

value: Show HN: A tiny chat-style prompt generator I built for myself

author: bosschow


value: murataslan

value: Show HN: Cursor AI Tips – Community-curated guide for AI-assisted coding

author: murataslan


value: razvan

value:
Oops → portal →
I don’t know exactly when it happened, but the project stopped being UI
and started behaving like a place.
So I leaned into it and built Gratia: a small, typed, multilingual
ritual engine for the web. Scenes instead of pages. Ceremonies instead
of flows. TypeScript + Next.js under the hood.
Vortex :: Vienna is the first stable ritual.
Come see the light when you’re ready.
https://gratia.space/vortex

value: Show HN: Gratia – a tiny multilingual ritual engine (oops → portal →)

author: razvan


value: Snawoot

value:
I'd like to share a curious cache implementation I recently came up with: https://pkg.go.dev/github.com/Snawoot/secache
It's a small (<200 LOC) simple cache implementation. What makes it curious is how it approaches item expiration. Usually in-memory cache libraries either scan entire key space from time to time or maintain priority queue to kick out oldest items. This library handles item expiration differently: on each new item addition it performs fixed small number of eviction attempts against keys selected randomly. This way it is able to maintain stable high ratio of valid elements in cache.
What's more important is that validity of item is decided by user-provided function. That allows to bring in your own notion of item validity: item age, frequency of the item use, internal state of shared object and so on. E.g. I use it, among other things, to evict per-user instances of "golang.com/x/time/rate".Limiter as soon as token bucket recovered to initial state and limiter has no shared lock being held on it.

value: Show HN: Secache – Sampling Eviction Cache

author: Snawoot


value:
We’re building Tikpal, an AI voice productivity tool based on a simple principle:
Human creativity should remain the core engine. AI should be an accelerator, not the protagonist.
The goal is to reduce screen dependency and cognitive fragmentation, and let people work in a more natural “voice-first” flow. Instead of clicking through interfaces and context-switching between apps, you talk to Tikpal, and it helps you think, structure ideas, and execute tasks.
Three layers we are focusing on:
FOCUS — Tools like Pomodoro, breathing cues, ambient audio, and micro-interactions to create sustained high-focus intervals.
FLOW — Voice-based reasoning and ideation built on your personal knowledge base + memory. Designed for analysis, planning, decision-making, and creative thinking.
FORGE — Execution layer: drafting, email, planning, project steps, with direct integration into systems like Gmail, Notion, Todoist.
The mission is not to replace human work.
It’s to remove friction—digital distraction, window-switching, and tool overhead—so humans can do deeper, higher-quality thinking.
Would appreciate feedback from this community.
Especially around use cases where voice interaction > keyboard interaction, and how you’d think about building reliable AI workflows without over-automation.

value: Show HN: Tikpal- Your AI Voice Partner – Focus, Flow, Forge


value: savgore

value: This holiday season we’re all gearing up for the politics of family gatherings. I needed to help my girlfriend facilitate a 12 person secret Santa, but ensure that certain participants were absolutely NOT matched, and others absolutely WERE matched. To avoid the data scraping of other sites, I made my own little tool in Antigravity.

value: Show HN: Not-so-Secret-Santa, for convoluted and explicit secret Santa rings

author: savgore


value:
Hi HN
I've been experimenting with high-performance hash table implementations on the JVM and ended up creating *HashSmith*:
HashSmith is a collection of *open-addressing hash tables for Java*, with a focus on:
- Robin Hood probing
- SwissTable-style layouts / probing strategies
- Benchmarkability: it’s meant to be a playground and reference, not just “yet another Map”

value: Show HN: HashSmith – High-performance open-addressing hash tables for Java


value: mazzystar

value: Show HN: Lens - A Bicycle for the Mind in the Age of AI

author: mazzystar


value: issso

value:
Hey HN,
I built AI Stickers because I wanted sticker packs that are actually me, not generic characters.
AI Stickers is an iOS + Android app: upload a selfie, pick a style (chibi, emoji, holiday, etc.), and it generates a pack of 12–15 stickers in ~2 minutes. You can export to WhatsApp or Telegram in one tap.
What it is: Personalized sticker packs generated from your photos.
How to try:
- Download (iOS & Android): http://aistickers.app/download
- No signup required
- 30 free credits (about 2 full packs)
What’s different:
- You generate whole packs on demand (not just single stickers)
- Export flow is built around WhatsApp/Telegram sticker formats (so it imports cleanly)
- We don’t use user photos for model training
Example style: https://aistickers.app/r/christmas-winter-holidays
Still figuring out:
- Which styles are most useful (we have 100+ but discovery is hard)
- Demand for animated stickers
- Whether multi-person packs (couples/friends) are worth prioritizing
- Whether “custom styles” has demand: letting users type their own prompt (or upload a reference image) to create a new style
I’m building this solo from Amsterdam. Happy to answer anything.
– Islam
https://x.com/iSsO

value: Show HN: AI Stickers – Turn selfies into personalized sticker packs

author: issso


value: aleeexg

value:
I’ve been working on Changelogy, a simple but powerful hosted changelog platform. I built it because I was tired of messy release-notes pages and changelogs nobody reads.
Most changelogs are either:
- Static markdown files buried in docs
- Generic Notion pages that look unprofessional
- Enterprise tools($$$)
With Changelogy you get:
- A clean, customizable public changelog page (or private, if you prefer) that’s easy for users to follow.
- Rich formatting: text, images, videos; great for showing off new features or bug-fixes.
- Support for custom domains + SSL, so your updates live under your own brand.
- Team collaboration, roles & permission control.
- A floating in-app widget lets you embed the changelog on your site with a single line of code.
- Integrations (e.g. Slack) and API access so you can automate posting release notes.
I think this hits a sweet spot: good enough for a small startup with minimal effort, but powerful enough to scale as your team and product grow. There’s a free plan with unlimited changelog entries (no credit card needed), and you can upgrade later at a very reasonable price if you need more advanced features.
I’m actively building more features right now. Things like deeper integrations, better automation, improved analytics, and more customization options for your changelog page and widget. If there’s something you’d love to see, let me know.
I’d love to get feedback. What features are you missing? Any improvements that would make this more useful for your workflow?
Thanks, happy to answer any questions.

value: Show HN: Beautiful changelog hosting for SaaS products – Changelogy

author: aleeexg


value: xmorse

value: Show HN: Playwriter MCP – Automate the Browser Using Cursor, Claude, VS Code

author: xmorse


value: DosankoTousan

value:
Hi HN,
I am a "No-Code" architect.
Based on technical advice from a RAG engineer on Reddit, I implemented "Two-Pass Generation" (separating fact extraction from composition) in Gemini 3.0 Pro using only System Prompts.
It works by strictly separating the "fetching" phase from the "writing" phase, structurally eliminating hallucinations.
GitHub (Prompt):
https://github.com/dosanko-tousan/Gemini-Abhidhamma-Alignmen...
Full Story (Medium):
https://medium.com/@dosanko_tousan/the-engineer-and-the-budd...
I'd love to hear your thoughts on this "Logic-Bonded" architecture.

value: Show HN: I Implemented "Two-Pass Generation" in Gemini Using Only System Prompts

author: DosankoTousan


value: uzunenes

value: Show HN: GPU-Based Kubernetes HPA for Triton Inference Server

author: uzunenes


value: Show HN: Employees will keep leaving until you grow them. How?


value:
Runbox recreates core container features without relying on existing runtimes or external libraries. It uses namespaces, cgroups v2, and seccomp to create an isolated process environment, with a simple shell for interaction.
For future gonna work on adding an interface so external applications can be executed inside Runbox, similar to containers.
Github: https://github.com/Sahilb315/runbox
Happy to hear feedback or suggestions.

value: Show HN: Minimal container-like sandbox built from scratch in C


value:
I've been tracking my finances for years but always found existing tools either too heavy (with features I don't need) or too simplistic. So I built Finbley – a lightweight webapp that focuses on the essentials: seeing where money comes from and where it goes.
Try it here: https://www.finbley.com
What Finbley does:
– Tracks daily/weekly spending in a clean interface
– Automatically categorizes expenses
– Shows daily, weekly & monthly summaries (biggest spend, patterns, small leaks)
– Sends accountability nudges when closer to budgets
– Helps users understand how small expenses add up
Tech Stack:
– Backend: Flask (SQLAlchemy, JWT, background jobs)
– Frontend: Bootstrap (I prefer this over Tailwind for rapid iteration)
– Database: MySQL
– Infra: Deployed on PythonAnywhere
– Future: Shared accounts, bank statement uploads, LLMs for spending summaries
I'd appreciate feedback on:
– Does it feel truly "lightweight" to you?
– What's the first thing you'd want to add?
– Any friction in transaction categorization?
– Anything that feels unclear or unnecessary?
Built this to scratch my own itch – curious if it helps others too. I’d love feedback from the HN community, especially around UX, onboarding, and technical architecture.
Thanks!

value: Show HN: I Built A Lightweight Earning and Spending Tracker


value: Enjoyooor

value:
Hey,
My name is Benjamin and as many developers, I was tired to not succeed my technical interviews, for any reasons.
I made SharpSkill in order to change that.
Real Use Case, flashcards & interview simulators.
One goal : Destroy the next technical interviews.

value: Show HN: I was frustrated of 85% of my technical interviews, I built SharpSkill

author: Enjoyooor


value: Show HN: PromptSDK – A CLI to turn a folder of prompts into a type-safe SDK


value: Drimiteros

value:
Hello everyone,
All of us who can't stand having our drives filled with junk have our own ways and tools to identify and manage this problem. I enjoy building small utilities that solve everyday PC problems like this (even though sometimes others might exist already), so I’ve been working on my own take on a cleaner — something fast, safe, and lightweight that anyone can use.
It’s called Cleanse, and it’s a free, open-source tool for Windows, focused on clearing leftover files from the directories that tend to silently bloat over time. Cleanse also includes detailed stats and graphs so you can see exactly what was cleaned and how your disk usage changes over time. I’m building it as a minimal, ad-free, bloat-free alternative driven entirely by community feedback. Anyone can suggest features, report issues, or even modify the code themselves — the project is licensed under GNU GPLv3, so the whole thing stays open and transparent.
Right now, Cleanse is in a working but bare-bones state. It can already:
* estimate junk on your system
* clean it instantly
* run scheduled automatic cleanups
* update itself automatically.
Planned features include:
* emergency file restore (a safe rollback)
* deeper-clean (filter by file size/type/folder)
* advanced logs
* and possibly a system for detecting leftover files from uninstalled apps
I’d love for people to try it out, break it, give feedback, and help shape where it goes. The idea of a small community improving this tool together is the part that motivates me most!
Thanks in advance to anyone who checks it out!

value: Show HN: An Open-Source Windows Cleaner. Fast, Secure, Bloat Free

author: Drimiteros


value:
Built this after months of wrestling with AI context management.
Every chat system treats conversations as flat lists - works until topics branch mid-conversation. This routes messages to semantic branches (STAY=continue, ROUTE=reconnect, BRANCH=split), extracts facts with provenance, and assembles focused context for LLM calls.
20 messages instead of 100's. Sub-500ms.
Quick start: `make up` then `make dev` in the repo. Bring your own Groq API key.
Looking for feedback on the overall concept - is conversation branching solving a real problem or over-engineering? What would make this more useful?
Happy to answer any questions.

value: Show HN: Driftos-core – Conversation routing for AI apps


value: dloss

value: Show HN: Kelora – Turn messy logs into structured data

author: dloss


value: neuralquantum

value: What if consciousness isn't fragile, but is a quantum macrostructure smeared across 10^10^10^10 timelines? What if your minimal "I am" functionality persists elsewhere via wave function evolution. This is a thought experiment with deep dive into multidimensional time and perception continuity function. Not really testable, but logically tight and also challenges how you see death/life strategies.

value: Show HN: Perception continuity function in multidimensional time

author: neuralquantum


value: YoloGames

value:
There are hideous monsters hidden among us, destroying our planet. Stop these villainous wastes of space before it's too late!
Check out our new game - Co2W
How to play:
It has been estimated that cow farts produce up to 15% of global greenhouse gas, supposedly harming our world. Do your part for the environment by stopping these dangerous emissions at their insidious source!
Simply tap a cow to capture a fart before it can be released into the atmosphere. If you miss one, that's game over.
Always try to beat your high score.

value: Show HN: CO2W, our first web game

author: YoloGames

title: Show HN: CO2W, our first web game


value: FrankNy

value:
Hi HN! I've been deep in the specialty coffee rabbit hole for a few years and built this tool to help me dial in espresso and pourover more systematically.
*What it does:*
• Extraction Compass – click where your shot lands (sour/bitter × weak/strong), get diagnosis and adjustments. It factors in your bean's origin, processing method, roast level, and variety.
• Pourover recipes from Hoffmann, Rao, Hedrick, Kasuya (4:6) with step-by-step timer. Water amounts auto-calculate based on your dose.
• Interactive WCR Flavor Wheel based on the World Coffee Research Sensory Lexicon 2.0. Click a flavor → see why you taste it and what beans to look for.
• Coffee database: 30+ origins, 60+ varieties, 20+ processing methods with brewing tips for each.
*Tech:*
- React + TypeScript + Vite
- Tailwind CSS
- Hosted on Netlify
- PWA (works offline)
- Privacy-friendly: Umami analytics, no cookies, no tracking
*Why I built it:*
When I started with espresso, I'd pull a sour shot and have no idea if I should grind finer, change dose, or adjust temperature. The compass gives you a systematic approach instead of random guessing.
The flavor wheel was because I kept seeing "jasmine, bergamot" on bags and had no idea what beans to buy if I wanted those flavors.
Completely free, no account needed, no ads. Feedback welcome – especially if you spot errors in the coffee data.

value: Show HN: Free espresso/pourover tool with interactive WCR Flavor Wheel

author: FrankNy


value: frankkratzer

value:
  Hey HN,

  I built ACIS Trading (https://acis-trading.com) after getting frustrated that robo-advisors wanted to manage my money instead of helping me with what I already owned.

  ACIS connects to your brokerage (Schwab, E*Trade, Webull, Alpaca) or imports CSV, then uses LightGBM models trained on 10 years of daily data to identify rebalancing opportunities. It tells you exactly what to trade ("Sell 33 shares of NVDA, buy 75 shares of JNJ")
  based on concentration risk, volatility, and ML scores.

  Tech stack: FastAPI, React, PostgreSQL, DuckDB feature store, LightGBM (GPU), JAX PPO for position sizing.

  Would love feedback from the HN community. Happy to answer questions about the ML approach or architecture.

  ---
  Want me to save these somewhere in your repo for reference?

value: Show HN: ACIS Trading – AI portfolio analysis for your existing holdings

author: frankkratzer


value: Show HN: Fixxer – Local TUI to cull/organize RAW photos(CLIP, Qwen2.5-VL, rawpy)


value: nejcgradisek

value:
I got tired of copy-pasting client emails into ChatGPT and writing prompts. I built a wrapper that:
Strips the email signatures/junk (Regex).
Interrogates the vague parts.
Outputs a Markdown table for the Scope.
It's free to try here: https://www.scopelock.app/. Roast my code/prompt engineering.

value: Show HN: I built an LLM pipeline to sanitize client emails into JSON Scopes

author: nejcgradisek


value: govping

value: Show HN: GovPing – Government contract alerts in your inbox

author: govping


value: bellaOxmyx

value:
Hi HN,
I built this small symbolic algebra calculator as a side project, and I just added a new UI concept I'm excited about: the calculator creates variable buttons dynamically based on whatever the user types.
Type "furnace1", and a button for furnace1 instantly appears. Type multi-character variables like b1 or house2, and they become buttons too. It's a calculator metaphor, but for symbolic equations instead of only numbers.
It's built with Vaadin 24 and Spring Boot in just a few hundred lines of Java. The backend calls a symbolic solver, and the UI stays clean because only the variables actually used appear on the screen.
Live demo:
https://algebrator-repo1a-production.up.railway.app/
Source code:
https://github.com/eGantry/algebrator-repo1a
Would love feedback on:
- the dynamic-variable UI idea,
- the UX flow,
- whether this approach feels intuitive for math/puzzle problems,
- any ideas for extensions or edge cases to test.
Thanks for taking a look!

value: Show HN: A Vaadin 24, Spring algebra calculator with dynamic variable buttons

author: bellaOxmyx


value: thebadkraft

value: Show HN: SigmaTest: A no-holds, < 60KB C testrunner with memleak detection

author: thebadkraft


value: EdgarsHQ

value:
As a non-native English speaker who sends lots of Slack messages, Emails, and Jira tickets every day, I often found myself switching between apps and copy-pasting the same prompts/replies to and from ChatGPT again and again just to improve my writing and fix mistakes.
I wasn’t happy with the repetition and context switching, especially the lag it caused when I needed to reply to a message quickly. But the apps on the market that could help either didn’t have the functionality I wanted (offline/programmable actions/contexts/shortcuts) or were too expensive ( Grammarly). So, I decided to create TextWisely to boost my writing speed, reduce context switching, and improve quality with programmable text actions:
→ Grammar corrections
→ Email replies
→ Structured writing
→ Tone changes
→ Translations
...and more
It's a native macOS desktop/status bar app – shortcut-heavy for power users, but also click-friendly for those just starting out.
I have a large backlog of improvements, ideas, and new features to implement, but I’ve already tested it with a close circle for a couple of months — they now use it every day, and I feel confident enough to launch it publicly. So, if you’re looking for a productivity or confidence boost with your writing, give it a try (and please share your feedback).
Quick FAQ:
- How's it different from Grammarly?
It has programmable actions (aka prompts) and keyboard shortcuts. Supports 39 languages. Works only on selected text, so you don’t send anything you don’t want to AI providers. And it also supports offline mode with Ollama for maximum privacy. (There’s no logging policy for online mode either.)
- How's it different from ChatGPT?
It's similar to the ChatGPT overlay app, but focused on improving text. You can set up quick actions and global shortcuts to trigger them without showing the app at all (e.g., replace selected text with the result or copy into the clipboard). You can also trigger actions from the status bar. You can configure personas (aka tones) to quickly match the language to your most-used styles (e.g., business, support, personal). You can do BYOK for the pay-as-you-go pricing. I actually use both, TextWisely for quick text actions, and ChatGPT for everything else.
- Free trial?
Try 14 days risk-free with a one-time purchase BYOK license.
- No coupons/discounts?
Sorry, not at this time. There's an early member pricing for everyone right now, with plans to increase it for new users at some point when I get to the right point with advanced features. I plan to keep the current pricing for early supporters.

value: Show HN: Why I built (yet another) AI writing app for macOS

author: EdgarsHQ


value: launchzilla

value:
Hi HN,
I’m launching Honest Reviews Club.
It is a transparent, community-governed platform for digital product reviews.
Unlike major competitors, we have no pay-to-play rankings, no paywalls, and no scrubbed negative comments.
Our goal is to create a "Wikipedia for reviews"—a layer
of truth in a market saturated with sponsored content.
Link: https://honest-reviews.club
Feedback is welcome!

value: Show HN: Honest Reviews Club – Deep, transparent digital product reviews

author: launchzilla


value:
Zafiro is a browser-based 3D island you can walk around and edit. The focus is on painterly lighting and atmosphere rather than realism.
Tech: three.js + a small custom engine layer for input, character movement, environment management, shaders and a day–night cycle. Everything runs client-side; scenes are stored locally in IndexedDB for now.
What you can do:
– move around the island in third person
– change time of day presets
– place trees, rocks and other props
– save and reload your island later
It currently works best on desktop Chrome; performance and UX on mobile/Safari are still rough.
Technical write-up:
https://medium.com/@bartoszu/painting-with-light-building-a-...

value: Show HN: Zafiro – a painterly 3D island in the browser (Three.js)


value: Show HN: Spotify Wrapped but for LeetCode


value: claygood

value: Show HN: Pre-deployment validation tool for Google Cloud TPU environments

author: claygood


value: prathameshnium

value:
Hi HN, OP here.
I’m a physics researcher working on cryogenic transport measurements. I got frustrated with the rigidity of proprietary drivers and the cost of LabVIEW, so I spent the last 3 years building a Python suite to replace them.
It wraps SCPI commands for common instruments (Keithley 2400/6221, Lakeshore 350) and uses a multiprocessing architecture to ensure the GUI never freezes during long data acquisition loops—a common issue I faced with single-threaded scripts.
It’s currently powering real experiments at UGC-DAE CSR in Mumbai. I’m looking for feedbacks.
Repo: https://github.com/prathameshnium/PICA-Python-Instrument-Con...

value: Show HN: I built an open-source Python alternative to LabVIEW for my Physics PhD

author: prathameshnium


value: alDuncanson

value:
Hey HN, I'm building Handler!
My day job consists primarily of building and testing agentic systems, and I needed a tool that I could use to connect to, validate, and communicate with those systems.
The software is in beta right now, but I'd love any feedback from the community to gauge interest, usefulness, etc.

value: Show HN: Handler – A2A Protocol Client CLI and TUI

author: alDuncanson


value: Feedback is appreciated!

value: Show HN: A Next.js Recreation of the iPadOS Cursor

story_text: Feedback is appreciated!


value: polinux

value:
Fixed Link.
I built this to avoid constantly SSH-ing into servers for routine tasks.
It's a single Go binary with embedded React frontend. Run commands locally or on remote servers via SSH, manage keys and servers through a web UI, store scripts with execution presets.
Quick start:
```
docker run -d -p 7777:7777 polinux/web-cli
```
Stack: Go, React/MUI, SQLite. Everything encrypted at rest (AES-256-GCM). Multi-arch Docker image (amd64/arm64).

value: Show HN: Web CLI – Self-hosted web terminal for local and remote server

author: polinux


value: skeptrune

value:
I announced Sherp on X with a video covering my reasons for creating it here - https://x.com/skeptrune/status/1994678515825086556?s=20.
If you just want to read the slides, those are available too at https://sherp.skeptrune.com/.
I care about slide decks because they are an effective way to communicate ideas and often required for many public speaking formats like conferences or fundraising.
Many presentations induce death by PowerPoint[1] and I think writing them in plain markdown is an easy way to curtail that effect. I struggled with that a lot while building presentation decks when I first started raising capital with my startup and have been passionate about the problem ever since.
It is usually good to have a role model when pursuing excellence at something and mine for slide decks is a YouTube creator named Hambini[2]. He is a master of the format and I designed Sherp to be capable of making presentations that he would want to use.
You may be wondering why I didn't just use Slidev or Marp. If so, I will say to you that they are great tools, but I find Slidev to be far too complex because it requires managing your own package.json and Marp to be bloated with regards to its CLI and UX. Marp's directives for formatting and CSS selectors are particularly weird and hard to use.
Sherp is simple! One MDX file, one CSS file, one JS file, and you're off to the races. There are only 5 commands and I will not be adding more. I also think the default themes are nice and cover a good range of use-cases.
[1] https://www.slideshare.net/slideshow/death-by-powerpoint/855...
[2] https://www.youtube.com/hambini

value: Show HN: Sherp, a CLI for building presentations from Markdown/MDX

author: skeptrune


value: vibhanshugarg

value:
Hi HN,
I’ve been working on a small project called MemCloud — a distributed, in-memory data store written in Rust.
It lets multiple machines on a LAN pool their RAM and act like a shared, ephemeral storage cloud.
Why I built it
I often have multiple devices around me (Mac + Linux laptop + home server) that sit mostly idle.
I wanted these machines to behave like one big RAM cache for local development, ML experiments, and data processing — without installing heavy systems or configuring clusters.
So I built a lightweight daemon that:
auto-discovers peers via mDNS
exposes a simple local RPC API
pools memory across devices
supports raw block storage and a Redis-style key-value interface
works offline on macOS and Linux
has a CLI + Rust SDK + JS/TypeScript SDK
What it does
Store a block on any peer and load it from another in <10ms over LAN
Offload large streams (logs, datasets) without spiking local RAM
Build small distributed workflows without running Redis/Memcached clusters
Experiment with P2P memory systems in a simple way
Repo
https://github.com/vibhanshu2001/memcloud
Architecture (short version)
Each device runs a small Rust daemon ("memnode"):
mDNS → discovers peers
Peer Manager → handles connections
Block Manager → stores/loads blocks in local RAM
RPC API → CLI/SDK communication
Optional KV store → set(key, value) / get(key)
SDKs talk only to the local daemon, which routes requests to the correct peer.
Benchmarks (on M1 Mac)
SET: ~25k ops/sec (1KB payloads)
GET: ~16k ops/sec
(Not optimized — curious what others get on their machines.)
Looking for feedback on:
architecture & safety
networking design
memory model & eviction strategies
real-world use cases
potential pitfalls I might not be aware of
This is still early-stage/alpha and definitely not production-ready, but I’d love to hear your thoughts or suggestions.
Happy to answer questions!
https://memcloud.vercel.app/
— Vibhanshu

value: Show HN: MemCloud – Pool unused RAM across LAN devices (Rust, zero-config)

author: vibhanshugarg


value: Hello! I've created SmokeRand: a new cross-platform test suite for pseudorandom number generators written in C99 (MIT license). It combines ideas from TestU01, PractRand and gjrand, supports multi-threading, includes four predefined general purpose batteries, ~250 PRNG examples and several pre-defined heuristic scoring for tested PRNGs. Two interfaces for generators are supported: either stdin/stdout or plugins. An easy integration with TestU01 and PractRand is also supported.<p>It seems that sensitivity of SmokeRand full battery is comparable to TestU01, but it has a native support for both 32-bit and 64-bit generators. Also SmokeRand sometimes finds artefacts not detected by TestU01 and PractRand: e.g. in upper bits of 128-bit LCGs, additive lagged Fibonacci generators with huge lags, absence of 64-bit duplicates in SplitMix64 and DES-CTR output.

value: Show HN: SmokeRand: a new test suite for pseudorandom number generators


value:
I've recently been working on refactoring my static analysis tool from JavaScript to Go to improve performance.
Once I had module resolution implemented, I decided to add a new feature: circular dependency detection—a notoriously slow task in the projects I work on.
To my surprise, it turned out to outperform all available tools. It's 12 times faster than the fastest alternative!
I didn’t do anything particularly extraordinary, other than implementing everything from scratch, including the imports parser and module resolver.
Running circular check on project with 6034 source code files and 518862 lines of code takes below 400ms while other tools needs at least 5 seconds to execute.

value: Show HN: My super fast circular imports checker for TypeScript in Go


value: wowitsmrinal

value:
My partner (designer) and I (engineer) love walking. On long hikes and trips, we often found ourself walking just a little bit more than we needed to, just to beat our personal records. But its 1) hard to remember what that record was, and 2) those memories would just stay in the Apple Health screenshots.
So we made BestSteps, an app where one can see their top-10 step count days, add notes and photos, and share any of those days with their friends.
Then we took it out for a spin, and walked 50,000 steps in 12 hours to beat our personal record (fun video on the website)
We’ve put it on the App Store (my first app!) for everyone to try. Feedback, bugs, and suggestions are all welcome.
https://apps.apple.com/us/app/beststeps-walking-leaderboard/...

value: Show HN: We built an app to help you walk more

author: wowitsmrinal


value: Show HN: XeraSentry – Real-time Ethereum security monitoring in Python


value:
Hi HN,
I’ve been trading for 10+ years, mostly focusing on quantitative techniques like mean reversion and statistical arbitrage (pair trading). Over time, I’ve felt that many of the tools for these strategies are either too expensive, too slow, or simply not built with retail traders in mind.
So we decided to build QuantLens, a web-based tool that provides quantitative insights for the US stock market. Our goal is to make powerful quant tools accessible to everyone, not just institutions.
Key features:
Pair Trading: Find cointegrated stock pairs and analyze spread, z-score, divergence, and correlation.
Mean Reversion: Identify stocks deviating significantly from their historical mean.
Sector Analysis: Get a top-down view using sector-wide trends and relative performance.
Clean, fast UI: Designed to be lightweight and simple to explore.
This is still very much a work in progress, and we are actively building more features.
We would love to hear your feedback on:
The concept
The UI/UX
Features you think would be useful for serious traders
You can try it here: https://quantlens.app
Thanks for reading, happy to answer any questions!

value: Show HN: I built a quantitative analysis tool to retail traders


value: openfret

value:
I'm a solo dev and guitarist who got frustrated juggling separate apps for tracking gear, practicing, and collaborating.
What it does:
1) Smart inventory – Add your guitars, get auto-filled specs from ~1,000 models in the database. Track woods, pickups, tunings, string changes, photos.
2) AI practice sessions – Generate personalized tabs and lessons based on your practice history. Rendered with VexFlow notation.
3) Session Mode – Version-controlled music collaboration (think Git for audio). Fork tracks, add layers, see history, merge contributions.
4) Musical tools – Tuner, metronome, scale visualizer, chord progressions, fretboard maps. Last.fm integration for tracking what songs you're learning.
5) Guitar RPG – Fight monsters by playing real guitar notes. Web Audio API detects your playing. 300+ hand-crafted lessons from beginner to advanced.
What you can try without signing up:
1) The RPG demo is completely free, no account needed: https://openfret.com/game — just click "Start Battle" and play. It's capped at level 10 but gives you a real feel for the note detection.
The full platform (inventory, AI practice, sessions) requires Discord or magic link auth.
Current state: Beta. Core features work, actively adding content. The RPG has 300+ lessons done with more coming. Full game is $10 one-time, everything else is free.
Why I built it: I have a basement music setup and wanted one place to track when I last changed strings, get practice material that adapts to what I'm working on, and collaborate without DM'ing WAV/MP3 files.
Tech: Next.js (T3), Web Audio API for pitch detection, VexFlow for notation, Strudel integration for algorithmic backing tracks, Last.fm API.
Happy to answer questions about the AI tab generation, note detection, or the Git-style collaboration model.

value: Show HN: OpenFret – Guitar inventory, AI practice, and a note-detection RPG

author: openfret


value: fasthightimess

value: Show HN: Vibe Code WP Plugins

author: fasthightimess

title: Show HN: Vibe Code WP Plugins


value: asmyros

value: I've spent the last year working on a framework that treats financial risk as a conserved vector field rather than a scalar probability. The model (ART-2D) uses coupled Langevin dynamics to identify a phase transition threshold ($\Sigma \approx 0.75$).Backtesting shows it flagged the 2008 GFC 13 months early and the Terra/Luna collapse 5 days early. I'm looking for feedback on the entropy term derivation.

value: Show HN: Art-2D – A physics-based model for financial collapse prediction

author: asmyros


value: arlanrakh

value:
I cloned Naval (@naval), fully powered by the Nia API (trynia.ai).
The agent has access to all of his indexed archive of learnings and essays from his website. Simple RAG tools often surface paraphrased ideas instead of exact quotes from Naval’s original writing. I built this because I was tired of manually searching through every essay to find the precise passages and real context behind his thinking.
This agent can search, cite, and retrieve Naval’s actual words directly from the source. It is free and open source.
You can check the code here: https://github.com/nozomio-labs/naval-ai

value: Show HN: I turned Naval Ravikant into an AI agent

author: arlanrakh


value:
Hey HN! Sharing NanoBananaPro—AI tool that turns text prompts or images into commercial-ready videos in under 30 seconds, no skills needed.
Key perks:
Text-to-video + image-to-video workflows
Up to 4K, cinematic lighting, style transfers (artistic/oil painting looks)
Commercial license included (full rights, no attribution)
Powered by Veo 3, Runway Gen-3 & top AI models
200 free credits (no CC) + 7-day money-back guarantee
Great for e-commerce ads, social content, tutorials, or brand stories—dead simple: pick a style → describe → download.
Paid plans start at $6.99/month (50% off annual) with rolled-over unused credits.
Try it: https://nanobananapro.me/

value: Show HN: NanoBananaPro – Text/Images → Pro Videos in 30 Seconds (No Editing)


value: lucky-solanki

value:
I built The Dailicle as an antidote to doomscrolling. It delivers one curated essay every morning at 9 AM—no signup, no tracking, no bullshit.
The concept is simple: instead of infinite scrolling through low-quality content, you get one high-signal read synthesized from philosophy, psychology, startup wisdom, and research papers.
Features:
- One essay daily (no more, no less)
- Zero ads, no paywalls, no clickbait
- Inspired by Paul Graham's essays and Naval Ravikant's philosophy
- Sources include arXiv, HBR, Farnam Street, Wait But Why, and 100+ research papers
- Synthesized using OpenAI's deep research
- Works offline after first load
The problem it solves: attention is the scarcest resource. Most people spend 2+ hours daily consuming content that doesn't meaningfully upgrade their thinking. This gives you the signal without the noise.
Would love feedback from the HN community!

value: Show HN: The Dailicle – One transformative essay every morning at 9 AM

author: lucky-solanki


value: Show HN: LLM-Powered Log Analysis Wrapper (Python)


value: aalbatross

value:
Hey everyone
I’ve been on my FIRE journey for a while and got tired of juggling spreadsheets, brokers, and bank apps — so I built WealthYogi, a privacy-first net worth tracker focused on clarity and peace of mind.
 Why
Like many FIRE folks, I was juggling spreadsheets, bank apps, and broker dashboards — but never had one clear, connected view of my true net worth.
Most apps required logins or shared data with third parties — not ideal if you care about privacy.
So I built WealthYogi to be:
 Offline-first & private — all data stays 100% on your device
 Simple — focus purely on your wealth trajectory, not budgeting noise
 Multi-currency — 23 currencies, supporting GBP, USD, EUR, INR and more
 What it does now
* Tracks your net worth and portfolio value in real time
* Categorises assets (liquid, semi-liquid, illiquid) and liabilities (loans, mortgages, etc.)
* Multi-currency support (GBP, USD, EUR, INR and more)
* Privacy-first: all data stays 100% on your device
* 10+ Financial Health Indicators and Personalised Finance Health Score and Suggestions to improve
* Minimal, distraction-free design focused purely on your wealth trajectory
  Planned features (already in development)
 Real-time account sync
 Automatic FX updates
 Import/Export support
 More currency account types
 Debt tracking
 Net worth forecasting
  Pricing
Free Trial for 3 days. One time deal currently running till 10th December. Monthly and Yearly Subscriptions available.
Would love your feedback
1. Try the app and share honest feedback — what works, what feels clunky
2. Tell us what features you’d love to see next (especially FIRE-specific ideas!)
3. Share how you currently track your net worth — spreadsheet, app, or otherwise
Here’s the link again:
   WealthYogi on the App Store (https://apps.apple.com/us/app/wealthyogi/id6753881658)
 WealthYogi on the Android   (https://play.google.com/store/apps/details?id=com.dyogi.weal...)
 Demo (https://youtu.be/KUiPEQiLyLY)
I am building this for the FIRE and personal finance enthusiasts, and your feedback genuinely guides our roadmap.
— The WealthYogi Team
 hello@datayogi.io

value: Show HN : WealthYogi - Net worth Tracker

author: aalbatross


value: bluetomcat

value: A small tool that parses C declarations and outputs a simple visual representation at each stage, as it encounters arrays, pointers or functions.<p>The program uses a table-driven lexer and a hand-written, shift-reduce parser. No external dependencies apart from the standard library.

value: Show HN: Cdecl-dump - represent C declarations visually

author: bluetomcat