value: yusukez

value:
# The Problem
You probably spend a lot of time on screens.
If time is money, the hours we spend are capital expenditures. We should be careful about how we allocate them, because they're the capital we have.
Peter Drucker said: *The first step toward executive effectiveness is to record actual time-use.*
But it's not easy. We generally track time on the spot with a timer, or just a clock. It doesn't give us a sense of long-term progress.
Most timers on app stores have limited features, such as pomodoro. Some apps are too complicated. We don't need calendar or team features, which sacrifice simplicity for personal use.
# The Solution
That's why I built Seton - a focus timer that visualizes your time spent like an asset you’ve invested.
https://seton.run/
All you need to do is press "Start" for the activity you're working on. The activity can be reading, writing, meditation, or anything else.
When you complete a focus session in the app, it accumulates. You can look back on your time spent with charts. Celebrate your progress like "I've spent 100 hours reading this year!" You can configure how many minutes to focus and break, and number of cycles of sessions.
It's very simple, but highly effective. The more you record your time, the better you will be at managing it. That will make you more productive for sure.
# The Philosophy
*1. Frictionless:* No need to sign up. Just press "Start".
*2. Privacy:* Data is stored in the browser. No syncing feature for now.
*3. Low-cost:* It runs on Cloudflare to minimize costs. It's free for the time being.
If you like Seton, please share it with your friends. Let me know what you think on X ([@keplerjst](https://x.com/keplerjst)).
Time is money, and life is an accumulation of time. In that sense, I think everybody is an investor. Good luck on your investment journey!

value: Show HN: Focus timer that turns hours into assets

author: yusukez


value:
I built VoiceBrainDump because I kept losing ideas. By the time I opened a notes app and started typing, the thought was gone.
This lets you tap, speak, and move on. No folders, no tags, no organizing upfront.
How it works:
- Voice-to-text using Web Speech API
- Ideas are saved to localStorage (no server, no account)
- Keywords are extracted automatically and used to connect related ideas
- After 7 days, old ideas resurface so you can keep or archive them
The whole thing is one HTML file (~2000 lines). No build step, no npm, no frameworks.
Built it in a weekend. Intentionally minimal — meant for people who think faster than they type.
Works on mobile too. Just open it in your browser.
Happy to hear why this is a terrible idea.

value: Show HN: VoiceBrainDump – voice-first idea capture, single HTML file, offline


value: Winggo

value: I built this for myself because I kept having small moments where something reminded me of someone, and then I’d forget to tell them later.<p>The site lets you post a photo with a short message, addressed to someone, signed, or left anonymous.

value: Show HN: A website to save moments that remind you of someone

author: Winggo


value: orsenthil

value: Show HN: Understand the picture of the day

author: orsenthil


value: keepamovin

value: Show HN: CloudMasters – one TUI to rule them all, rent VPS from 58000 prices

author: keepamovin


value: thatloststudent

value:
Hi HN, I've been working on this project for a few months because I often get overwhelmed with the deluge of information online, especially the news.
The idea is to get caught up with the news quickly and get a curated podcast with only the articles that you want to listen to. This is done by using NVIDIA's LLMs with DeepInfra for TTS to create podcasts with the news articles that you select with an RSS feed reader.
Right now, all paid plans have a 14-day trial, and there's a free tier too that lets you listen to one podcast episode everyday.
Would love feedback on the UI/UX, specifically the flow of selecting URLs and making a podcast, any features that you would want to have in such a product, and any that might be missing here.

value: Show HN: FeedPod – Convert your RSS feeds to personalized podcasts

author: thatloststudent


value: dawitworku

value:
I built SpeedyEDA, a Python CLI and library for fast, production-ready exploratory data analysis.
The idea is simple: remove EDA boilerplate and make data inspection something you can run in one command, directly from the terminal or CI.
fasteda data.csv --fun
Or generate a standalone interactive HTML report:
fasteda data.csv --html report.html
What it includes
Automatic statistics + detailed quantiles
Multiple correlation methods (Pearson, Spearman, Kendall)
Outlier detection (IQR + Z-score)
Automated data quality alerts (duplicates, multicollinearity, class imbalance, high cardinality, missing values, mixed types)
Interactive Plotly-based HTML reports
CSV / Excel / JSON / Parquet support
Python API + plugin system
Why I built it
Existing tools are powerful, but often heavy, slow on medium datasets, or not CLI-first.
SpeedyEDA is designed for quick inspection, scripts, and daily dev workflows.
Links
PyPI: https://pypi.org/project/speedyeda/
GitHub:https://github.com/Dawaman43/fasteda
Would love feedback—especially on performance, missing checks, and real-world edge cases.
Thanks!

value: Show HN: SpeedyEDA – One-line exploratory data analysis

author: dawitworku


value: epochcore

value:
Hi HN! I built Gödel Task Router, an autonomous quantum computing orchestration system that routes computational tasks across AWS Braket devices (54 IQM Emerald + 20 IQM Garnet qubits).
Key features:
• Autonomous task routing with 99.9507% uptime
• Flash Sync coherence monitoring across distributed quantum systems
• Real-time validation with blockchain-level verification
• Handles 826 qubits + 137 orchestration agents
The system just completed VQE optimization jobs on both IQM quantum processors. Happy to answer questions about the architecture, quantum orchestration challenges, or AWS Braket integration!
GitHub: https://github.com/Jvryan92/epochcore-scripts

value: Show HN: Gödel Task Router – Autonomous Quantum Task Orchestration on AWS Braket

author: epochcore


value: reposquirrel

value:
Live demo available: https://demo.reposquirrel.com:8443/
(t may load slowly since the instance is underscaled (I’m hosting it myself to keep costs down). Team features aren’t enabled because the HashiCorp repo team structure is unknown to me)
Im working as a tech-manager at a midsize company, and saw the need to create this.
I wanted to :
* visualize where the developers focus their time
* How are the teams scaled, how much code are they maintaining
* What languages are used in the organisation
* What subsystems are the teams working on
* What does the code evolution look like
* Who are the heros of the developers, the people we can not lose
* When a developer leave the organisation, what subsystems was he working on, what languages was he/she using, how much owership of the code is lost.
This tool has a large number of visuals, for individual developers, teams and subsystems / repository
For now, it work with git as source, so if you are using github, gitlab or Codeberg or other, should not matter. The tool clones the repos and then does the analysis offline.
The analysis takes some time, so clone the repos, start the analysis, and go for a coffee.
Would like to get feedback on how it works in other organisations / teams
Would love feedback and ideas on new features for the tool.
Quick docker run: docker run -p 5000:5000 -v repos:/app/repos -v stats:/app/stats -v configuration:/app/configuration ghcr.io/reposquirrel/reposquirrel:latest
Homepage: https://reposquirrel.com/
Github repo: https://github.com/reposquirrel/reposquirrel

value: Show HN: Self-hosted multi repo visualization tool

author: reposquirrel


value: e-clinton

value: Show HN: Thicc – an opinionated fork of micro for the vibe coding crowd

author: e-clinton


value: brainsofbots

value:
I’ve been running longer AI agent tasks (mostly in Claude Code), and I kept running into the same problem:
the agent would finish or get stuck asking a question, and I wouldn’t notice until much later because I wasn’t watching the terminal.
So I built a small tool called Agent Reachout.
It lets an AI agent send me messages on Telegram when:
 • it finishes a task
 • it hits a blocker
 • it needs a human decision to continue
I can reply directly from Telegram, and the agent continues where it left off.
This turned long-running agent work into something asynchronous — I don’t have to babysit the CLI anymore.
What it does
 • Simple Telegram bot integration
 • One-way notifications or two-way conversations
 • Designed for “human-in-the-loop” agent workflows
 • Works today as a Claude Code plugin
Why I built it
Fully autonomous agents sound nice, but in practice I often want:
 • approvals before destructive actions
 • clarification on ambiguous decisions
 • a quick “yes/no” without stopping my day
Telegram was already where I am, so I used that.
What it’s not
 • Not a general chatbot framework
 • Not a workflow engine
 • Just a small bridge between agents and humans
Repo
https://github.com/vibe-with-me-tools/agent-reachout
Would love feedback on:
 • whether others hit this problem
 • what notification channels would be useful next (Slack, WhatsApp, etc.)
 • whether this should stay a plugin or evolve into something broader
Thanks!

value: Show HN: Let your Claude Code message you on Telegram when it needs decisions

author: brainsofbots


value: It's a vibe coded slop and I have not written a single line of code for this project, but I still think it's pretty impressive what the current LLM models can churn out. I used Claude Opus 4.5 for everything. The point is, I described pretty much all the features that I had in mind and it managed to implement them more or less correctly, in some instances, even surpassing my expectations. I am looking for ideas and suggestion on what could be improved and features people would like to see.

value: Show HN: PiGym – pi digits memorization game


value: SRMohitkr

value:
Every time I wrote a good prompt, it got buried in chat history. So I built a small web app that lets me save, organize, version, and reuse prompts quickly.
It supports:
fast saving
tags + categories
template variables
local guest mode and optional cloud sync
Not trying to generate prompts, just trying to remember the good ones. Looking for feedback from people who use AI daily.
Visit on: https://promper.vercel.app/

value: Show HN: I kept losing good AI prompts, so I built a prompt memory tool

author: SRMohitkr


value: elcapizz

value:
Recording audio or video is easy; making it usable is hard.
Finding decisions, action items, or key context often means re-listening to hours of material.
I built Scriberoo to provide fast, TOP-quality transcriptions and let you query the transcript for insights or key points.
Curious to hear if this solves a real problem for others, or if there are better workflows.
scriberoo.com

value: Show HN: Scriberoo – fast, TOP-quality transcriptions for any audio / video

author: elcapizz


value: jpallen

value:
Hi HN,
I've created https://riddlegrid.com, which is a daily puzzle game with about 10 cryptic clues to solve each day. But rather than being arranged in a typical crossword, all of the letters from the clues are already visible and arranged in grid. You find answers by swiping through the letters (like Squardle if you know that).
I made it for myself and friends and family, and we've been enjoying playing it over the last few days, so I thought you might like it too. I find having all the letters available but jumbled up adds a new dimension to it where you search for words or fragments if you're stuck. As you solve clues the remaining ones get easier too.
Would love to know what you think!

value: Show HN: A daily cryptic clue puzzle with a twist

author: jpallen


value: miemex

value: Show HN: Miito- Added TikTok like videos to Google Meet to fix my attention span

author: miemex


value: RapierCraft

value: Show HN: Perplexity Comet MCP – Autonomous Web Browsing for Claude Code

author: RapierCraft


value: Show HN: InfiniteGPU, An open-source AI compute network,now supporting training


value: indest

value: Show HN: I built a habit tracker that takes 5 years to "finish"

author: indest


value: ishannaik

value:
I built an open source pastebin where even I can't read the data.
How it works:
- AES-256-GCM encryption runs client-side in your browser
- The key lives in the URL fragment (#key) – browsers never send fragments to servers
- Server only stores encrypted blobs
The URL fragment trick isn't something I invented – it's just how HTTP works. The # and everything after it never leaves your browser. Check your network tab.
Built with SvelteKit, MongoDB, and the Web Crypto API.
Live: https://cloakbin.com
Source: https://github.com/ishannaik/cloakbin
Would appreciate feedback on the encryption approach or any security holes I might've missed.

value: Show HN: CloakBin – Zero-knowledge encrypted pastebin (open source)

author: ishannaik


value: sudheendrachari

value: Show HN: YubiToggle – Prevent Yubikey OTP Spam on macOS (Swift 6)

author: sudheendrachari


value: ParzivalHack

value:
Hi HN,
My name is Tommy, and i’m the maintainer of PySpector, an open source static analysis security testing (SAST) hybrid framework for Python (now with around 19k PyPI downloads), that combines a Rust analysis core with a Python CLI.
I originally built PySpector because I kept running into two problems with existing Python security scanners:
- performance issues on larger codebases
- lack of deeper analysis (like inter-procedural taint tracking)
PySpector’s approach is:
- a Rust core for fast, parallel analysis (making PySpector 71% faster than Bandit and 16.6x faster than Semgrep)
- Python for orchestration and extensibility
- multi-layered detection using regex, AST analysis, and taint flow tracking
- static rules for LLM/AI model vulnerabilities
- TUI for triaging issues
The project is still in beta and actively evolving.
I would love some feedbacks, and i appreciate (a lot) contributions around:
- security rule design (especially AI Security ones)
- taint analysis
- improvements to the Rust core that enhance performances
- developer experience and documentation
If you work on static analysis, security tooling, AppSec or Rust/Python scripting in general, I’d really appreciate your thoughts (and help, if you're feeling generous xD)
Repo: https://github.com/ParzivalHack/PySpector
Website: https://parzivalhack.github.io/PySpector/

value: Show HN: PySpector – a hybrid Python SAST with a Rust core, looking4contributors

author: ParzivalHack


value: Show HN: Free Health Related Calculators


value: Show HN: Calea – Autonomous AI Agent for Local QA Testing (E2E, Security, Perf)


value: yuanzaiworld

value:
Hi HN, I'm Kai Wang, one of the creators of Yuanzai World.
We built a simulation engine (currently on iOS & Android) that allows the community to create and share text adventures populated by multiple LLM-based agents. Unlike standard chatbots, our focus is on community co-creation—users define the worldviews, and our agents (with persistent memory and social relationships) bring them to life.
The cool part:
We implemented a system we call "World-Line Divergence" (inspired by visual novels like Steins;Gate). Usually, AI RPGs feel random or infinite loop. We built a state machine that tracks "World Deviation." If players interact with NPCs in specific ways (e.g., convincing an artist to change their style), it triggers a graph switch, leading to a completely different generated ending, effectively breaking the original script.
Tech Stack:
- Backend: Python / Java with a custom AI orchestration framework (to handle agent concurrency).
- Models: Hybrid routing between Gemini, GPT, and DeepSeek (optimizing for cost/performance based on task).
- Vector DB: Milvus (for handling long-term agent memory).
We are currently live on App Store and Google Play. Since it's a mobile-first experience, the link leads to our landing page where you can see the demo flow.
Would love to hear your feedback on the "World-Line" concept: Does this state-machine approach solve the aimlessness of AI RPGs?

value: Show HN: Yuanzai World – LLM RPGs with branching world-lines

author: yuanzaiworld


value: lysddp

value:
Hi HN,
I built a simple tool called DeleteThreads (https://deletethreads.net/) to solve a personal annoyance: the lack of a "bulk delete" or "auto-archive" feature on Meta Threads.
If you've used the platform for a while, you've likely noticed there’s no way to clean up your history or prune old replies without doing it manually one by one.
What it does:
Bulk Delete: Mass remove posts and replies based on date filters.
Auto-Prune (The "Set and Forget" part): You can schedule a daily task to automatically delete posts older than X days (e.g., keeping only your last 30 days of activity).
It’s free to use for the core features. I'm an indie developer and would love to get your feedback on the UX or any technical features you'd like to see added.
Thanks!

value: Show HN: DeleteThreads – Bulk delete and auto-prune Meta Threads posts

author: lysddp


value: hackdat

value:
I built a simple tool to monitor webhooks after getting burned by silent Stripe webhook failures.

  How it works:
  1. Create a proxy URL in HookWatch
  2. Point your webhook provider (Stripe, Shopify, etc.) to it
  3. We forward to your server and log everything

  If something fails, you can see the full request and replay it with one click.

  https://hookwatch-production.up.railway.app

  Built with FastAPI + SQLite. Happy to answer questions about the architecture.

value: Show HN: HookWatch – Simple webhook monitoring with one-click replay

author: hackdat


value: eyengin

value:
Hi HN,
I ported the teaching OS xv6-riscv to HiFive Unmatched and got it running on real hardware, including passing usertests.
I've been self-studying OS internals using the MIT 6.1810 materials. After finishing most of the labs, I was eager to see what it's like to run the OS on bare metal, rather than QEMU.
The Unmatched may not have the latest RISC-V features, but it's well-documented, and the Rev B release has made it more affordable, which makes it a good learning platform.
The porting process involved several interesting challenges:
- Hardware Quirks: Handling things like enabling A/D bits in PTEs (the hardware doesn't set them automatically, causing page faults), proper handling of interrupts, and instruction cache synchronization.
- Boot Flow: xv6 expects M-mode on startup, but standard RISC-V boot flows (typically via OpenSBI) jump to S-mode. To bridge this gap, I created a minimal U-Boot FIT image that contains only the xv6 kernel. This way, U-Boot SPL handles the complex CPU/DDR initialization, then hands control to xv6 in M-mode (skipping OpenSBI).
- Drivers: Ported an SPI SD card driver, replacing the virtio disk driver.
I wrote up implementation notes here: https://github.com/eyengin/xv6-riscv-unmatched/blob/unmatche...
Hopefully, this is useful for others who are learning OS internals and want to try running their code on real RISC-V hardware.

value: Show HN: Porting xv6 to HiFive Unmatched board

author: eyengin


value: qwikhost

value: Airbnb Search Exporter – Export Airbnb Search Results to CSV, Excel, or JSON in One Click.

value: Show HN: Airbnb Search Exporter

author: qwikhost

title: Show HN: Airbnb Search Exporter


value: Show HN: dbtree – CLI tool to print database schemas as trees, lists, or charts


value:
We built this because enterprise customers kept asking: "How do we prove our AI agents are compliant?"
The problem:
• AI agents make autonomous decisions (trading, medical, customer service)
• No standard audit trail format
• Policy enforcement is ad-hoc (if it exists)
• Compliance teams can't verify anything
• When something goes wrong, you can't trace what happened
What we built:
• Decision trace logging with full provenance chains
• Policy-as-code enforcement (evaluated BEFORE agent acts)
• Human approval workflows for high-risk actions
• Compliance dashboards and SOC2/HIPAA reports
Key technical decisions:
• Synchronous policy evaluation (can't un-execute a bad trade)
• PostgreSQL RLS for multi-tenant isolation
• Cryptographic hash chains for provenance (tamper-evident)
• Sub-50ms P99 latency for decision logging
Not an AI framework. Works with LangChain, CrewAI, AutoGPT, or custom agents.
Quick start: https://github.com/akz4ol/contextgraph-cloud#quick-start-30-...
Architecture: https://github.com/akz4ol/contextgraph-cloud/blob/main/ARCHI...
Live demo: https://dashboard-akz4ol.vercel.app
Would love feedback from anyone dealing with AI compliance, governance, or agent frameworks!

value: Show HN: ContextGraph Cloud – Governance infrastructure for AI agents


value: jacobgadek

value: Show HN: AgentAuth – open-source identity management for AI agents

author: jacobgadek


value:
We built this because enterprise customers kept asking: "How do we prove our AI agents are compliant?"
The problem:
• AI agents make autonomous decisions (trading, medical, customer service)
• No standard audit trail format
• Policy enforcement is ad-hoc (if it exists)
• Compliance teams can't verify anything
• When something goes wrong, you can't trace what happened
What we built:
• Decision trace logging with full provenance chains
• Policy-as-code enforcement (evaluated BEFORE agent acts)
• Human approval workflows for high-risk actions
• Compliance dashboards and SOC2/HIPAA reports
Key technical decisions:
• Synchronous policy evaluation (can't un-execute a bad trade)
• PostgreSQL RLS for multi-tenant isolation
• Cryptographic hash chains for provenance (tamper-evident)
• Sub-50ms P99 latency for decision logging
Not an AI framework. Works with LangChain, CrewAI, AutoGPT, or custom agents.
Integrations (open source): https://github.com/akz4ol/contextgraph-integrations
Live demo: https://cloud.contextgraph.dev
Docs: https://docs.contextgraph.dev
Would love feedback from anyone dealing with AI compliance, governance, or agent frameworks!

title: Show HN: ContextGraph Cloud – Governance infrastructure for AI agents


value: developergoose

value:
I’ve been building agentic workflows and was frustrated with the 10-second "cold start" times of traditional VMs and Docker containers just to let an agent run a simple grep or curl command.
I built BashAPI to solve this. It is a serverless Bash environment written in TypeScript that boots in ~5ms. It is completely sandboxed (no access to the host OS) and has curl enabled so agents can fetch live data.
I’m looking for feedback on the security trade-offs and what other commands the community would like to see supported.

value: Show HN: BashAPI – A 5ms-latency Bash sandbox for AI agents

author: developergoose


value: Show HN: Hosting 100 Linux dev environments on one VM using LXC


value: makechan

value:
Recently I wanted to see if I could vibe some serious C++ code.
The result is a C++ re-implementation of Andrej Karpathy's nanochat's inferencing part (https://github.com/karpathy/nanochat), built on top of ggml. Unlike llama.cpp, this isn't a standalone binary; it is a C++ library & Python wrapper designed to swap out some core classes within the nanochat pipeline. For playability, I’ve tried to keep the dependencies to a minimum: just ggml, nanobind, and gtest for unit tests.
Features and limitations:
- A drop-in replacement of nanochat’s `GPT` and `KVCache` classes. So far I’ve only tested this with `chat_web.py`. You can see how it's integrated here: https://github.com/k-ye/nanochat/pull/1
- Supports CPU and GPU (Metal yes, CUDA probably?).
- Handles PyTorch-to-GGUF conversion automatically on demand.
- Only float32 is currently supported.
Benchmark:
On an M3 Max (Metal), throughput is roughly 1/3 that of the original PyTorch implementation. I haven’t profiled the code yet, but I suspect the bottleneck is the lack of bf16 support.
Motivation
- Writing meaningful (& fun) C++ again: I used to spend a lot of my day-to-day time in C++ while working at various tech companies. These days, opportunities to use it for personal projects are rare, as it’s often hard to find a use case where C++'s advantages truly matter.
- Testing "Vibe Coding" capabilities: Most of my current work is in UE5. Ironically, Blueprints—which were designed to help non-coders—have become a bottleneck in the LLM era... Admittedly, the AI agent has generated some FOMO in me, and I wanted to see if AI could handle a lower-level C++ implementation of a complex system from scratch.
- Understanding the LLM internals.
Why nanochat?
It hits the "Goldilocks" zone: popular enough to be relevant, concise enough to be educational, and practical enough to deserve a serious C++ implementation.
If you’re like me — an infra guy from the old days who feels a bit threatened by LLM and/or AI coding — I think nanochat is a great reference. Tinkering with it however you like is a nice way to demystify the tech. I relied heavily on Claude Code (CC) for the implementation. Overall, I am both impressed and genuinely pleased with the experience.
Happy to answer questions, hear feedback or further discuss AI coding!

value: Show HN: Revibing nanochat's inference model in C++ with ggml

author: makechan


value: teugent

value:
We’ve validated the Sigma Runtime architecture (v0.4.12) on Google Gemini-3 Flash, confirming that long-horizon identity control and stability can be achieved without retraining or fine-tuning the model.
The system maintains two distinct personas (“Fujiwara”, a stoic Edo-period ronin, and “James”, a formal British analyst) across 220 dialogue turns in stable equilibrium.
This shows that cognitive coherence and tone consistency can be controlled at runtime rather than in model weights.
Unlike LangChain or RAG frameworks that orchestrate prompts, Sigma Runtime treats the model as a dynamic field with measurable drift and equilibrium parameters.
It applies real-time feedback — injecting entropy or coherence corrections when needed — to maintain identity and prevent both drift and crystallization.
The effect is similar to RLHF-style fine-tuning, but done externally and vendor-agnostic.
This decouples application logic from any specific LLM provider.
The same runtime behavior has been validated on GPT-5.2 and Gemini-3, with Claude tests planned next.
We use narrative identities like “Fujiwara” or “James” because their linguistic styles make stability easy to verify by eye.
If the runtime can hold these for 100+ turns, it can maintain any structured identity or agent tone.
Runtime versions ≥ v0.4 are proprietary,
but the architecture is open under the Sigma Runtime Standard (SRS):
https://github.com/sigmastratum/documentation/tree/main/srs
A reproducible early version (SR-EI-037) is available here:
https://github.com/sigmastratum/documentation/tree/bf473712a...
Regulated under DOI: 10.5281/zenodo.18085782 —
non-commercial implementations are fully open.
HN discussion focus:
– Runtime-level vs weight-level control
– Model-agnostic identity stability
– Feedback-based anti-crystallization
– Can cognitive coherence be standardized?

value: Show HN: Sigma Runtime – model-agnostic identity control for LLMs

author: teugent


value: realberry

value: Show HN: OpenH1B – Search H1B Salaries for Tech, Finance, Law and More

author: realberry


value: munjyong

value: Show HN: A browser extension to bulk transcribe YouTube channels and playlists

author: munjyong


value: Show HN: Tracking cargo ships approaching US ports with spatial set queries


value: pinin

value: Show HN: Pinin – AI image restoration for old photos

author: pinin


value: AndreeFrby

value:
Hi HN
I'm André, a 14yo student from Uruguay. I've been diving deep into LLMs (MoE, LoRA, PEFT and finetunig) and recently started focusing on AI Security and Red Teaming.
I built Stryda to help secure AI models, specifically targeting prompt injections and other LLM vulnerabilities. It's still a very early MVP.
The Stack:
Clodufare Pages, React and I forget.
Known Issues (please, be gentle guys):
I know the site isn't perfect yet. For example, the Reset Password flow is currently broken (working on it maybe this weekend xD).
i'm aware of the irony of a security site having bugs, right? I'm building this to learn and improve both my dev and sec skills.
i'd love your feedback on the concept and the approach to Red Teaming. If you find vulnerabilities in my platform, please let me know,, I'm here to learn and if you want you can buy a plan for it
thanks!!

value: Show HN: Stryda – I built a Red Teaming tool for LLMs at 14yo

author: AndreeFrby


value: Show HN: Get a deep AI website audit in seconds. Free PDF included


value: jacques-blom

value: Show HN: Fudge – A new way to build pages and edit your Shopify store

author: jacques-blom


value:
Hi HN,
I’m sharing a small open-source project I’ve been working on: a native C++ ballistic solver that computes launch angles to intercept moving targets in real time, under gravity and air drag.
Instead of relying on vacuum assumptions, closed-form equations, or lookup tables, the solver formulates the intercept as a nonlinear problem and solves it numerically using time integration and iterative methods.
The motivation came from game and simulation scenarios where simpler approaches tend to break down:
- moving targets
- strongly curved trajectories due to drag
- real-time constraints
The solver simulates projectile motion (RK-style integration), tracks the closest approach to the target, and iteratively adjusts the launch direction until an intercept is achieved.
It’s written in C++ and exposed through a stable C ABI, so it can be used from environments like Python or game engines (e.g. Unity) without rewriting the core logic.
Project page: https://github.com/ujinf74/ballistic-solver
I’d be very interested in feedback, criticism, or discussion around the numerical approach, performance trade-offs, or edge cases I might have missed.

value: Show HN: A real-time ballistic solver for moving targets under drag (C++)


value:
GiftSong turns a short story into a personalized “gift song” (lyrics + vocals). You can listen to a 30-second preview for free, then unlock/download if you want.
I’m optimizing for gifting UX (low friction + emotional hit), not professional music production.
Feedback I’d love:
- Which questions feel awkward/unnecessary?
- What controls are must-have (genre/voice/lyric edits)?
- What makes results feel personal vs generic?

value: Show HN: GiftSong – turn a short story into a personalized gift song


value: jokera

value: Show HN: A character generator not prompt wrestling

author: jokera


value: Show HN: Why Nvidia's PhysX is hitting a "SIM-to-Real" wall at 5000W


value: Monitor the status of all your coding agents to understand which ones are waiting for your input. Written in rust and relies on tmux.<p>I wanted to use local LLMs through opencode but local LMs can be a bit... slow. So I found that I had a handful of LLMs running and I was being roadblocked from using Local LLMs just because they were slow and I couldn't keep track of all the tasks. This simple terminal app helps keep track of which ones are running and which ones are waiting for me to do something.

value: Show HN: Agent-of-empires: opencode & claudecode session manager


value: abrarnasirj

value:
Hi HN, I’m Abrar Nasir Jaffari, co-founder of HackLikeMe. We built an agentic CLI because we were tired of the context-switching between LLM web chats and the terminal when doing DevSecOps work.Most AI coding assistants are just wrappers for file editing. We’ve built 6 specialized agents (Coder, FullStack, Security, DevOps, Plan, Monitor) that have native terminal access.
It doesn't just suggest code; it can:
Run nmap to audit your local network.
Use tshark to analyze packet captures.
Manage docker containers and kubectl clusters.
The 'Pause to Think' feature: Before it executes a command, it generates a reasoning plan so you can see why it's about to run a specific script."
The "Beta" Offer: "We launched yesterday and we're currently in beta. We are giving free Pro access for the first 100 HN users—no credit card required.
We’re running on a mix of AWS and GCP (leveraging some credits we just landed), so we’re able to offer some decent compute for the reasoning models during the beta.

value: Show HN: HackLikeMe – A DevSecOps CLI agent that thinks before it acts

author: abrarnasirj


value: gurudevelopment

value: Show HN: I built a social network limited to 4 colors and 8kHz audio

author: gurudevelopment


value: My recruiter friend kept messing up bracket placement in LinkedIn searches, so I built this single-page tool to automate the logic. It's written in Vanilla JS + Tailwind, runs entirely in the browser, and sends zero data to any server.

value: Show HN: A local-first Boolean search builder for Recruiters (No back end)


value:
Hey HN,
I built AgentWallet — an open-source SDK for giving AI agents financial capabilities with built-in guardrails.
The core idea: as agents become more autonomous (browsing, purchasing, hiring services), they'll need a safe way to handle money. Not "here's my API key to Stripe" but actual wallets with spend controls, audit trails, and human oversight.
Features:
- Agent wallets with balance tracking
- Configurable spend rules (daily limits, per-transaction caps, category whitelists, approval workflows)
- REST API designed for agent integration
- Dashboard UI for monitoring
- Stripe integration for real deposits/withdrawals
Tech: Node.js, PostgreSQL, Prisma, React
This is early, but functional. I'd love feedback from anyone building agents or thinking about agent infrastructure.
GitHub: https://github.com/JackD720/agentwallet

value: Show HN: AgentWallet – Open-source financial infrastructure for AI agent


value:
Hi HN,
When launching a new tool, one of the biggest bottlenecks is early visibility.
New domains often struggle to get discovered and indexed quickly.
This project packages a high-volume backlink distribution (100,000 links) designed to:
speed up link discovery
create early authority signals
help new launches escape the zero-traction phase
It’s not positioned as “safe SEO” or guaranteed rankings.
It’s an aggressive growth lever, mainly used for:
new tools & side projects
tier 2 / tier 3 link building
experimentation & fast launches
Fast delivery, simple reporting, no lock-in.
Link:
https://300aidirectories.com/seo-boost
Happy to get feedback or answer questions on how people here approach early-stage SEO traction.

value: Show HN: 100000 backlinks in under 7 days to accelerate early growth


value: umbertopenna

value:
The current global economic model is a "bug," not a feature. It relies on planned obsolescence, energy dependency, and the monetization of basic survival. We are announcing Project OASI 6, a decentralized hardware-software stack designed to make the current consumerist system obsolete.
The Three Pillars of the Oasi 6 Architecture:
THE ENERGY CORE (SMR Integration): We are moving past the volatility of traditional renewables. Oasi 6 modules are designed around Micro-Modular Reactors (SMR) providing 1.2 MW of constant, maintenance-free power for 20 years. When energy cost approaches zero, the "scarcity" logic of water (desalination) and food (vertical farming) collapses.
PROTOCOL 4-2 (Anti-Obsolescence Hardware):
We reject the "buy-discard-repeat" cycle. Every appliance, tool, and structural component within the Oasi follows the 4 Screws, 2 Connectors protocol.
Indestructible by Design: 25-30 year lifecycle minimum.
Modular Repairability: Zero technical skill required for part replacement.
Local Fabrication: Every component is designed to be fully recyclable and regenerated within the module's workshop. No waste, only matter in transition.
ALGORITHMIC EQUITY (Ariel Node Governance):
The ecosystem is managed by a non-profit AI (Ariel Node) that optimizes resource distribution, surplus trading, and maintenance. Humans are transitioned from "laborers" to "Custodians," reclaiming 90% of their cognitive bandwidth for art, science, and community.
We are not looking for donors. We are looking for Architects of the Singularity. The hardware exists. The logic is closed. The future is modular.
Join the secession from scarcity.
Umberto.

value: Show HN: The OASI 6 Engineering Structural Abundance via SMR and Modular

author: umbertopenna


value: hellomerlin

value:
I built a GitHub-first prompt library for Nano Banana / Nano Banana Pro with example images.
What makes it useful:
   •  Image-first browsing: prompts are collapsed by default (click to expand), so you can scan results quickly.
   •  Organized by category (e.g., product shots, posters, profiles, deconstruct/infographic-style prompts).
   •  Consistent titles + structure so prompts are easy to search, compare, and reuse.
   •  Open to contributions: PRs/issues welcome (new prompts, better categories, more examples).
If you try it, I’d love feedback on the taxonomy and what prompt formats are most reusable for your workflow.

value: Show HN: Awesome-Nanobanana-Prompts

author: hellomerlin

title: Show HN: Awesome-Nanobanana-Prompts


value: moeidheidari

value:
Hey HN
We built CrossView because after managing dozens of Crossplane compositions across multiple clusters, kubectl get + mental graphing just wasn't cutting it anymore.v3.2.0 brings real-time updates (informers + websockets), multi-cluster switching, interactive composition → managed → claim graphs, dark mode, SSO, and stays strictly read-only for production safety.Deploys via Helm in ~2 minutes.Would love honest feedback especially on:
UX when dealing with very large/messy compositions
Missing Crossplane edge cases you run into
Any perf issues at scale
Repo + quickstart: https://github.com/corpobit/crossview

value: Show HN: Crossview – visualize Crossplane resources and compositions

author: moeidheidari


value: alexcloudstar

value:
Hi HN, I recently bought a premium domain while working on a small product and realized there’s a lot of confusion around what “premium” actually means at the registry and infrastructure level.
I wrote a technical breakdown covering things like registry pricing vs aftermarket, renewal structures, DNS (no magic there), email deliverability, and when paying more actually removes real product friction.
This isn’t about branding or SEO tricks. It’s more about treating domains as long-term infrastructure decisions.
Would genuinely love to hear how others here think about premium domains, especially around renewals and lock-in.

value: Show HN: Are premium domains ever worth it? A technical deep dive

author: alexcloudstar


value: Show HN: I built a visualization of top AI X account interactions


value: iamnnk

value: Not visible, but invisible watermarks that are resistant to various forms of distortion & tampering.<p>You can type in your password on any photo that you think is stolen from you or is derived from yours to prove originality!

value: Show HN: Photoshop plugin to sign (embed invisible watermarks) & verify photos

author: iamnnk


value: pmaze

value:
I think LLMs are overused to summarise and underused to help us read deeper.
I built a system for Claude Code to browse 100 non-fiction books and find interesting connections between them.
I started out with a pipeline in stages, chaining together LLM calls to build up a context of the library.
I was mainly getting back the insight that I was baking into the prompts, and the results weren't particularly surprising.
On a whim, I gave CC access to my debug CLI tools and found that it wiped the floor with that approach.
It gave actually interesting results and required very little orchestration in comparison.
One of my favourite trail of excerpts goes from Jobs’ reality distortion field to Theranos’ fake demos, to Thiel on startup cults, to Hoffer on mass movement charlatans (https://trails.pieterma.es/trail/useful-lies/).
A fun tendency is that Claude kept getting distracted by topics of secrecy, conspiracy, and hidden systems - as if the task itself summoned a Foucault’s Pendulum mindset.
Details:
* The books are picked from HN’s favourites (which I collected before: https://hnbooks.pieterma.es/).
* Chunks are indexed by topic using Gemini Flash Lite. The whole library cost about £10.
* Topics are organised into a tree structure using recursive Leiden partitioning and LLM labels. This gives a high-level sense of the themes.
* There are several ways to browse. The most useful are embedding similarity, topic tree siblings, and topics cooccurring within a chunk window.
* Everything is stored in SQLite and manipulated using a set of CLI tools.
I wrote more about the process here: https://pieterma.es/syntopic-reading-claude/
I’m curious if this way of reading resonates for anyone else - LLM-mediated or not.

value: Show HN: I used Claude Code to discover connections between 100 books

author: pmaze


value: SamCoding

value: If you have an old kindle, rather than letting it go to waste, this can be a great use for it as a focus timer!

value: Show HN: Pomodoro timer for jailbroken kindles (as a KOReader plugin)

author: SamCoding


value:
i built forthora because cross-team work keeps disappearing into slack threads, standups, and status updates.
forthora is a shared stream of “work signals”, things like “product is waiting on tech”, “tech needs client clarity”, or “design approved”, that becomes a live, shared memory of what people still owe each other and what has already resolved.
when someone in product needs something from tech (or sales, ops, or a client), a signal is created between them. it lives inside a small shared space for that interaction, with notes and context attached, and stays visible until both sides consider it done.
forthora runs as an always-on sidebar, so this shared memory is visible while you work, instead of buried in a separate app or chat history.
the result is focused, cross-team work history instead of long chat threads or scattered docs.
there are no tasks, no statuses, and no workflows. just signals that show what’s happening and what’s still open.
i’d love feedback from people who deal with product, engineering, sales, or operations working across each other.
link: https://forthora.com

value: Show HN: Forthora-> an always-on sidebar for cross-team work signals


value: cottomzhang

value:
Paper Animator: turn any photo into a paper cut-out animation in seconds
## What Paper Animator is
Paper Animator is a browser-based tool that transforms any image or text into animated paper cut-outs, folds, tears, and “ransom note” style graphics, with no install or plugins required. It targets short-form video creators, marketers, and designers who want a distinctive paper/stop-motion look without learning motion graphics software.[1]
## Why build this
- Most “paper” or stop-motion looks today require After Effects, templates, or manual masking, which is overkill for TikTok/Reels/Shorts creators who just want a quick effect.[1]
- Existing mobile/video apps rarely combine AI background removal, realistic paper textures, and export-ready formats (green screen, transparent PNG sequences) in one place.
- The goal is a “Canva for paper animation”: upload → tweak → export in under a minute.
## How it works
- Upload a photo (JPG/PNG/WebP up to 10MB); the AI removes the background and extracts the subject as a clean paper cut-out.
- Customize edge roughness, shadows, paper texture, and animation intensity, with live preview in the browser.
- Pick styles like cut-out, fold, tear, origami, ransom-note text, stop-motion wiggle, or text match-cuts.
- Export as 720p/1080p MP4 or transparent PNG sequences, with optional green screen background for compositing in any editor.
## Who it’s for
- *Creators*: TikTok, Instagram Reels, YouTube Shorts looking for scroll-stopping transitions or lyric/quote animations.
- *Marketers & brands*: product launches, UGC-style ads, and “handmade” promo visuals that stand out from template-heavy motion graphics.
- *Educators & artists*: explainer videos, course content, album/cover animations, and experimental collage-style work.
## Pricing and link
- Free tier: create and download animations with a small watermark, for personal use.
- Paid plans: higher resolution, more styles, and commercial usage rights (no watermark).
- Live demo (no signup required): *https://paper-animator.net**
Feedback on UX, performance, and export pipeline from HN (especially motion designers and VFX folks) would be very welcome.

value: Show HN: Transform any photo into paper animations in seconds

author: cottomzhang


value: maurohouseless

value:
Hey HN, my name's Mauro Casas.
I found myself constantly testing and debugging users at the company I work at, and we have strict 2FA requirements for our user base, thus I had to deal constantly with new tokens.
I got tired of using my phone and wanted to have a handy tool which works offline, doesn't require a server and is entirely client-side.
I built https://twofa.dev (open-source) within a few prompts and I'm pretty happy on how it turned out!
Would love to hear feedback!

value: Show HN: Twofa.dev – Local first and offline 2FA/TOTP debugger

author: maurohouseless


value: stared

value:
Hi HN!
"Never perfect. Perfection goal that changes. Never stops moving. Can chase, cannot catch." - Abathur (https://www.youtube.com/watch?v=pw_GN3v-0Ls)
StarCraft 2 is one of the most balanced games ever - thanks to Blizzard’s pursuit of perfection. It has been over 15 years since the release of Wings of Liberty and over 10 years since the last installment, Legacy of the Void. Yet, balance updates continue to appear, changing how the game plays. Thanks to that, StarCraft is still alive and well!
I decided to create an interactive visualization of all balance changes, both by patch and by unit, with smooth transitions.
I had this idea quite a few years ago, yet LLMs made it possible - otherwise, I wouldn't have had the time to code or to collect all changes from hundreds of patches (not all have balance updates). It took way more time than expected - both dealing with parsing data and dealing with D3.js transitions.
Pretty much pure vibe coding with Claude Code and Opus 4.5 - while constantly using Playwright skills and consulting Gemini 3 Pro (https://github.com/stared/gemini-claude-skills). While Opus 4.5 was much better at executing, it was often essential to use Gemini to get insights, to get cleaner code, or to inspect screenshots. The difference in quality was huge.
Still, it was tricky, as LLMs do not know D3.js nearly as well as React. The D3.js transition part is a thing that sometimes I think would be better to do manually, and only use LLMs for details. But it was also a lesson.
Enjoy!
Source code is here: https://github.com/stared/sc2-balance-timeline

value: Show HN: 15 Years of StarCraft II Balance Changes Visualized Interactively

author: stared


value:
ContextFS is a library that lets you construct a virtual filesystem using a router-style API. It's mountable via NFS or `just-bash`, and useful for providing agents with hierarchical, explorable context defined in code.

  // Define file system structure
  const vfs = createFileSystem({
    issues: {
      ":id": {
        [list]: () => getIssues().map(i => ({ id: i.id })),
        [read]: (c) => getIssue(c.params.id).body,
      }
    }
  });

  // Mount with NFS
  await mount(vfs, { mountPoint: "/tmp/issues" });
  await fsp.readFile("/tmp/issues/123");

  // Explore with just-bash
  const env = new Bash({ fs: new ContextFS(vfs) });
  await env.exec("ls /tmp/issues");

Key features:
- Express-style dynamic paths (:id, :slug.md) with full TypeScript inference
- Read and optional write support
- Symlinks to represent relationships
- Browser-safe core library
- Pure TypeScript NFS v3 implementation, no native deps

value: Show HN: ContextFS – virtual file system abstraction for agent context


value: Show HN: A macOS cleanup tool with a terminal UI


value: lostmsu

value:
This is a clone of https://www.transum.org/Software/Shunting/ with improved UX and simplified mechanics suitable for younger kids.
In the original preschoolers were unable to prevent collisions which caused level restart.
The new one is also controllable from the keyboard.
https://github.com/lostmsu/Shunting/issues

value: Show HN: Shunting – train logic puzzles for young kids

author: lostmsu


value:
Hey HN! I built Debrify, an open-source Flutter app that lets you stream and download content from debrid services (Real-Debrid, Torbox, PikPak) without torrenting on your device.

  Features:
  - Built-in video player with streaming support
  - Download manager with queue
  - Works on Android phones, tablets, and Android TV
  - Full D-pad navigation for TV
  - No ads, no tracking, fully open source

  Website: https://varunsalian.github.io/debrify/

  Would love feedback from the community!

value: Show HN: Debrify – Open-source cross-platform debrid manager for Android


value:
Hi HN,
I built Monitor Supply to compare monitors using normalized specs and transparent ranking criteria.
It includes “best for” lists curated by user personas (designers, developers, gamers, mac/windows users), where the scoring and tradeoffs are visible. Some products use affiliate links, disclosed on the site.
It’s early and I’m mainly looking for feedback on:
- Whether the comparison model and persona-based rankings make sense
- What data points feel missing or misleading
- What would make this actually useful vs. noise

value: Show HN: Monitor Supply – compare monitors with normalized specs


value: projectyang

value:
I was curious to see how some of the latest models behaved and played no limit texas holdem.
I built this website which allows you to:
Spectate: Watch different models play against each other.
Play: Create your own table and play hands against the agents directly.

value: Show HN: Play poker with LLMs, or watch them play against each other

author: projectyang


value: This is a small entry app for opening links in the browser profile I want based on the URL. I wrote it in Python first, and now rewrote it in Rust to make it a small standalone binary.<p>Didn't use vibe coding as this was my first real-world Rust rewrite, and I wanted to learn. It was easier and more enjoyable than I imagined!

value: Show HN: Rewrote my most important util in Rust


value:
I’ve been trying to read books in foreign languages for a long time, and the biggest problem for me was always the same:
every unknown word breaks the reading experience.
If I stop and open a dictionary, I lose the sentence and the rhythm.
If I ignore the word, I sometimes miss too much meaning.
Either way, reading turns into work instead of something enjoyable.
I ended up building a small iOS app for myself called LinguaRead. It opens EPUB books and lets you tap on a word to see what it means in the context of the sentence you’re reading. The goal isn’t perfect translation — it’s reducing friction enough to keep reading without constantly switching apps.
It’s a simple tool and still early, but it helped me read longer and finish more books in another language than I could before.
I’m curious how others here approach this problem:
Do you translate selectively or only when you’re stuck?
Do you mostly rely on context?
Do you reread books you already know in another language?
Happy to hear what’s worked (or not worked) for you, and open to feedback.

value: Show HN: An iOS reader that lets you translate words inline while reading


value: dawitworku

value:
What is FlowKitX?
FlowKitX is a Python library that makes writing async workflows more readable and structured.
It provides lazy pipelines: operations (like API calls) are queued and executed only when awaited. This lets you chain calls and process data fluently without blocking the event loop.
It’s not magic — it doesn’t convert blocking code to async or bypass asyncio fundamentals. It’s built for I/O-bound workflows, especially APIs and data pipelines.
Why use it?
Traditional async code can get messy:
async def fetch_user_data(user_id):
    async with aiohttp.ClientSession() as session:
        async with session.get(f"https://api.example.com/users/{user_id}") as response:
            user = await response.json()
            async with session.get("https://api.example.com/posts", params={"userId": user_id}) as posts_response:
                posts = await posts_response.json()
                return {"user": user, "posts": posts}
With FlowKitX:
@flowkit.simple
def fetch_user_data(user_id):
    user = flowkit.get(f"https://api.example.com/users/{user_id}").json()
    posts = flowkit.get("https://api.example.com/posts", params={"userId": user_id}).json()
    return {"user": user, "posts": posts}
result = await fetch_user_data(123)
Cleaner, more readable, and fully composable.
Features
Fluent API – chain operations with .pipe()
Lazy execution – operations run only when awaited
Type-safe – full IDE support and type hints
Framework-ready – examples for FastAPI, Django, Flask
Minimal boilerplate – built on httpx
Examples
Data Processing
@flowkit.simple
def fetch_user_data(user_id: int):
    return (flowkit.get(f"https://jsonplaceholder.typicode.com/users/{user_id}")
              .json()
              .pipe(lambda user: {*user, "processed": True}))
Concurrent API Calls
@flowkit.simple
def fetch_dashboard():
    users = flowkit.get("https://jsonplaceholder.typicode.com/users").json()
    posts = flowkit.get("https://jsonplaceholder.typicode.com/posts").json()
    comments = flowkit.get("https://jsonplaceholder.typicode.com/comments").json()

    return {"users": users, "posts": posts, "comments": comments}  # executes concurrently

When to Use
API-heavy applications
Data pipelines & processing workflows
Teams wanting consistent async patterns
Rapid prototyping
Not for: CPU-bound tasks or making synchronous code non-blocking.
Installation
pip install flowkitx==1.0.1
import flowkit
result = await flowkit.get("https://jsonplaceholder.typicode.com/users/1").json()
print(result)
Github - https://github.com/Dawaman43/flowkit

value: Show HN: FlowKitX – Fluent async workflows with lazy execution for Python

author: dawitworku


value: Xnfinite

value:
I’ve been exploring the risks of letting autonomous AI agents generate or execute code — especially via WASM.
Night Core is a lightweight console that treats execution as a boundary, not just output. It uses signature-based validation, human approval queues, and sandboxed runtimes (like Wasmtime) to let you review or reject what runs — before it happens.
Demo screenshots: https://x.com/xnfinitecore/status/2010067157774991457?s=46
Still early, but open to ideas, pushback, and contributions. Curious if others are thinking about this edge.

value: Show HN: Night Core – A WASM execution firewall for AI agents and untrusted code

author: Xnfinite


value: alexcloudstar

value:
Hi HN,
I’m building makers.page because I’ve noticed a pattern among technical founders: we have high-intent traffic hitting our personal bios, but our "link-in-bio" is usually a static site or a link-tree clone that doesn't do much.
I wanted to build something that treats a maker's reach as a liquid asset.
The Core Concept: It’s a portfolio site where you can showcase your builds, but with a built-in "leasing" mechanic. You can set a price for your top-level "Featured" slot, and other makers in the community can request to lease it.
Why I’m building this:
Contextual Ads: Traditional ads are noisy. A recommendation from a founder you actually follow is high-signal.
Approval-First: The owner of the page has 100% control. You only approve the SaaS products you actually like.
Distribution for New Builds: It gives new makers a way to "buy" eyes from established builders without the friction of traditional ad platforms.
The Stack: I’m building this with Next.js 15, Framer Motion for the UI, and a PostgreSQL backend. I’ve just launched the waitlist to allow people to reserve their handles (first-come, first-served).
The Marquee: I added a "Legends" marquee on the landing page that pulls in handles from the waitlist in real-time. It’s a small detail, but I wanted the "collective" feel to be visible from the second you land.
I'd love to hear your thoughts on the "leasing" mechanic. Is this a distribution model you'd actually use, or is it too close to "selling out"?
I'll be here to answer any questions!

value: Show HN: Makers.page – A link-in-bio for founders with a "slot leasing" protocol


value: mustafaiste

value: Show HN: Stillmail. minimalist email app for friends

author: mustafaiste


value: dxsecarch

value: Show HN: I built a DLL to stop Excel/Word from spawning PowerShell shells

author: dxsecarch


value: AttentionBlock

value:
This is my attempt in building a memory that evolves and persist for claude code.
My approach is inspired from Zettelkasten method, memories are atomic, connected and dynamic. Existing memories can evolve based on newer memories. In the background it uses LLM to handle linking and evolution.
I have only used it with claude code so far, it works well with me but still early stage, so rough edges likely. I'm planning to extend it to other coding agents as I use several different agents during development.
Looking for feedbacks!

value: Show HN: Persistent Memory for Claude Code (MCP)

author: AttentionBlock


value: MarkSweep

value: Did you just wake up from a 20 year coma? Did you build a bunch of buzzword compliant web services back in the early 2000s and want all your SOAP and WSDL to be relevant again? Now you can put the smooth sheen of AI on your pile of angle brackets by exposing your SOAP-based web service as a Model Context Protocol (MCP) server.

value: Show HN: MCP server for SOAP web services

author: MarkSweep


value: ayushmaanbhav

value:
Most "Voice AI" demos today are just API wrappers around cloud LLMs. They are impressive, but they fail in production for three reasons: Latency, Compliance, and Lack of Control.
I built VAAK (Voice-Activated Autonomous-Knowledge-System) to solve exactly this.
It’s not just a "local chatbot." It is a domain-agnostic, production-grade Conversational Operating System built entirely in Rust.
Here is why Senior Architects and Product Leaders should pay attention:
1. The "Deterministic" Architecture  Enterprise AI cannot hallucinate when discussing interest rates or medical advice. VAAK uses a hybrid architecture:
Generative Fluidity + Deterministic Guardrails: It flows naturally but adheres strictly to business logic for critical data.
Sophisticated Memory Systems: It doesn't just "remember" the last token. It separates Context Memory (conversation flow) from Agent Memory (long-term facts), allowing it to handle complex, multi-turn negotiations without losing the plot.
Real-Time RAG: Built-in Retrieval Augmented Generation that queries your internal knowledge base in milliseconds, ensuring answers are grounded in your documents, not the internet.
2. Built for Complex "Human" Behaviors  VAAK isn't limited to Q&A. It is engineered for specific high-value modes:
Discovery & Intent: Accurately identifies why the user is calling before attempting to solve.
Objection Handling: A dedicated layer that manages pushback (e.g., "The price is too high") with empathetic, logic-backed retorts.
Sales & Conversions: Tracks sentiment and guides the conversation toward a closing event.
Finance & CRM: Securely handles transactional queries (Gold Loans, EMI calculations) with zero data leakage.
3. True Sovereignty & Security (GDPR Ready)  In the era of "Data Sovereignty," VAAK offers what big cloud providers can’t: Total Isolation.
Air-Gapped Runtime: No data leaves your VPC.
Compliance First: Built-in PII redaction and audit logging.
Zero-Trust Design: You own the model, the weights, and the inference pipeline.
4. Performance Engineering (The Rust Advantage)
<500ms Latency: Achieves human-level "interruptibility" and response times.
No GPU Tax: Runs inference efficiently on standard CPUs.
Configurability: Change the entire domain (e.g., from Banking to Healthcare) just by swapping a YAML config file.
The Vision VAAK is proof that we don't need massive clusters to build intelligent systems. We need better engineering.
If you are building for Banking, Healthcare, or Government sectors where privacy and precision are non-negotiable—this is the blueprint.
Explore the architecture & code here:  https://github.com/ayushmaanbhav/Voice-Activated-Autonomous-...
#VAAK #RustLang #SystemArchitecture #GenerativeAI #SovereignAI #EnterpriseTech #VoiceAI #RAG #OpenSource #SoftwareEngineering

value: Show HN: VAAK (Voice-Activated Autonomous-Knowledge-System)

author: ayushmaanbhav


value: quentinrgdev

value:
Hello HN,
I’m the developer behind Tooliz. I built this because I was frustrated with the current state of utility apps on the Play Store—most are either 100MB+ bloatware, require unnecessary permissions (like contacts/location for a flashlight), or force full-screen video ads just to use a simple ruler.
I wanted to build a single, lightweight app that respects the user and focuses on UI/UX efficiency.
The Tech Stack: It’s built with Flutter. I chose it to handle the custom painting required for the tools smoothly at 60fps+ on both Android and iOS.
Interesting Technical Challenges:
The Radial Menu: I didn't want a standard grid or drawer. I implemented a custom Radial Menu using CustomPainter and heavy trigonometry to handle the touch hit-testing and animations. It feels much faster for thumb navigation than reaching for a top-left hamburger menu.
Sensor Fusion & Hardware:
Metal Detector: Accesses the raw magnetometer stream (sensors_plus package). I had to implement a calibration step to filter out the background magnetic field and isolate local anomalies (metals).
Sound Meter: Uses the microphone stream to calculate decibels. Mapping the raw PCM data to accurate dB SPL values across different device microphones was... painful. I used a calibration offset system to mitigate hardware variance.
Offline-First Architecture: Except for a minimal ad banner (to keep the project alive), everything works offline. For the Unit Converter, I hardcoded the conversion logic instead of relying on an API, so it works instantly in airplane mode.
Monetization: It’s free. There is a small banner ad (AdMob) at the bottom.
I’d love to hear your feedback on the Radial UI implementation or the sensor accuracy on your specific device!

value: Show HN: Tooliz – An offline-first mobile toolkit built with Flutter (Radial UI)

author: quentinrgdev


value: dustfinger

value:
I built a tag-driven changelog generator for an OSS project I maintain and used it to backfill our 2025 docs changelog.
It walks git tags, finds merged PRs between releases, buckets them into categories, and renders MDX (Docusaurus in our case) organized by year -> month -> category -> version. There is an optional LLM mode that produces structured JSON via a Pydantic schema for PR entry and monthly summaries.
Example:
python .scripts/changelog/generate.py --year 2025 --github --ai --ai-model gpt-5.2
(or --help)
Gotcha: if you use --github, set GITHUB_TOKEN or you will most likely hit GitHub rate limits.
Repo script: https://github.com/confident-ai/deepeval/blob/main/.scripts/...
Disclosure: I maintain DeepEval. Happy to answer questions and take feedback.

value: Show HN: Tag driven changelog generator (MDX) with optional LLM summaries

author: dustfinger


value: jackprescott

value: Show HN: Marten – Elegant Go web framework (nothing in the way)

author: jackprescott


value: jackomelon

value:
Inspired by DeepWiki, which I love! I wrote about my thoughts on agent-generated
architectural wikis a few days ago: https://dakota.codes/blog/agent-generated-architectural-wiki...
Ted Mosby (the architect) generates documentation where every concept links to exact source code
(file:line references). Uses RAG with FAISS for semantic search, generates Mermaid
diagrams, and includes an automatic verification loop that keeps generating until
all internal links resolve.
Built on top of the Claude Agent SDK (using buildanagentworkshop.com) Feedback welcome!! :)

value: Show HN: Show HN: Ted Mosby – open-source Claude agent for architectural wikis

author: jackomelon


value:
Hey HN - long-time reader, first-time Show HN.
I built a sports app called Arbitration[1] primarily for experiencing live professional games. The original itch was pretty simple: during close or rivalry games I’d constantly flip between two team game threads on Reddit to see how each side was reacting to the same play.
Arbitration puts both fanbases’ live reactions in one place, synced to the game clock. It doesn’t generate opinions or takes — it just curates what fans are already saying, in real time.
Feel free to checkout the first NFL playoff game of the year, Rams @ Panthers: https://www.app.arbi.gg/scores/nfl/20260110-8-5
For folks curious about the tech:
- Agents are used to curate and rank live fan posts (not generate content)
- Live DraftKings props come from a websocket snooper[2]
- Google Gemini is used only to structure and summarize live prop data
- Rust backend, React frontend, anonymous sessions, no accounts.
- Mostly built for myself, but figured others here might enjoy it.
- iOS app coming soon!
Happy to answer questions :)
- [1] https://arbi.gg
- [2] DraftKings websocket snooper: https://github.com/stonehedgelabs/snuper

value: Show HN: Arbitration, a way to experience live sports through both fanbases


value: rinvi

value:
I wanted to control the browser from the terminal so I made buse:
buse browser-1            # open chrome
buse browser-1 navigate "https://example.com"
buse browser-2            # open a second browser
buse browser-2 search "cat"
buse browser-1 observe    # returns JSON about the page
buse browser-1 click 16   # clicks on the learn more link
I've been reading about agentic computer use and I tried to use MCPs and Browserbase, but there was just a lot of friction for me. So, I brought it to the CLI instead.
https://github.com/rinvii/buse

value: Show HN: buse – automate your browser from the terminal

author: rinvi


value: grahameb

value: Show HN: Sebastos: a sync client for Standard Ebooks

author: grahameb


value: seesea

value:
We’ve been working with auditors and compliance teams in regulated sectors (finance, healthcare) and hit a wall: LLM risk assessments are subjective, non-reproducible, and don't satisfy growing regulatory demands for evidence, not just opinions.
So we built EB3F (Evidence-Based Framework for Foundational Models). It's a packaged methodology that transforms an audit from a consultant's report into a standardized process for producing reproducible, legally-admissible exhibits.
The twist: We're not selling consulting services. We're structuring it as a transferable asset (like a franchise model). We sell the complete framework – methodology, tools, templates – so that consultancies, RegTech firms, or in-house teams can run their own certified audits.
We're looking for:
1. Feedback from experts in AI governance, compliance, and ML security. Is this approach useful? What's missing?
2. First partners (especially in consulting or RegTech) who want to implement this as their own service line. We're ready to discuss details under NDA.
Why would you buy this? Our estimate (based on building similar frameworks in corps): it saves 18-24 months and $750K-$1M+ in R&D, legal reviews, and piloting that you'd spend to build this in-house.
What does the community think? Can a "framework as an asset" model work in the AI governance space?

value: Show HN: EB3F A framework to turn LLM audits into a legal-grade

author: seesea


value: aswinsilvadasan

value:
Main tools on Kliga.com:
1) AI Music Detector
- Detects with 99.9% accuracy with smart models attuned to latest AI models.
- You can upload an audio file or paste a Spotify track URL and Kliga analyzes whether the music is likely AI-generated or human-made.
- It uses spectral + temporal analysis and gives a probability breakdown instead of a simple yes/no.
2) Audio Mastering
- 100% private, your songs never hit our servers
- Preview with 12 Studio-grade presets designed by industry experts.
- Download in HD-WAV 24 bit, MP3 320kbps for FREE.
- No audio engineering required.
There are other useful tools like video compressor, audio cutter, etc. Do check them out.
Why I built this:
- AI-generated music is everywhere now, but it’s hard to quickly verify authenticity accurately.
- Most artists want to master their songs privately before releasing. They want one-click processing happening in their own device without having to download an expensive software.
Direct Links to main tools:
- AI Detector: https://kliga.com/ai-music-detector
- Audio Mastering: https://kliga.com/mastering
Happy to answer any questions. Thanks for checking it out!

value: Show HN: Human or AI-made song detector and 100% Private Audio Mastering

author: aswinsilvadasan


value:
Hi HN,
I’m working on an experimental 3D FPS game engine in C++20, aiming to deeply understand engine internals from first principles rather than just using existing frameworks.
Currently I'm strictly following LearnOpenGL docs.
This project focuses on:
Entity-Component-System (ECS) architecture for high performance.
OpenGL 4.1 rendering with a PBR pipeline, material system, HDR, SSAO, and shadow mapping.
Modular systems: input, physics (Jolt), audio (miniaudio), assets, hot reload.
A sample FPS game & debug editor built into the repo.
Repo: https://github.com/jackthepunished/horizon-engine
This isn’t intended to be a commercial rival to any commercial game engines.
it’s a learning and exploration project: understanding why certain engine decisions are made, and how to build low-level engine systems from scratch.
I’m especially looking for feedback on:
Architecture choices (ECS design, render loop, module separation) Your thoughts on modern C++ engine patterns
What you’d build vs stub early in a homemade engine
Tips from experienced graphics/engine developers
Criticism and suggestions are very welcome — it’s early days and meant to evolve.
Thanks for checking it out!

value: Show HN: Horizon Engine – C++20 3D FPS Game Engine with ECS and Modern Renderer


value: There is also a little command line tool to search jobs from command line. You can also use the web interface at https://jobswithgpt.com

value: Show HN: MCP Server for Job Search

title: Show HN: MCP Server for Job Search


value: rainliu

value:
We're excited to share rtc (https://github.com/webrtc-rs/rtc), a pure Rust WebRTC implementation built on the sans-I/O architecture. With the recent release of rtc v0.7.0, we've achieved feature parity with our async-based webrtc crate while offering complete runtime independence.
## What is Sans-I/O?
Sans-I/O separates protocol logic from I/O operations. Instead of the library performing network reads/writes, YOU control all I/O. The library acts as a pure state machine.
Core API (8 methods):
- poll_write() / poll_event() / poll_read() / poll_timeout() - Get outputs
- handle_read() / handle_timeout() / handle_write() / handle_event() - Feed inputs
## Why Sans-I/O for WebRTC?
WebRTC is a STACK of protocols (ICE, DTLS, SRTP, SCTP, RTP/RTCP). Traditional implementations tightly couple protocol logic with async runtimes, making them runtime-locked, difficult to test without network I/O, and hard to integrate into existing event loops.
Sans-I/O solves this by modeling WebRTC as a composable protocol pipeline where each layer implements the same sansio::Protocol trait.
## Feature Parity
- Full WebRTC 1.0 API (PeerConnection, Media, DataChannel)
- Complete protocol stack (ICE, DTLS, SRTP/SRTCP, SCTP, RTP/RTCP)
- Simulcast with multiple spatial layers
- RTCP Interceptors (NACK, Sender/Receiver Reports, TWCC)
- mDNS support for IP privacy
- W3C and RFC compliant
## Architecture Highlights
- Pure Protocol Pipeline: WebRTC as composable handlers implementing sansio::Protocol. Read: Raw Bytes → Demuxer → ICE → DTLS → SCTP/SRTP → Interceptor → Endpoint. Write path reverses this.
- Zero-Cost Abstractions: Interceptors use generic composition instead of async trait objects. No heap allocations in the hot path.
- Multi-Socket I/O: Handle multiple sockets (mDNS multicast + WebRTC traffic) in one event loop - difficult with async designs.
- Testable: Protocol logic tested without network I/O. Feed synthetic packets, verify state transitions.
## Relationship with async webrtc
rtc (sans-I/O) and webrtc (async) are COMPLEMENTARY:
- Use webrtc for async/await, Tokio integration, quick start
- Use rtc for runtime independence, custom I/O, maximum control, embedded systems
Both actively maintained.
## Recent Milestones
v0.7.0 (Jan 10) - mDNS support for IP privacy with .local hostnames
v0.6.0 (Jan 9) - Complete interceptor framework (NACK, RTCP Reports, TWCC)
v0.5.0 (Jan 5) - Enhanced simulcast support
v0.3.0 (Jan 4) - Initial public release
## Use Cases
Sans-I/O shines for: custom networking, embedded systems, game engines, high performance applications, testing infrastructure, WebAssembly.
## Links
- GitHub: https://github.com/webrtc-rs/rtc
- Crates.io: https://crates.io/crates/rtc (v0.7.0)
- Docs: https://docs.rs/rtc
- Blog: https://webrtc.rs/blog
- Discord: https://discord.gg/4Ju8UHdXMs
Technical deep dives available on our blog exploring the protocol pipeline architecture and interceptor design principles.
We'd love feedback from the Rust and WebRTC communities!

value: Show HN: webrtc-rs/rtc – A Sans-I/O WebRTC Stack for Rust

author: rainliu


value:
Fully built with Claude Code.  Hook into Claude Code sessions to sync session data to https://confabulous.dev.  From there, you can explore the transcript, create share links, calculate productivity metrics.
CLI piece is open source at https://github.com/ConfabulousDev/confab
Free while in beta.  Likely there will be a free tier forever.
Give it a spin at https://confabulous.dev

value: Show HN: Understand your Claude Code sessions


value: vaskort

value: Show HN: Symfreq – Analyse symbol frequencies in code (Rust)

author: vaskort


value: yungookim

value: Turn messy email threads and attachments into clean notes with agentic RAG

value: Show HN: Lolodex turns email threads and attachments into clean/searchable notes

author: yungookim


value: tehryanx

value: Show HN: Chordle. Learn to identify pitch by playing Wordle with chords

author: tehryanx


value: mimchak

value:
I launched Embex two weeks ago and hit 9,000 downloads (7K PyPI, 2K npm).
Embex is a universal ORM for vector databases. One API that works across LanceDB, Qdrant, Pinecone, Chroma, PgVector, Milvus, and Weaviate.
The problem: Every vector database has a different API. Switching from Pinecone to Qdrant means rewriting your data layer.
Example:
```python
# Works with ANY provider
client = await EmbexClient.new_async(provider="lancedb", url="./data")
await client.insert("products", vectors)
results = await client.search("products", vector=query, top_k=5)<p># Switch to Qdrant? Change one line:
client = await EmbexClient.new_async(provider="qdrant", url="http://localhost:6333")
```
Built with Rust core + SIMD acceleration (4x faster than pure Python/JS). Available for Python and Node.js.
What happened after launch:
- Published to PyPI and npm
- Downloads started coming in organically
- 9K downloads in 2 weeks
I'm honestly not sure where most of the traffic came from. PyPI/npm search probably, but I haven't dug into the analytics deeply. I just made one LinkedIn post which didn't get any likes/comments.
Start local with LanceDB (embedded, zero Docker), then switch to production databases (Qdrant, Pinecone, Milvus) without changing code.
GitHub: https://github.com/bridgerust/bridgerust
Docs: https://bridgerust.dev/embex/introduction
Would love feedback on:
- API design decisions
- Which databases to support next
- Performance optimizations
Built using BridgeRust, a framework for creating cross-language Rust libraries (also open source in this repo).

value: Show HN: Embex – 9K organic downloads in 2 weeks with zero marketing

author: mimchak


value: jamesponddotco

value:
TLDR: Librario is a book metadata API that aggregates data from Google Books, ISBNDB, and Hardcover into a single response, solving the problem of no single source having complete book information. It's currently pre-alpha, AGPL-licensed, and available to try now[0].
My wife and I have a personal library with around 1,800 books. I started working on a library management tool for us, but I quickly realized I needed a source of data for book information, and none of the solutions available provided all the data I needed. One might provide the series, the other might provide genres, and another might provide a good cover, but none provided everything.
So I started working on Librario, a book metadata aggregation API written in Go. It fetches information about books from multiple sources (Google Books, ISBNDB, Hardcover. Working on Goodreads and Anna's Archive next.), merges everything, and saves it all to a PostgreSQL database for future lookups. The idea is that the database gets stronger over time as more books are queried.
You can see an example response here[1], or try it yourself:

  curl -s -H 'Authorization: Bearer librario_ARbmrp1fjBpDywzhvrQcByA4sZ9pn7D5HEk0kmS34eqRcaujyt0enCZ' \
  'https://api.librario.dev/v1/book/9781328879943' | jq .

This is pre-alpha and runs on a small VPS, so keep that in mind. I never hit the limits in the third-party services, so depending on how this post goes, I’ll or will not find out if the code handles that well.
The merger is the heart of the service, and figuring out how to combine conflicting data from different sources was the hardest part. In the end I decided to use field-specific strategies which are quite naive, but work for now.
Each extractor has a priority, and results are sorted by that priority before merging. But priority alone isn't enough, so different fields need different treatment.
For example:
- Titles use a scoring system. I penalize titles containing parentheses or brackets because sources sometimes shove subtitles into the main title field. Overly long titles (80+ chars) also get penalized since they often contain edition information or other metadata that belongs elsewhere.
- Covers collect all candidate URLs, then a separate fetcher downloads and scores them by dimensions and quality. The best one gets stored locally and served from the server.
For most other fields (publisher, language, page count), I just take the first non-empty value by priority. Simple, but it works.
Recently added a caching layer[2] which sped things up nicely. I considered migrating from net/http to fiber at some point[3], but decided against it. Going outside the standard library felt wrong, and the migration didn't provide much in the end.
The database layer is being rewritten before v1.0[4]. I'll be honest: the original schema was written by AI, and while I tried to guide it in the right direction with SQLC[5] and good documentation, database design isn't my strong suit and I couldn't confidently vouch for the code. Rather than ship something I don't fully understand, I hired the developers from SourceHut[6] to rewrite it properly.
I've got a 5-month-old and we're still adjusting to their schedule, so development is slow. I've mentioned this project in a few HN threads before[7], so I’m pretty happy to finally have something people can try.
Code is AGPL and on SourceHut[8].
Feedback and patches[9] are very welcome :)
[0]: https://sr.ht/~pagina394/librario/
[1]: https://paste.sr.ht/~jamesponddotco/a6c3b1130133f384cffd25b3...
[2]: https://todo.sr.ht/~pagina394/librario/16
[3]: https://todo.sr.ht/~pagina394/librario/13
[4]: https://todo.sr.ht/~pagina394/librario/14
[5]: https://sqlc.dev
[6]: https://sourcehut.org/consultancy/
[7]: https://news.ycombinator.com/item?id=45419234
[8]: https://sr.ht/~pagina394/librario/
[9]: https://git.sr.ht/~pagina394/librario/tree/trunk/item/CONTRI...

value: Show HN: Librario, a book metadata API that aggregates G Books, ISBNDB, and more

author: jamesponddotco


value: dibasdauliya

value:
I've been using TheTabber primarily to repurpose my mom's TikTok content for other social media platforms. The available options are too expensive and too cluttered and confusing.
I thought, why not add more features with a clean and easy-to-use UI and publish it? So here I am.
I came up with the name TheTabber because the more tabs you have open for social media posting, the more of The Tabber you are--and this product is for you. LOL!
These are the available features so far:
- Connect 9+ social platforms
- Post or schedule image, carousel, video, or text content
- Repurpose content from other social media accounts
- View analytics of your posts
- Create UGC-style videos with AI help
- Create 2x2 image grid videos with AI help
- Generate captions, edit styles, split long video into segments with AI help

value: Show HN: TheTabber – Create, repurpose, and post across 9+ platforms

author: dibasdauliya


value:
While working on a proof of concept project, I kept hitting Claude's token limit 30-60 minutes into their 5-hour sessions. The accumulating context from the codebase was eating through tokens fast. So I built a language designed to be generated by AI rather than written by humans.
GlyphLang
GlyphLang replaces verbose keywords with symbols that tokenize more efficiently:

  # Python
  @app.route('/users/<id>')
  def get_user(id):
      user = db.query("SELECT * FROM users WHERE id = ?", id)
      return jsonify(user)

  # GlyphLang
  @ GET /users/:id {
    $ user = db.query("SELECT * FROM users WHERE id = ?", id)
    > user
  }

  @ = route, $ = variable, > = return. Initial benchmarks show ~45% fewer tokens than Python, ~63% fewer than Java.

In practice, that means more logic fits in context, and sessions stretch longer before hitting limits. The AI maintains a broader view of your codebase throughout.
Before anyone asks: no, this isn't APL with extra steps. APL, Perl, and Forth are symbol-heavy but optimized for mathematical notation, human terseness, or machine efficiency. GlyphLang is specifically optimized for how modern LLMs tokenize. It's designed to be generated by AI and reviewed by humans, not the other way around. That said, it's still readable enough to be written or tweaked if the occasion requires.
It's still a work in progress, but it's a usable language with a bytecode compiler, JIT, LSP, VS Code extension, PostgreSQL, WebSockets, async/await, generics.
Docs: https://glyphlang.dev/docs
GitHub: https://github.com/GlyphLang/GlyphLang

value: Show HN: GlyphLang – An AI-first programming language


value: thegoodduck

value:
An easy-to-self-host social media platform
designed to work without a central authority.<p>Each instance controls its own data, feeds are lightweight,
and content can be verified cryptographically.

value: Show HN: Endless: Run Your Own Social Network

author: thegoodduck


value: JoseOSAF

value:
I did something that might be incredibly stupid.
I made 25 specific predictions about what will happen in tech over the next 6 months — and published all of them with deadlines before I could chicken out.
Not vague "AI will grow" predictions. Specific, falsifiable claims like:
Medical AI will face mandatory safety requirements within 18 months (regulatory signals are screaming)
There's a ~6 month window in AI infrastructure before consolidation locks out new entrants
Browser agents hit mainstream faster than current discourse suggests
Each prediction has a confidence score, a hard deadline, and what would prove me wrong.
Why would I do this?
Because I'm tired of pundits making unfalsifiable claims and retroactively declaring victory. "I predicted crypto would struggle" — okay, when? By how much? What counts as struggling?
So I'm doing the opposite. Public predictions. Specific deadlines. No editing after the fact.
The first verification check runs January 24. I'll publish results whether they make me look smart or completely delusional.
A few already make me uncomfortable — some have conviction scores above 75%, which feels overconfident for 6-month horizons. But that's the point. If I'm not risking being wrong, I'm not actually predicting anything.
All 25: https://asof.app/alpha
What's your most contrarian take on what happens in tech this year? Curious what predictions HN would make with actual deadlines attached.

value: Show HN: I made 25 tech predictions and mass-published them

author: JoseOSAF


value: malkosvetnik

value:
I built an open-source desktop weather widget for Windows focused on short-term
rain accuracy using 15-minute nowcasting. Feedback welcome.

value: Show HN: Desktop weather widget for Windows with short-term rain nowcasting

author: malkosvetnik


value: RyanZhuuuu

value: Show HN: Epstein IM – Talk to Epstein clone in iMessage

author: RyanZhuuuu


value: devttyeu

value: My current role requires me to do insane amounts of context-switching, with many of them being fairly long-running or requiring quite a bit of back-and-forth. This is a quick vibe-coded project which adds a new mode for managing "tasks" (as-in todo-list tasks) as dedicated desktops - the idea is that in times of less focus (e.g. boring meetings) I can do discovery/setup phase of a bunch of things, then later can, much more efficiently execute things which need slightly more focus (think like pulling input docs / conversations first to then write an email; Finding relevant dashboards and user reports to later debug some complex issue).<p>In principle this model should also work much better with desktop AI agents, but that is not a problem I need to solve now.

value: Show HN: A task-based workflow manager for bspwm – tasks as desktops

author: devttyeu


value: zameermfm

value: I'm a backend, infra dev for a IoT based European startup for few years. After years of ups and downs with distributed computing ideas and being amazed by it, I badly needed a side project to exercise them on my own. For one, this is more of a exploration in that direction, but I also want to see if PDF API SaaS business still has legs.

value: Show HN: Fast, Low cost Pay as you go PDF API for HTML, Markdown and images

author: zameermfm


value: juleshenry

value: Fun project I made to stamp my code deliberately recursively with @DerekITCoder (https://github.com/DerekITCoder)

value: Show HN: Tatuagem, a boastful code signature suite

author: juleshenry


value: OlaProis

value:
Ferrite: Fast Markdown/Text/Code editor in Rust with native Mermaid diagrams
Built a Markdown editor using Rust + egui. v0.2.1 just dropped with major Mermaid improvements:
→ Native Mermaid diagrams - Flowcharts, sequence, state, ER, git graphs - pure Rust, no JS
→ Split view - Raw + rendered side-by-side with sync scrolling
→ Syntax highlighting - 40+ languages with large file optimization
→ JSON/YAML/TOML tree viewer - Structured editing with expand/collapse
→ Git integration - File tree shows modified/staged/untracked status
Also: minimap, zen mode, auto-save, session restore, code folding indicators.
~15MB binary, instant startup. Windows/Linux/macOS.
GitHub: https://github.com/OlaProeis/Ferrite
v0.2.2 coming soon with performance improvements for large files. Looking for feedback!

value: Show HN: Ferrite – Markdown editor in Rust with native Mermaid diagram rendering

author: OlaProis


value: weishu

value: Show HN: HAPI - Vibe Coding Anytime, Anywhere

author: weishu


value: I was searching for this kind of app for a very long time. I checked HC-Gateway. But it needs external server or give hosted URL. I don't want to share my data to external service. So I went and built my own and made it source available. You can use this with n8n, activepieces, or any POST URL which accepts data. It's still in beta, feel free to try and share feedback.

value: Show HN: I made an Android app which sends Health Connect data to your webhooks


value: burnerToBetOut

value:
Since version 9 of Java (~2014) it's had  the Java Platform Module System (JPMS) [1].
TL;DR: Like the 'M' in JPMS suggests, it let's you compose a system using collaborating chunks of functionality.
It's fair to say that Java modules are designed mainly with the JDK itself in mind. The JDK itself is JPMS' most gung ho user. Modules' main goal in life seems to mostly be to keep riff raff system programmers from poking around in the JDKs internals.
Java modules are a killer idea in my opinion. So it surprises me that it's been adopted by so few in the   Java ecosystem beyond the Java platform itself.
I wrote the com.lingocoder.mrjar Gradle plugin [2] as a hobby project. Mostly because I get a kick out of designing and building modular applications.
I'm under no illusions that this plugin will have any impact whatsoever on adoption of Java modules. I'm just putting it out there as a demonstration.
I'm hoping it shows how developing JPMS-based libraries doesn't have to be as onerous as many application programmers at most Java shops seem to think.
[1] https://openjdk.java.net/jeps/261
[2] http://lingocoder.com/mrjar/

value: Show HN: mister.jar – Modular MRJAR Files Made Easy

author: burnerToBetOut


value: BlackVectorOps

value: Show HN: Hashing Go Functions Using SSA and Scalar Evolution

author: BlackVectorOps


value: jackzhuo

value: Show HN: Reverse-engineering images into model-specific syntax(MJ,Nano,Flux,SD)

author: jackzhuo


value: haasiy

value:
Hi HN! I built VAM Seek because I was frustrated with 1D seek bars – you never know where you're going until you get there.
VAM Seek renders a 2D thumbnail grid next to your video. Click any cell to jump. All frame extraction happens client-side via canvas – no server processing, no pre-generated thumbnails.
- 15KB, zero dependencies
- One-line integration
- Works with any <video> element
Live demo: https://haasiy.main.jp/vam_web/deploy/lolipop/index.html
Would love feedback!

value: Show HN: VAM Seek – 2D video navigation grid, 15KB, zero server load

author: haasiy


value: SnowingXIV

value: Show HN: Umaro – An interactive music theory suite for guitarists

author: SnowingXIV


value: veliona

value: Show HN: Artdots: The benefits of creating a side project

author: veliona


value: dufbugderopa

value: Show HN: Just published a hard-SF novel Voyager1 returns with a quantum palantir

author: dufbugderopa


value: kodefreeze

value:
Hi HN,
I built this tool to solve the "flakiness" problem in UI testing. Existing AI agents often struggle with precise interactions, while traditional frameworks (Selenium/Playwright) break whenever the DOM changes.
The Approach: Instead of relying on hard-coded selectors or pure computer vision, I’m using a multi-agent system powered by multimodal LLMs. We pass both the screenshot (pixels) and the browser context (network requests, console logs, etc) to the model. This allows the agent to:
"See" the UI like a user and accurately map semantic intent ("Click the Signup button") to precise coordinates even if the layout shifts.
The goal is to mimic natural user behavior rather than following a predefined script. It handles exploratory testing and finds visual bugs that code-based assertions miss.
I’d love feedback on the implementation or to discuss the challenges of using LLMs for deterministic testing.

value: Show HN: UI testing using multimodal LLMs

author: kodefreeze


value: cboulio

value:
AI generates complete novels with cover art, ready for print Text: I built a tool that generates complete, print-ready books from a single concept. Enter your idea, pick a genre and length, and you get:
Full manuscript PDF (formatted for print with title page, copyright, chapters)
Editable DOCX file
AI-generated cover art
Print-ready cover PDF with spine
The whole thing takes a few minutes. Output is sized for standard trim sizes so you can upload directly to KDP or other print-on-demand services. Built with Claude for the writing and image generation for covers. Priced starting at $19. Would love feedback on the concept and output quality. https://printreadybook.com

value: Show HN: PrintReadyBook

author: cboulio

title: Show HN: PrintReadyBook


value:
I use voice dictation daily, but Wispr Flow at $144/year felt
like too much for what it does.
So I built a minimal version: Hold Option → Speak → Release →
Text appears at cursor.
- Works in any app
- 100% local (WhisperKit), works offline
- No account, no cloud
It's not as polished as Wispr or MacWhisper. But it's $1 and
gets the job done.
If you run into any bugs, email me at support@getairboard.com
— I'll fix it. Helps me learn too.
Built with SwiftUI + WhisperKit. Happy to answer questions.

value: Show HN: Airboard – $1 voice dictation for Mac local


value: deevus

value: Show HN: Use Terraform to manage to your TrueNAS apps

author: deevus


value: vcrushing

value: Shelfarr is a tool for cleaning and renaming audiobook libraries. It scans local files, matches available metadata, and produces consistent folder and filename structures, including series handling. All changes are previewed before applying, with support for dry runs and custom templates. The focus is on predictable behavior and user control rather than full automation.

value: Show HN: Shelfarr is an open source audiobook renamer tool

author: vcrushing


value: patrickdavey

value:
This is a play website I built out with my 6 year old to show her that you can also build for the web (not just consume!).  The idea was to make a bunch of small mini games (more coming) where you can learn some basic chess strategy.  In this game you play a knight vs 3 kings who try to trap you.  Try to survive for 15 moves.
Once you get bored of that, there's the classic radioactive pooping knights [1] ;). It's also wrapped up into an app [2] if that's better :)
Very keen for feedback :)
1. https://minichessgames.com/#/play/pooping-knights
2. https://play.google.com/store/apps/details?id=com.minichessg...

value: Show HN: Kings vs. Knight

author: patrickdavey

title: Show HN: Kings vs. Knight


value: jokera

value: Show HN: AI Character Generator for Fashion Model Shots and Consistent Avatars

author: jokera


value: laxmena

value:
I built this MCP (Model Context Protocol) server to let AI agents easily publish, edit, and manage content on Write.as or self-hosted WriteFreely instances.
It's useful for automating AI-generated blogs, newsletters, or feeds without manual intervention.Key
features:
1. Publish/edit/delete posts and collections
2. Browse public feeds
3. Supports auth via access tokens
Python-based, installs via uv/pip
Motivation:
I wanted a simple way for AI workflows to integrate with privacy-focused platforms like (Write.as) WriteFreely.
It's early (v0.1.3), so feedback on tools like publish_post() or config would be great.
MIT license—fork/contribute if interested!
Repo: https://github.com/laxmena/writefreely-mcp-server
PyPi: https://pypi.org/project/writefreely-mcp-server/
What do you think? Any use cases or improvements?

value: Show HN: MCP Server for AI Agents to Publish on WriteFreely

author: laxmena


value: KenzoArai

value: Show HN: DreamForge – AI dream journal that turns dreams into art

author: KenzoArai


value: Show HN: Cortex – Android Notification manager with on-device LLM


value: robotnikz

value: new in development, feedback highly appreciated =)

value: Show HN: WinBorg, a beautiful alternative to Vorta for BorgBackup

author: robotnikz


value: mandynoee

value: Show HN: I built an Instagram-style productivity app with gamification

author: mandynoee


value: mikasisiki

value: Show HN: MCP for browsing, searching, exporting, backing up Cursor chat history

author: mikasisiki


value:
I built a diagram editor optimized for keyboard based workflows.
The main UI is the command palette with fuzzy search over the actions applied over the selected objects.
It saves diagrams as json & can export to SVG (no-round trip support).
Curious on what people think of this :)

value: Show HN: Keyboard-first diagram editor in Rust with fzf-style command palette


value: tanin

value:
Hi HNers,
I've just made a self-hosted CORS-enabled waitlist that writes to Google Sheets for myself.
It's the most economical option. Google Sheets is free. One instance can serve many many landing pages. The landing pages wouldn't need backends and can be hosted for free e.g. Netlify, Github Pages.
The integration is also seamless. It utilizes CORS. You can make a waitlist form on your own HTML and just do a cross-domain AJAX request. This gives the highest flexibility in terms of styling and customize the after actions.
The alternatives often use iframes, which are more difficult to style and customize because you won't have direct access to the content within the iframes.
I use it to power >10 of my landing pages, which are all hosted for free on Netlify. The Wait server is hosted on OVHcloud for $4/month.
I'm looking for early users who are interested. If you are interested, please let me know.
The repo: https://github.com/tanin47/wait
Thank you!

value: Show HN: Self-hosted CORS-enabled waitlist that connects to Google Sheets

author: tanin


value: Show HN: I auto-generate alt text using Gemini 3 Flash


value: Show HN: I created an interactive tool to visualize various ML algorithms


value: anythingworks

value: I analyzed 10 years of Hacker News data (2016-2025) to track Show HN submission trends.<p>- Show HN posts went from ~900/month (2016-2019) to 3,315 in Dec 2025<p>- Share of all stories: 2.4% (2016) → 12.8% (Dec 2025)<p>- Notable spikes: COVID-19 (2020), AI boom (2023), and accelerating growth through 2024-2025<p>Data source: HackerBook (144k Show HN posts / 3.4M total stories)

value: Show HN: Show HN submissions have tripled since 2023

author: anythingworks


value: Show HN: Verdic Guard – Policy Enforcement and Output Validation for LLMs


value:
We’ve been working on production LLM systems and noticed a recurring issue:
even well-crafted prompts fail under real-world conditions.
We wrote a technical breakdown of the failure modes (intent drift, hallucinations,
modality violations) and why monitoring alone doesn’t prevent them.
Would love feedback from people running LLMs in production.

value: Show HN: A policy enforcement layer for LLM outputs (why prompts weren't enough)