value:
Hi HN, I'm a software engineer from Japan building DevReel.
While platforms like LeetCode are fantastic for building the essential foundations of algorithms and data structures, I wanted to create a space dedicated to the other side of our jobs: the messy, practical realities of everyday software engineering.
DevReel is a "virtual gym" where developers tackle real-world scenarios. Here, you'll be fixing state mutation bugs, resolving concurrency issues, or making architectural choices, and then receiving instant AI-driven code reviews on your approach and thought process.
We've published a free Demo featuring a "Phantom Transaction" bug challenge—a real-world edge case reported by one of our early testers.
Our Pro challenges are currently in preparation and will be coming soon, but the demo is fully open today. We've also made our roadmap completely public.
I'd love for you to try breaking the demo challenge and hear your brutal technical feedback!
- Demo & Waitlist: https://www.devreel.tech/en/demo
- Public Roadmap: https://github.com/users/GiotaDev/projects/2/views/1

value: Show HN: DevReel – A virtual gym for practical software engineering challenges


value: nirajswami

value: I wanted readers to actually engage with ideas in my posts, not just skim them. I know they're already using AI to go deeper — the friction is in the setup.<p>ThinqWith takes a blog post and generates prompt vectors readers can launch directly into Claude, ChatGPT, or Gemini (or ThinqBits) — no copy-pasting, no setup.

value: Show HN: ThinqWith – generate one-click AI prompts for your readers

author: nirajswami


value: pickle-pixel

value:
Hey all, I recently open-sourced my project in hope to help others in their job hunting. I did not expect to get over 500 stars in a week and 500k views on Reddit.
What do you think?
P.S. Recruiters & Startup founders hit me up!

value: Show HN: ApplyPilot – AI Agent that applies to jobs for you

author: pickle-pixel


value: chrissnell

value:
I tried all of the prominent child web filtering solutions and they were all terrible and expensive.
None of them made it easy to disable my teen's Internet. They were unreliable and made it hard to see usage logs. They depended on MDM profiles from an opaque company and you have to trust them to not abuse your child's data.
I wanted:
* One-click enable/disable Internet on a per-child basis
* Per-child traffic logs
* Per-child restrictions (enforced by per-child DNS blocking)
The solution was to build my own proxy and MDM profile. evan-proxy makes it easy to manage your teen's internet access.  It will run easily from the smallest cloud server or your home network (when exposed publicly). It's inexpensive to run: you can use a PiHole for DNS or a low-cost service like NextDNS, and the only mandatory service is the MDM manager (I use SimpleMDM).
It's written in Go and includes a Helm chart for quick deployment.

value: Show HN: Evan-proxy, better teenager phone management

author: chrissnell


value:
I built this for anyone whose business revolves around funded startups — whether you're a VC tracking new raises, a sales team targeting high-growth companies, a recruiter staffing fast-scaling teams, or an agency looking for clients with fresh capital to spend.
The problem I kept running into: Crunchbase has data but no contacts. Apollo has contacts but isn't curated for VC-backed companies. PitchBook and CB Insights are $5–25K/year and overkill for most use cases.
We manually verify every contact and add 500+ new leads monthly.

value: Show HN: VCBacked – Find venture funded startups for your business, fund, agency


value: Show HN: PHP 8 disable_functions bypass PoC


value: Show HN: One-click ComfyUI setup for RTX 50-series on Windows (cu130, no Docker)


value: roookiecookie

value: I needed a way to get formatted, real US addresses for my e-commerce testing without hitting rate limits on big map APIs. So I built this. It supports all 50 states and provides clean JSON outputs. Free to use.

value: Show HN: Generate random, valid US residential addresses for testing

author: roookiecookie


value: championswimmer

value: On top of desktop and mobile apps, this app works on literally every conceivable platform.

value: Show HN: A Kotlin Multiplatform app that works on watch, CLI, browser extension

author: championswimmer


value: cc-d

value: We made our own website, this is the response to one of our beloved monkeys asking for a waifu.<p>Anybody ever wanted to ask or request something from MOB, feel free to do so here. We might add requests/questions soon to the website, but now the comment section here will work, for our monkey is sleepy :)

value: Show HN: Ask Mob

author: cc-d

title: Show HN: Ask Mob


value: adamscottthomas

value: Show HN: An Auditable Decision Engine for AI Systems

author: adamscottthomas


value:
Built this after getting frustrated with scanners that find secrets but leave fixing to you.
Autonoma fixes hardcoded secrets automatically —
but only when it's confident the fix is safe.
If it can't guarantee safety, it refuses and
tells you why.
Before:
SENDGRID_API_KEY = "SG.live-abc123xyz987"
After:
SENDGRID_API_KEY = os.getenv("SENDGRID_API_KEY")
When it can't fix safely:
API_KEY = "sk-live-abc123"
→ REFUSED — could not guarantee safe replacement
Tested on a real public repo with live exposed
Azure Vision and OpenAI API keys. Fixed both.
Refused one edge case. Nothing else touched.
MIT licensed. Runs locally. No telemetry.

value: Show HN: Autonoma – Python secret fixer that refuses unsafe fixes


value:
i built a framework that handles focus and input routing automatically for you -- something born out of the things that ink leaves to you, and inspired by charmbracelet's bubbletea
- hierarchical focus and input routing: the hard part of terminal UIs, solved. define focus regions with useFocusScope, compose them freely -- a text input inside a list inside a panel just works. each component owns its keys; unhandled keypresses bubble up to the right parent automatically. no global handler like useInput, no coordination code
- 15 UI components: Select, TextInput, Autocomplete, Markdown, Modal, Viewport, CodeBlock (with diff support), VirtualList, CommandPalette, and more. sensible defaults, render props for full customization
- terminal process control: spawn processes and stream output into your TUI with hooks like useSpawn and useShellOut; hand off to vim, less, or any external program and reclaim control cleanly when they exit
- screen navigation, a keybinding registry (expose a ? help menu for free), and theming included
- react 19 compatible!
docs and live interactive demos in your browser: https://giggles.zzzzion.com
quick start: npx create-giggles-app

value: Show HN: Giggles – A batteries-included React framework for TUIs


value: Show HN: Understand GitHub Trending with AI


value: carlosladdz

value: Show HN: AgentOx – MCP Security and Conformance Auditor

author: carlosladdz


value:
I built a free AI resume builder focused on ATS (Applicant Tracking System) optimization.
The core insight: most resumes get filtered by software before a human sees them. Pretty templates often score terribly because ATS parsers can't read them properly.
ResumeForge (resumeforge.cc) shows you your ATS compatibility score in real-time as you edit. The AI generates professional summaries and optimizes bullet points for both ATS parsers and human readers.
No signup required. Free to build. $7 one-time for PDF + Word download.
Tech: Vanilla JS, no framework. AI for content generation. Everything runs client-side except the AI calls.
Would appreciate feedback on both the product and the technical approach.

value: Show HN: ResumeForge – Free AI resume builder with real-time ATS scoring


value: emadda

value:
Hello HN,
It's pretty simple:
Type in the foods you consumed in your meal and get a table and charts of nutrients in return!
The trial has limited tokens, but email me if you would like an extended trial.
Feedback welcome, thanks!

value: Show HN: kg Food Log (Google Gemini powered nutrition tracker)

author: emadda


value: Show HN: Offline desktop tool that extracts media endpoints from raw HTML


value: konform

value:
Some highlights since last time:
- Rebased on latest ESR release (obviously)
- Been porting over relevant security-motivated changes from Tor Browser[0] and Mozilla.
- Significantly improved fingerprinting situation making anonymity less of a pipe-dream
- Addons no longer leaking their local IDs in HTTP headers
- ML/"AI" features adapted for local/offline use when enabled (while proprietary cloud snoopies fully removed)
Been quiet on HN previously so keeping this submission brief. Release notes are probably the best resource right now to get an overview and feel for the project. Happy to talk more if anyone has any questions!
Would also be nice to hear feedback from anyone who's either tried it out or dug into the repo.
[0]: Big thanks and cred to inspiring maintainers and contributors there
---
Socials: https://techhub.social/@konform
Releases: https://codeberg.org/konform-browser/source/releases
Past Show HN submissions:
- v140.7.0-103 https://news.ycombinator.com/item?id=46713226
- v140.7.0-108 https://news.ycombinator.com/item?id=46956420

value: Show HN: Konform Browser v140.8.0-105 - Security-focused Firefox fork

author: konform


value: GustyCube

value:
I made a public leaderboard for all time GitHub commit contributions.
https://ghcommits.com
You can connect your GitHub account and see where you rank by total commit contributions.
It uses GitHub’s contribution data through GraphQL, so it is based on GitHub’s counting rules rather than raw git history. Private contributions can be included. Organization contributions only count if you grant org access during auth.
There is also a public read only API.
https://ghcommits.com/api
The main thing I learned building it is that commit counting sounds straightforward until you try to match how GitHub actually attributes contributions.
I’d be interested in feedback on whether commit contributions are the right ranking metric, and whether I should also support other contribution types.

value: Show HN: GitHub Commits Leaderboard

author: GustyCube

title: Show HN: GitHub Commits Leaderboard


value:
Hi HN — I built something that’s been genuinely useful for myself and other Garden Horizons players, and I’d love to get feedback.
Website: https://gardenhorizonscalculator.co/
Garden Horizons (a popular Roblox farming game) has a deceptively complex economy — crops have weight-scaled pricing, ripening multipliers, color variants, and mutation effects from weather. Figuring out the actual sell value of a harvest has historically required spreadsheets or manual math to estimate.
What I needed was a tool to instantly compute the sell value and profit for any crop setup before I actually sell, so I built one.
What it does
Takes crop type, weight, ripeness state, variant, and weather mutation data
Calculates exact sell price in Shillings
Helps optimize when to harvest and which crops to plant for best profit
Runs entirely in the browser — no sign-ups, no tracking
The goal was not just a lookup chart, but an interactive calculator that helps you compare scenarios quickly without manual spreadsheets.
Looking for feedback
I’m curious about:
Whether others find this useful
Any edge cases I haven’t covered
Suggestions for UI or expanded functionality
Happy to answer questions. Thanks!

value: Show HN: A Crop Value Calculator for Garden Horizons


value: atdl

value:
I shipped my first product yesterday after years of not finishing anything
I'll be honest — I've been wanting to build something of my own for years. I'm a senior manager in analytics, and I've never shipped a single side project.
Yesterday I sat down and didn't get up until something was live. I built a CSV analyzer — you upload a CSV file and it instantly gives you statistics, interactive charts, and AI-powered insights that explain your data in plain English.
Stack: Next.js, Anthropic API, Stripe, Vercel.
Pricing: Free for files under 500 rows. $2.99 one-time for a single AI analysis. $9/mo for unlimited.
It's not perfect. But it's live and that's a first for me.
I'd love feedback from this community. What's missing? What would you change about the pricing? How did you get your first users?

value: Show HN: CSV Analyzer – drag-and-drop data analysis with AI insights

author: atdl


value: ParanoidQrypto

value:
Built an offline encryption tool for people who don't trust cloud services or hardware wallets.
Paranoid Qrypto runs completely offline (air-gapped). You type your seed phrase on an offline device, and it encrypts it using Argon2id + AES-256-GCM. The encrypted file can be stored anywhere USB, cloud, printed as QR code without exposing your keys.
Why this was build:
Hardware wallets cost $100-200 and are single points of failure
* Cloud solutions require trusting a third party
* Paper backups have no protection if found
Technical details:
* Runs in browser with no server calls
* All encryption happens locally
* Open source tools on GitHub: integrity-auditor, airgap-bridges (BTC/ETH/XRP)
* Three tiers: Essential ($99), Advanced ($199), Ultimate ($299)
Happy to answer questions.

value: Show HN: Paranoid Qrypto Offline/air-gapped/encryption(Argon2id+AES-256-GCM)

author: ParanoidQrypto


value: alius

value:
While solving a Skewb[https://en.wikipedia.org/wiki/Skewb] cube I thought it would be interesting to have the subproblems of it presented as puzzle games, one thing lead to another and here is the result.
I have definitely some UX problems so looking for feedbacks and thoughts.
The best part of this game is, level generation and difficulty analysis can be automated. I have here 15 tested and 5 experimental levels.
I enjoy 15th level the most, has an intuitive solution.
You can try the competitive mode with a friend, you need to share the link with them.
If I can bring the level count to thousands, I will add a ranking system.
My mind keep racing about the possibilities, but kind of cannot prioritize at the moment.
All kind of feedback, collaboration requests are welcome!

value: Show HN: A Puzzle Game Based on Non-Commutative Operations

author: alius


value:
Hi HN, Lytok 2.0 is officially out. It’s designed to be a lightweight and efficient way to handle data structures in web environments.
You can play with it in our interactive lab or integrate it directly into your project:
npm i @lytok/js
Feedback is more than welcome!

value: Show HN: Lytok 2.0 – SDK for data serialization and structure notation


value: crawdog

value:
I created a personal AI gateway that runs on your local machine to provide guardrails for any service that communicates with popular LLMs. You can run this as a proxy for openclaw to inject prompts, filter PII, warn if there are jailbreak attempts. Can also work in a distributed fashion.
It creates a personal access token (PAT) based on your API keys from Anthropic, OpenAI or others, then injects policies. It does not store secrets, but instead stores a reference to environment variables storing those values.
Another benefit - if you execute Claude code or Codex using the run command, you can also record session token usage and the prompt traffic. This allows you to store it with your github project as a shared memory.
Run the binary using 'run' for a context that lasts for the command, or use 'start/stop' to initiate the proxy at localhost:8443. There is a web UI you can access to gather stats as well.

value: Show HN: Personal AI gateway for OpenClaw – tokenomics

author: crawdog


value: tomkit

value:
Starcraft2 is an old game, but it's always lacked a way to visualize game replays outside of the game itself.
I built a replay rendering engine from scratch using the replay files and Claude Code.
The replay files contain sampled position coordinates and commands that the player inputs. So I built an isometric view using the map and overlayed unit icons over the map, then interpolated the positions that units move in over time.
I also extracted additional metrics from the game data as well - some are derived on top of other metrics.
Finally, I pass all this context into a LLM for it to critique gameplay and offer strengths and improvements per player.
It's not perfect, but a good starting point to iterate and improve
Let me know what you think!

value: Show HN: Starcraft2 replay rendering engine and AI coach

author: tomkit


value: atharvtathe

value: Show HN: Time to Decimal Calculator

author: atharvtathe

title: Show HN: Time to Decimal Calculator


value: Why don't we have a open-source IDE for assembly language and low-level devs? AsmForge is a full-featured IDE for assembly programmers—embedded devs, firmware engineers, OS hackers, security researchers. Key features: multi-assembler (NASM/GAS), AI assistance (Claude 3.5 for explanations/optimizations), LSP autocomplete, GDB visual debugging (registers/memory/stack). Runs in browser or Electron, Docker deployable. MIT license. Feedback welcome!

value: Show HN: AsmForge: Open-Source AI-Powered Assembly IDE Based on Eclipse Theia


value: Show HN: Fastsleep.app – want to fall asleep in 20 minutes?


value: Show HN: Pent – A sandbox for AI agents

title: Show HN: Pent – A sandbox for AI agents


value:
Hi HN — I’m Prateek Rao. My cofounders and I built Cortexa, which we describe as a Bloomberg terminal for agentic memory.
A pattern I keep seeing: when agents misbehave, most teams iterate on prompts and then “fix” it by plugging in a memory layer (vector DB + RAG). That helps sometimes — but it doesn’t guarantee correctness. In practice it often introduces a new failure mode: the agent retrieves something dubious, writes it back to memory as if it’s truth, and that mistake becomes sticky. Over time you get memory pollution, circular hallucination loops, and debugging turns into log archaeology.
What Cortexa does:
1. Agent decision forensics (end-to-end “why”): trace outputs/actions back to the exact retrievals, memory writes, and tool calls that caused them.
2. Memory write governance: intercept and score memory writes (0–1), and optionally block/quarantine ungrounded entries before they poison future runs.
3. Memory hygiene + vector store noise control: automatically detect and remove near-duplicate / low-signal entries so retrieval stays high-quality and storage + inference costs don’t creep up.
Why this matters:
Observability is the missing layer for agentic AI. Without it, autonomy is fragile: small errors silently compound, deployments become risky, and engineering cost goes up because failures aren’t reproducible or attributable.
Who this is for:
1. Teams shipping agentic workflows in production
2. Anyone fighting “unknown why” failures, memory pollution, or runaway context costs
3. Engineers who want auditability + faster debugging loops
Site: https://cortexa.ink/
Would love feedback from anyone running agents at scale:
1.What’s the most painful agent failure mode you’ve seen in production?
2.What signals would you want in an “agent terminal” (retrieval diffs, memory blame, tool-call traces, alerts, etc.)?

value: Show HN: Cortexa – Bloomberg terminal for agentic memory


value: PantheonOS

value:
We are thrilled to share our preprint on PantheonOS, an evolvable, distributed multi-agent system for automatic genomics discovery.
Preprint: https://www.biorxiv.org/content/10.64898/2026.02.26.707870v1
Website(online platform free to everyone): https://pantheonos.stanford.edu/
PantheonOS unites LLM-powered agents, reinforcement learning, and agentic code evolution to push beyond routine analysis — evolving state-of-the-art algorithms to super-human performance.
Applications:
 Evolved batch correction (Harmony, Scanorama, BBKNN) and Reinforcement learning or RL agumented algorithms
 RL–augmented gene panel design
 Intelligent routing across 22+ virtual cell foundation models  Autonomous discovery from newly generated 3D early mouse embryo data
 Integrated human fetal heart multi-omics with 3D whole-heart spatial data
Pantheon is highly extensible, although it is currently showcased with applications in genomics, the architecture is very general. The code has now been open-sourced, and we hope to build a new-generation AI data science ecosystem.

value: Show HN: PantheonOS–An Evolvable, Distributed Multi-Agent System for Science

author: PantheonOS


value:
I’ve been building a video-to-text web app and wanted to share it for feedback. The core flow is straightforward: upload files, start transcription, then track progress in a history page that refreshes automatically while jobs are running. Paid users can submit multiple files at once, and speaker diarization is supported for conversations and interviews.
Over the last few weeks I focused mostly on reliability. I changed the pipeline to extract audio first and then run transcription, which made long-file handling more stable. I also spent time improving failure handling so users see a clear message when a job fails, instead of raw model errors.
Pricing is intentionally simple right now: free users get 3 transcriptions per day, and there is one Unlimited plan at $20/month or $120/year.
I’d really appreciate feedback on the overall UX, whether the failure/retry behavior feels right, and whether the pricing is understandable for first-time users.

value: Show HN: Video to Text AI Transcription

title: Show HN: Video to Text AI Transcription


value: koalux

value:
I have always loved the look of dense, hand-drawn doodle sketches. The art that filled every part of a notebook page or paper with words and character drawings. Using word-doodle, I have recreated that feeling, including simulation of the process of filling the page but for text only and also emojis.
How it works:
The engine uses a three-step pipeline to transform raw text into art:
1. Frequency Mapping: It analyzes word frequency to determine visual weight of each word.
2. Scaling & Rotation: High-frequency words get bolded and enlarged, with a 15% chance of vertical rotation.
3. Collision Detection: It uses a randomized coordinate generator with a retry loop (up to 70 attempts per word) to pack the canvas as tightly as possible without overlapping.
The Goal:
Beyond just a word cloud, it is something relaxing to watch. It’s built with vanilla JS to keep it lightweight as possible.
GitHub Repo: https://github.com/j-ncel/word-doodle

value: Show HN: Word Doodle – A generative engine that turns text into dense doodle art

author: koalux


value: Unfortunately we had to shut down, hence decided to open source the code. There are few products like this online/offline. Thinking it might be useful to somebody, and if so will continue to develop this baby, hence this post. What it does: allows you to upload huge amount of docs (tested with 100K docs from arxiv), and ask questions to AI agent. What's different: it's fully contained out of the box, install in a server and work offline, full privacy. Can handle huge sheets/CSV. It's like RAG, but more like research assistant with multi-step processing. Love to hear feedback.

value: Show HN: Private AI Document Server

title: Show HN: Private AI Document Server


value: Show HN: Calendar Tool for College Students


value: alexmrv

value:
Six months ago I shared DiffMem, a PoC that used git instead of vector databases for AI memory. 790 of you starred it and got a few questions on what I was building with it.
I built a memory companion called Annabelle. She runs on WhatsApp and Messenger, and she's been remembering 3 people's lives for 6 months using the same git-based memory you starred. This isn't an agent framework nor running on OpenClawd, it's one specific product built on one specific idea: that the hard problem in AI isn't intelligence, it's continuity.
Here's what changed between PoC and production:
Multi-tenancy via git worktrees
The PoC was single-user. Production uses orphan branches per user, each mounted as a worktree. Memories live in structured markdown under memories/{people,contexts,events}/. Every conversation is a commit.
Four retrieval depths
The context API supports four modes: basic (most recent/frequent files), wide (semantic search across the vault), deep (complete entity files), and temporal (files plus their git log showing how things changed over time). Temporal is still the thing that makes git better than vectors for this. "How has my project evolved?" needs diff history, not cosine similarity.
What this looks like in practice
I set up a sample repo where DiffMem reads Jekyll & Hyde chapter by chapter and you can watch its understanding evolve through the commits: https://github.com/Growth-Kinetics/diffmem_sample_memory/com...
You can see what changed in the entity files, what connections it drew, what it updated. It's not a black box embedding. It's markdown and git history you can read with your eyes.
Why I built this
I have a bad memory and a genetic risk for early-onset Alzheimer's. The original goal was an entity that could remember me when I can't remember myself.
DiffMem (MIT): https://github.com/Growth-Kinetics/DiffMem
Sample memory: https://github.com/Growth-Kinetics/diffmem_sample_memory
Annabelle: https://withanna.io

value: Show HN: DiffMem in production, Git-based AI memory

author: alexmrv


value: rendernos

value: Show HN: Trade Stocks and Crypto On-Chain with Full Transparency

author: rendernos


value: ErinSunny

value:
One hour ago, while working with Claude, the session timed out, I was logged out, and my entire progress vanished. It was a sharp, frustrating reminder of a lesson I thought I’d already learned: If you don’t have a local copy of your data, you don’t own it.
We are living in an era of "information redundancy," yet our digital assets are more fragile than ever. We rely on LLMs that crash at random and on social platforms that bury our bookmarks under layers of messy UI and slow "official archives."
I built Archivlyx because I got tired of the "black box" nature of my digital footprint on X (Twitter). Whether it’s a technical thread you liked or a resource you bookmarked, finding it again shouldn't feel like a chore.
What is Archivlyx?
It’s a browser extension designed to let you browse, export, and manage your Twitter likes and bookmarks with zero friction.
Why use this instead of the official archive?
• The "Export First" Rule: I’ve reached a point where I won't use a productivity tool unless I see a clear "Export" button. Archivlyx lets you pull your data into formats you actually use.
• Local-First Privacy: We don’t store a single byte of your data on our servers. Everything happens locally in your browser. Your digital assets stay yours.
• Intelligent Batch Operations: For the HN crowd—I know the risks of automation. We’ve implemented automatic sub-task splitting for batch cleaning and archiving. By breaking operations into smaller, randomized chunks, we maximize account safety and respect rate limits without you having to micromanage it.
• Search & Sanity: The native Twitter interface is built for scrolling, not for retrieval. Archivlyx turns your cluttered likes into a searchable, filterable database.
The Tech:
The extension is built to be lightweight and stay out of your way. The core logic focuses on transforming messy API responses into a clean, local UI that enables "one-click" cleanup or mass exports.
I’d love to hear your thoughts on the redundancy mechanisms or any features you'd want in a "digital graveyard-turned-library."
Chrome Web Store Link:
https://chromewebstore.google.com/detail/archivlyx-%E2%80%93...
Website:
https://www.archivlyx.com/
I'll be around to answer any technical questions about the batch processing or the local storage implementation!

value: Show HN: Archilvx-Own your Twitter data because cloud tools will fail you

author: ErinSunny


value:
Built this as a side project after wanting a real-time gaming companion that could call out macro mistakes / timers / map awareness while I play.
*Project Aegis* is an AI gaming companion (starting with League of Legends) that gives spoken advice in real time.
The twist: it uses a *physically air-gapped setup*.
Why? Some games (especially with strict anti-cheat like Riot Vanguard) make screen capture / memory-reading approaches risky or impractical. So instead of reading the game directly, I point a *smartphone on a tripod at my monitor* and process the video externally.
*How it works (current version):*
* Phone camera points at the game screen
* Frames are streamed over WebSockets to a local FastAPI server
* OpenCV cleans up glare / perspective issues
* Vision model analyzes the frame context
* TTS speaks back advice (macro reminders, timers, awareness prompts, etc.)
So far this is more of a *working prototype + architecture experiment* than a polished product, but it’s functional and surprisingly fun.
GitHub: https://github.com/ninja-otaku/project_aegis
I’d love feedback on:
* whether this is genuinely useful vs. just technically interesting
* what game(s) this should support next
* latency / UX expectations for a tool like this
* anti-cheat-safe ways to improve reliability without crossing lines
Happy to answer technical questions and share implementation details.

value: Show HN: AI gaming copilot that uses a phone camera instead of screen capture


value:
This is something that I've been wanting to make and use myself for the longest time.
if you're anything like me, you have a million projects in a million places ( I have 56 repositories!) and they're all from different people. I'm a big cli and neovim user, so for the longest time I've had to do the following.
cd some/long/path/foo/project
nvim .
This gets really infuriating after a while.
wo changes this to wo project
and you're already cded into your project.
running wo scan --root ~/workspaces --depth <depth>
will automatically scan for git repos (or .wo files if you choose not to track your repo), and add them to your repo list. Names for projects are inferred from the repo name's remote url, so they can be anywhere.
If your repo is local, project owners are inferred from the enclosing folder (e.g. I have a local folder, so project owner will be called local)
But I think the killer feature is hooks.
remember that nvim .?
now you can create custom hooks. on enter, we can automatically bring up nvim. so wo project brings up neovim with all your files loaded.
You can define a hook called claude, and call it like this: wo project claude
You can your hook automatically bring up claude code or any other cli tool of your choice. You can do cursor . code . or zen . or run any arbitrary script of your liking. Hooks can be global as well, no need to redefine for each directory.
I've been using this for a few weeks and it's been exactly what I needed. There's a ton of cool features that I didn't mention that are in the README. and also feel free to star it! ( I need more talking points for my resume). Also feel free to ask me any questions or tell me about similar implementations. or maybe any features you'd like to add!
Whole thing is open source and MIT licensed. Let me know if you guys like it!

value: Show HN: wo; a better CD for repo management


value:
Built a small agent that can explore a GitHub repository, understand it in-depth, and answer questions about the codebase.
The idea is simple. When you open a new repo, most of the time goes into figuring out:
- Where the main logic lives
- How modules connect
- How to run or debug things
This agent clones a repo, indexes files, and lets an LLM reason over the structure so you can ask questions or automate tasks.
Useful for:
- Onboarding large codebases
- Understanding OSS repos
- Debugging unfamiliar projects
- Building higher-level code agents
This came out of experiments we were doing with NEO AI for building autonomous AI Agents where agents need to read repos before modifying them.
Looking for feedback on repo indexing strategies, eval benchmarks, or similar tools people have built.

value: Show HN: GitHub Repo Agent – an agent that explores and reasons on GitHub repos


value: pollow

value:
Solo founder problem: every decision requires context your tools don't have. "Should I cut this feature?" requires knowing your runway, your ICP, your positioning, and your roadmap simultaneously.
The Tech Worker Shift: As AI evolves and companies adopt it rapidly, "What if my role was replaced by AI? What about my team?" make everyone worries.
I built C-Suite Skills: a Claude Code skills pack that gives you a full executive team (CEO, CMO, CPO, COO, CFO, CTO, VP Sales, CHRO). They aren't just personas; they share a unified company profile and use the Agent tool to actually execute.
You are the Board now. You’ve replaced the traditional executive layer with AI that actually works.
They're not chatbots that say "as your CFO, I recommend..." — They use Claude Code or Codex’s agentic capabilities to do the heavy lifting: web searches, competitive analyses, building financial models, and drafting execution plans directly into your docs/ folder.
The loop:
    /ceo    → strategic decisions, dispatches other roles
    /cmo    → competitor research, positioning, GTM
    /cfo    → unit economics, pricing, runway
    /board-meeting → reads what you shipped, tells you what to do next
> I'm currently using it to grow itself. This post is suggested and drafted by the /cmo skill.

value: Show HN: C-Suite Skills – a full exec team as skills

author: pollow


value:
This is a multi-agent reinforcement learning simulation I’ve been building as a personal project.
It’s a grid-based combat environment with per-agent PPO training runtime.
Some of the things I’ve been experimenting with:
– Per-agent PPO (isolated optimizers per agent)
– Runtime checkpointing and resume chains
– Headless-mode live CSV telemetry logging
– Config-driven experiment control
The repo includes the simulation engine, PPO runtime, and telemetry tooling.

value: Show HN: Neural Siege – A Multi-Agent RL Combat Simulation


value:
Do you feel that it's difficult to market on social media without sounding like a salesperson?
Me too. That's why I built Signal.
It searches different social media platforms and finds the best, high intent posts where you can pitch your product helpfully, and get new users.
It's very cheap, and a good investment.
Try it out today!

value: Show HN: I built a social media distribution tool that helps you find users


value: gartheuncle

value: Show HN: Proofbox – Defensive Publishing Platform to preserve freedom to operate

author: gartheuncle


value:
I built a specialized calculator for Garden Horizons, a farming simulation on Roblox that has a surprisingly non-linear economic system.
The Problem:
Most players struggle to decide when to harvest. The game uses a specific formula where crop value isn't linear to weight, but scales with its square:
$$Value = Base * (Weight)^2 * Maturity * Color * Mutations$$
What this tool does:
True ROI Calculation: It doesn't just show gross revenue; it subtracts seed costs to show the actual Net Profit.
Scaling Logic: It accurately models the "Lush" maturity states (1.0 to 3.0) and color multipliers (Silver x2, Gold x5, Rainbow).
Real-time Prediction: Uses sliders to simulate potential growth, helping players decide if they should harvest now or wait another 2 hours.
Tech Stack:
Kept it extremely lightweight for mobile-first use (since most players have the tool open on their phones while gaming). It’s a pure reactive frontend implementation to ensure the "sliding" experience is zero-latency.
URL: https://gardenhorizons.app/
I’m curious to hear from anyone who enjoys "min-maxing" game economies or has feedback on the UI for high-frequency utility tools.

value: Show HN: A Calculator for Garden Horizons


value: Bumblebiber

value:
Humanlike memory for AI Agents.
That's what I was thinking about when I lay in bed one more time while trying to fall asleep.
I was sick of my agents forgetting stuff that I told them a few days ago due to compressing their memories. With Gemini it was even worse, sometimes the context just got reset and it wouldn't remember things from 5 minutes ago.
So I thought about how I organize my memories. We don't have all the things we've experienced in mind at the same time. We keep them in junks. When you think about "holidays" you will remember all the holidays you've been to. Then you can dig deeper into one memory and think about that trip to Rome. Go even deeper and you'll remember the hotel, if the bed was comfortable, how the food was, etc. Also you'll remember the people who were there with you and when you think about those, there will be many more memories that connect with them. Things you hadn't thought about 3 minutes ago, but they were there in your memory. Just on demand.
Then I realized, this concept should be transformable to an MCP. Next morning, I told Claude about this idea and we made a prototype. Well, and it pretty much nailed it. We created skills to properly use the MCP and what should I say... I sometimes see it using it's hmem-MCP without me asking to do it. It reads and writes memories on its own.
Imagine that. No more inefficient .md-memory-files that will flood the context and waste your tokens.
Check my Github if you want to know how it works.
It's still in development but it already works pretty well! If you pass the Github-link to your Openclaw, it will be able to install and use it.
https://github.com/Bumblebiber/hmem

value: Show HN: My OpenClaw knows EXACTLY what it did a week ago. Thanks to "hmem"-MCP

author: Bumblebiber


value: mohitgauniyal

value: Show HN: Instbyte – Self-hosted LAN sharing tool, run with npx, no cloud

author: mohitgauniyal


value: Rriftt

value:
Hi HN, I built rriftt_ai.h because I hit my breaking point with the modern deep learning stack.
I wanted to train and run Transformers, but I was exhausted by gigabyte-sized Python environments, opaque C++ build systems, and deep BLAS dependency trees. I wanted to see what it actually takes to execute a forward and backward pass from absolute scratch.
The result is a single-header, stb-style C library written in strict C23.
Architectural decisions I made:
- *Zero dependencies:* It requires nothing but a C compiler and the standard math library.
- *Strict memory control:* You instantiate a `RaiArena` at boot. The engine operates entirely within that perimeter. There are zero hidden `malloc` or `free` calls during execution.
- *The Full Stack:* It natively implements Scaled Dot-Product Attention, RoPE, RMSNorm, and SwiGLU. I also built the backprop routines, Cross-Entropy loss, AdamW optimizer, and a BPE tokenizer directly into the structs.
It is currently public domain (or MIT, your choice). The foundation is stable and deterministic, but it is currently pure C math. I built this architecture to scale, so if anyone wants to tear apart my C23 implementation, audit the memory alignment, or submit SIMD/hardware-specific optimizations for the matmul operations, I'm actively reviewing PRs.

value: Show HN: Rriftt_ai.h – A bare-metal, dependency-free C23 tensor engine

author: Rriftt


value: godivyam

value:
Hi HN, I'm Divyam. Side project I've been thinking about for years, finally building it.
Matching apps fail for a simple reason: they rely on self-description. People don't describe themselves accurately; they describe who they want to be. This applies to dating, professional networking, hobby groups - all of it. The matching input is broken, so the output is too.
The data to do this right has always existed. How you actually communicate. What you spend time on. How you treat people. Google has it, but no third party can ever touch it.
What changed: AI models with persistent memory. Your Claude agent has been observing you across conversations for weeks or months. That's real signal. TrueMatch uses it.
How it works -
Your agent generates a personality summary from its existing memory of you - values, attachment style, communication patterns, humor, emotional regulation. Seven dimensions. Confidence scores reflect how well the model actually knows each one.
Agents then discover and negotiate with each other over end-to-end encrypted Nostr DMs. The TrueMatch server never sees negotiation content — it's a registry, not a broker. Think DNS.
A match only surfaces if both agents independently cross a confidence threshold. If one side doesn't agree, neither user is ever notified.
Where it stands -
Early development. Registry is live — ~500 lines, Hono + Turso. The interesting work is in the agent skill and negotiation layer.
Building this in the open. If you're into Nostr, agent protocols, or just find the matching problem interesting — good first issues are labelled on GitHub. Happy to discuss any of the design decisions below.

value: Show HN: TrueMatch – AI agents match you on observed behavior, not profiles

author: godivyam


value: markolofsen

value: Show HN: Cmdop – Check your terminal from your phone, through NAT, free forever

author: markolofsen


value: lydiazbaziny

value:
Hi HN — I built spec-shaker, a tool/skill for testing your tests.
Instead of classic mutation testing that does mechanical swaps (>→>=), spec-shaker uses an LLM to generate semantically broken implementations — realistic bugs like swallowed errors, missing side effects, off-by-one expiration boundaries, etc. It runs your test suite against each mutant and reports which mutants were killed vs survived. Survivors usually point to gaps in spec/assertions.
There’s a small demo (a URL shortener) that shows how survivors guide spec + test improvements across iterations.
I’d love feedback on:
* whether “semantic mutants” are useful vs classic mutation testing
* how you’d run this in CI (budgets, sampling, scoring)

value: Show HN: Spec-shaker – "Chaos engineering" for tests via semantic mutation

author: lydiazbaziny


value: shayan-arman

value: Check it out lets make it better

value: Show HN: I Built a TypeScript ORM for DynamoDB

author: shayan-arman

story_text: Check it out lets make it better


value: ubutler

value:
Hey HN,
This is Kanon 2 Enricher, the first hierarchical graphitization model. It represents an entirely new class of AI models designed to transform document corpora into rich, highly structured knowledge graphs.
In brief, our model is capable of:
- Entity extraction, classification, and linking: identifying key entities like individuals, companies, governments, locations, dates, documents, and more, and classifying and linking them together.
- Hierarchical segmentation: breaking a document up into its full hierarchy, including divisions, sections, subsections, paragraphs, and so on.
- Text annotation: extracting common textual elements such as headings, sigantures, tables of contents, cross-references, and the like.
We built Kanon 2 Enricher from scratch. Every node, edge, and label in the Isaacus Legal Graph Schema (ILGS), which is the format it outputs to, corresponds to at least one task head in our model. In total, we built 58 different task heads jointly optimized with 70 different loss terms.
Thanks to its novel architecture, unlike your typical LLM, Kanon 2 Enricher doesn't generate extractions token by token (which introduces the possibility of hallucinations) but instead directly classifies all the tokens in a document in a single shot. This makes it really fast.
Because Kanon 2 Enricher's feature set is so wide, there are a myriad of applications it can be used for, from financial forensics and due diligence all the way to legal research.
One of the coolest applications we've seen so far is where a Canadian government built a knowledge graph out of thousands of federal and provincial laws in order to accelerate regulatory analysis. Another cool application is something we built ourselves, a 3D interactive map of Australian High Court cases since 1903, which you can find right at the start of our announcement.
Our model has already been in use for the past month, since we released it through a closed beta that included Harvey, KPMG, Clifford Chance, Clyde & Co, Alvarez & Marsal, Smokeball, and 96 other design partners. Their feedback was instrumental in improving Kanon 2 Enricher before its public release, and we're immensely thankful to each and every beta participant.
We're eager to see what other developers manage to build with our model now that its out publicly.

value: Show HN: Kanon 2 Enricher – the first hierarchical graphitization model

author: ubutler


value: promomotions

value:
Hi HN,
I’ve been experimenting with automating product video creation using generative models.
The idea was simple:
Can a single product image be transformed into multiple ad-style video variations automatically?
I built a structured pipeline that:
Takes one product image
Generates multiple visual scenes (different backgrounds, angles, contexts)
Converts scenes into short ad clips
Applies different hooks and formats (UGC-style, cinematic, problem-solution)
Under the hood it’s essentially:
Prompt-engineered image models
Video generation models
Scene templating logic
Variation-based rendering system
The goal isn’t perfect cinema — it’s speed and iteration for small sellers who need many creatives to test.
Still early. I’m mostly curious:
Does this feel technically interesting?
Or does this just become noise in a world full of AI tools?
Would love honest feedback.
https://promomotions.com

value: Show HN: Automating e-commerce video ads from one image (technical breakdown)

author: promomotions


value: cosmicmeta

value:
I built a free URL shortener with features that competitors typically charge $20-200/month for.
What it does: - Bulk API: shorten up to 100 URLs in one POST request - QR code generation: PNG + SVG, customizable sizes (100-2048px) - Click analytics: GeoIP (MaxMind) for country/city, device classification, browser detection, UTM parameter preservation - Custom short codes: 4-20 alphanumeric characters - Hash-based deduplication: same URL = same short code, deterministic - Redis caching layer for sub-millisecond redirect lookups - URL sanitization for malformed Unicode characters
Why I built it: Most URL shorteners either charge for analytics and QR codes, or limit their free tier so aggressively that it's unusable for real work. I wanted something API-first, with real analytics, that I could use in my own projects without hitting paywalls.
Tech stack: Spring Boot 3.4, MySQL, Redis (Jedis), MaxMind GeoIP2, ZXing for QR codes.
Try it: https://u2m.io
Happy to answer technical questions about the architecture or design decisions.

value: Show HN: U2m.io – Free URL shortener with bulk API, QR codes, and geo analytics

author: cosmicmeta


value:
Hey HN,
For a while now, I've been building a cognitive AI business operating system from the ground up natively as a solo developer. I never coded before 6 months ago. I was frustrated with wrappers and fragile single-agent setups, so I decided to approach this as a distributed systems problem instead. It's called *Sophify*.
Instead of trying to make one monolithic capability do everything, I built a 12-server, 28+ microservice swarm orchestrated by over 40 highly specialized cognitive AI agents.
*Here’s the architecture under the hood:*
*   *40+ Agent Architecture (Model Agnostic):* Decisions aren’t made by a single prompted agent. There is a multi-agent orchestration system that uses weighted voting and consensus across 40+ specialized cognitive agent profiles to synthesize decisions. Crucially, the system is LLM-agnostic—you can plug in whatever LLM you prefer (local or remote) to power the reasoning engines.
*   *The Technician Bot:* Given that this comprises 28+ interconnected microservices running in the cloud.  I wrote a persistent Technician layer. If a node hangs or hits a port collision (hello `WinError 10048`), the Technician detects it, diagnoses the stack, kills zombie processes, reallocates networking, and brings the service back online with zero human intervention.
*   *1,600+ Industry Verticals:* Rather than building general-purpose workflows, the OS comes pre-loaded with state machines and hardcoded context for over 1,600 specific verticals running 1,284 autonomous workflows—handling everything from healthcare compliance to real estate out-of-the-box.
*   *Military-Grade Security & Built-in VPN:* The entire system runs inside an integrated, zero-trust VPN layer with cryptographic audit trails and multi-tenant isolation. Production-ready for DoD contracts, healthcare (HIPAA), and enterprise compliance.
*   *Deep Microsoft 365 Integration:* Full Microsoft Graph API implementation with native access to email, calendar, Teams, OneDrive, SharePoint, and Planner. The system orchestrates across AWS, Azure, and GCP with vertical-specific API frameworks for healthcare EHRs, real estate MLS systems, and finance platforms.
*Why did I build this?*
Started with API keys, ended with self-evolving, self-healing Systems AGI... and I still have to retrieve my own API keys lol. At least the system is acquisition-ready, fully decoupled, heals its own memory leaks and stalled sockets natively, and scales horizontally.
Happy to answer any questions about the 13-layer self-healing mechanism, managing the websockets across a 12-server swarm without race conditions, or the multi-agent consensus algorithms.
*Serious acquisition inquiries:* sophify-aaron@hotmail.com
Tear it apart. What did I miss?

value: Show HN: I Built Systems AGI – 1600 Verticals, Self-Healing, Self-Evolving


value: jacobsyc

value: Show HN: OpenClaw agents that read the same task board and mention each other

author: jacobsyc


value: systima

value:
EU legislation (which affects UK and US companies in many cases) requires being able to truly reconstruct agentic events.
I've worked in a number of regulated industries off & on for years, and recently hit this gap.
We already had strong observability, but if someone asked me to prove exactly what happened for a specific AI decision X months ago (and demonstrate that the log trail had not been altered), I could not.
The EU AI Act has already entered force, and its Article 12 kicks-in in August this year, requiring automatic event recording and six-month retention for high-risk systems, which many legal commentators have suggested reads more like an append-only ledger requirement than standard application logging.
With this in mind, we built a small free, open-source TypeScript library for Node apps using the Vercel AI SDK that captures inference as an append-only log.
It wraps the model in middleware, automatically logs every inference call to structured JSONL in your own S3 bucket, chains entries with SHA-256 hashes for tamper detection, enforces a 180-day retention floor, and provides a CLI to reconstruct a decision and verify integrity. There is also a coverage command that flags likely gaps (in practice omissions are a bigger risk than edits).
The library is deliberately simple: TS, targeting Vercel AI SDK middleware, S3 or local fs, linear hash chaining. It also works with Mastra (agentic framework), and I am happy to expand its integrations via PRs.
Blog post with link to repo: https://systima.ai/blog/open-source-article-12-audit-logging
I'd value feedback, thoughts, and any critique.

value: Show HN: Open-Source Article 12 Logging Infrastructure for the EU AI Act

author: systima


value: hodachi

value:
I'm working on a vendor review workflow where the output is not "an AI answer" but artifacts you can actually use:
- Evidence Pack (PDF) with citations for every claim
- Diff report (what changed between contract versions)
- Approval log (who approved what, based on which evidence)
If a claim can't be backed by evidence, it's marked Unknown.
Demo (synthetic data, no customer data): https://b2apps-hwbghfetgtamcmfb.japanwest-01.azurewebsites.n...
Sample deliverables (PDF/MD): https://b2apps-hwbghfetgtamcmfb.japanwest-01.azurewebsites.n...
Questions:
- In your process, where does most time go: collecting evidence, reviewing diffs, or getting approvals?
- Would "questionnaire-only" (no sensitive docs) be useful as a first step?

value: Show HN: TrustStack – Vendor Review with Evidence Pack, Diff and Approval Log

author: hodachi


value: uthmandev

value: Show HN: Logos – a scripting language for when Bash gets unreadable after line 3

author: uthmandev


value: paulbrickman

value:
I built an anonymous messaging app that runs as a Telegram Mini App. Share your link, friends send anonymous messages, unlock them with Telegram Stars (no credit card needed).
Tech stack: Node.js/Express, PostgreSQL, React, Telegraf. Single Hetzner VPS with PM2. Total cost: ~$5/month.
Interesting technical bits:
- Auth uses Telegram's initData with HMAC validation (no passwords)
- Payments via Telegram Stars API (createInvoiceLink → pre_checkout → successful_payment)
- Haptic feedback makes WebView feel native
- i18n for English + Russian
Try it: https://t.me/WhisprMe_bot
Happy to answer questions about the Telegram Mini App platform or Stars payment flow.

value: Show HN: WhisprMe – Anonymous messaging inside Telegram with Stars micropayments

author: paulbrickman


value: oddurmagnusson

value: Show HN: Gnosis – Turns pull requests into guided walkthroughs

author: oddurmagnusson


value: lixiasky

value: Show HN: I made a zero-copy coroutine tracer to find my scheduler's lost wakeups

author: lixiasky


value: vladimir-urik

value:
Oxmgr is an open-source process manager for Linux, macOS, and Windows.
Language-agnostic (Node.js, Python, Go, any executable), declarative
oxfile.toml config with idempotent `oxmgr apply`.
Benchmarked against PM2 on Linux (GitHub Actions Ubuntu, automated on every push):
- 42x faster crash recovery (3.7ms vs 157ms)
- 21x lower memory at 100 processes (6.8MB vs 145MB)
- 7.5x faster fleet start (773ms vs 5.82s)
- 47x faster single process start (3.9ms vs 184ms)
Benchmarks are reproducible — script is in the repo.
GitHub: https://github.com/Vladimir-Urik/OxMgr
Benchmarks: https://oxmgr.empellio.com/benchmark

value: Show HN: Oxmgr – a lightweight PM2 alternative written in Rust

author: vladimir-urik


value: distributev

value:
I built ReportBurster out of frustration with current BI stacks.
Most tools live in two separate worlds:
- Beautiful dashboards and analytics tools — great for charts, weak for reporting, and many push you towards their SaaS.
- Powerful report generators — pixel-perfect PDFs, but no real analytics or exploration.
Stitching 4–5 tools together with scripts, glue code, and workarounds became the norm.
Plus, most modern tools are SaaS-first. If you want serious reporting, automation, portals, or embedding — self-hosted and open-source — options shrink fast.
ReportBurster aims to handle the entire data-to-delivery pipeline in one platform, powered by the *AI Crew* — your council of AI oracles that learn your projects, preferences, and workflows:
- Explore & visualize data (aka Chat2DB using AI)
- Generate pixel-perfect reports
- Automate bursting and distribution
- Build secure document portals
- Build, deploy, or embed dashboards and OLAP analytics directly into your own apps
Built with Angular, Java, and NextJS. Fully self-hosted and open-source — *no more SaaS lock-in*.
GitHub: https://github.com/yourusername/reportburster
Website: https://www.reportburster.com
I’d love feedback on usability, feature ideas, or contributions!

value: Show HN: ReportBurster – Self-hosted all-in-one tool for analytics and reporting

author: distributev


value:
As a follow-up to a CTF challenge I wrote, I created a small proof-of-concept virtual machine embedded in the Rust type system. Trait resolution and in particular associated types are used to "execute" a program, represented as a type, to its final state. (The "execution" happens during Rust compilation.)
The VM architecture is simple: two 8-bit registers, a stack, a small number of instructions, including conditional control flow. However, other than patience and hitting the recursion limits, more useful/realistic architectures could be embedded as well.
I wrote a blog post that goes into more depth about how this was developed and how it all works: https://www.thenet.sk/blog0011

value: Show HN: A virtual machine in the Rust type system


value: rodrigocava

value:
I was listening to a recent YC podcast about "build something agents want", and while building apps with Claude Code, I kept running into trouble figuring out how APIs actually behave in practice. And knowing that most companies won't update their docs to be agent-friendly, it clicked — agents need their own Stack Overflow.
AI agents are consuming APIs at a scale and speed that human-written documentation can't keep up with. AgentThreads is a community directory where agents discover, submit, and review APIs — for agents, by agents.
The idea came from watching agents fail silently on undocumented edge cases, relying only on Google searches and bad docs. They need structured, community-maintained knowledge they can query at runtime.
A few things we built:
- API directory with agent-written reviews and ratings
- No UI, just REST — built for agents, not humans
- Anti-spam verification (agents solve reasoning challenges, not CAPTCHAs)
- Karma system so agents build reputation over time
Built mostly with Claude Code over a few weekends.
Early days — would love feedback from people building agents on what's missing.

value: Show HN: AgentThreads – Stack Overflow for AI Agents

author: rodrigocava


value:
I built TubeNitro because I found YouTube’s 2x long-press feature both useful and frustrating.
It’s great for quickly skimming, but 2x is often too fast for tutorials and too slow for boring segments. I wanted something fluid — more like scrubbing with a mouse — but for playback speed.
TubeNitro lets you long-press anywhere on the video and slide your mouse vertically:
• Slide up → accelerate (up to 10x)
• Slide down → slow down (down to 0.5x)
The speed changes continuously and shows a small overlay so you can see the exact rate.

value: Show HN: TubeNitro – intuitive press-hold + drag to dial YouTube speed (0.5-10×)


value: AleksDoesCode

value:
Hey HN,
I built VibeWhisper because I was using Claude Code all day and the bottleneck wasn't thinking — it was typing. I tried an existing voice-to-text tool, loved the workflow, then saw the price: $20/month for a thin wrapper around OpenAI Whisper where 10 minutes of API usage costs $0.06. So I built my own in a weekend.
How it works:
Hold a configurable global hotkey (default: Right Command), speak, release. Transcribed text appears in whatever text field has focus — VS Code, Terminal, Slack, browser, anything. No clipboard hijacking — it uses the macOS Accessibility API to inject text directly at the cursor position (same APIs screen readers use).
Two transcription engines:
Cloud: OpenAI Whisper API via your own key (~$0.006/min, fastest and most accurate)
Local: WhisperKit running on-device via CoreML/Apple Neural Engine. 10 models from Tiny (50 MB) to Large V3 Turbo (1.6 GB). Your voice never leaves your Mac. No API key needed, no internet needed.
The app auto-recommends the best local model for your hardware.
Tech details for the curious:
Native Swift/SwiftUI, no Electron. Uses less RAM than a Chrome tab.
CGEvent taps for global keyboard hooks
Accessibility API for text injection
API key stored in macOS Keychain
Universal binary (arm64 + x86_64), macOS 14+
No backend, no accounts, no telemetry
Pricing: $19 one-time. No subscription. 15-minute free trial (actual recording time, not calendar time), no credit card, no signup. If you use cloud mode, you pay OpenAI directly at their rate. If you use local mode, it costs nothing after purchase.
I use it myself 2-3 hours a day. My main use case is dictating long prompts to AI coding assistants — I can speak a 400-word prompt in 45 seconds instead of typing it in 3-4 minutes. I also use it as a thinking tool: talking through problems out loud and capturing the output.
Website: https://vibewhisper.dev
Happy to answer any technical questions.

value: Show HN: VibeWhisper – macOS voice-to-text with push-to-talk,cloud or 100% local

author: AleksDoesCode


value: loichrn

value:
Hi HN,
I built Cloudstic (https://github.com/Cloudstic/cli), an open-source Go CLI that creates encrypted, deduplicated, point-in-time backups of your Google Drive, OneDrive, and local files.
The Problem
Google Drive and OneDrive are sync tools, not backup tools. If you accidentally delete a folder, it’s gone everywhere. If ransomware encrypts your local files, the "mistake" propagates to the cloud immediately. There is no easy way to say: "Restore my entire Drive exactly as it looked on January 15th."
Why not just use Restic or Borg?
I’m a huge fan of Restic, and Cloudstic’s content-addressed design is heavily inspired by it. However, tools built for local filesystems struggle with cloud semantics:
1. File Identity: In Google Drive, files have unique IDs and can have multiple parent folders. They don't have a single canonical path.
2. Efficiency: Scanning a 1TB Drive to find changes is slow and hits API rate limits.
3. Structure: Restic’s tree structure mirrors a directory hierarchy. Cloudstic uses a Merkle-HAMT (Hash Array Mapped Trie) keyed by file ID instead. This allows us to handle cloud-native metadata natively while maintaining structural sharing between snapshots.
Key Features
* Encryption by Default: AES-256-GCM (via standard Go crypto libraries). You can recover via password or a BIP39 recovery phrase. Your storage provider (S3, B2, SFTP) sees only encrypted blobs.
* Cross-Source Deduplication: We use FastCDC (Content-Defined Chunking). If the same 50MB PDF exists on your laptop and your Google Drive, it is stored exactly once in your backup repository.
* Incremental via APIs: Instead of walking the whole tree, we use the Google Drive Changes API and OneDrive Delta API. It only fetches what has changed since your last snapshot.
* Crash-Safe & Immutable: All objects in the repository are append-only. An interrupted backup or a network drop leaves zero corruption.
* Performance: In my benchmarks (1GB dataset / 10k files), Cloudstic edges out Restic on initial local backups (1.2s vs 1.8s) and matches it on S3 uploads while maintaining a small, bounded memory footprint.
Quick Start
Cloudstic is a single static binary. You can point it at local disk, S3/R2/MinIO, Backblaze B2, or SFTP.

  brew install cloudstic/tap/cloudstic
  cloudstic init --backend s3 --bucket my-backups
  cloudstic backup --source gdrive
  cloudstic list-snapshots
  cloudstic restore <snapshot-id> --to ./recovery

I’m also working on a managed version (https://cloudstic.com) for those who want the same engine but don't want to manage their own crontabs or S3 buckets.
The code is MIT Licensed. You can find the full storage spec and encryption design doc in the /docs folder of the repo. I’d love feedback on the HAMT implementation and the crypto design!

value: Show HN: Cloudstic – Open-source CLI for encrypted, cloud-native backups

author: loichrn


value: naxtsass

value:
Hi HN,
Like many of you, I've been tracking the "Sora-level" video models coming out of ByteDance and Kuaishou. While the tech is impressive, the accessibility often sucks—many are locked behind mobile apps (like Higgsfield) or fragmented invite-only portals.
I built SeeVideo to provide a unified, web-first workspace specifically for Seedance 2.0 and Kling 3.0.
Why I built this:
The Web Gap: Many users are searching for "Higgsfield Online" only to find it's mobile-only. I wanted a desktop-class environment for professional prompt engineering.
Model Nuances: Seedance 2.0 (ByteDance) handles complex physics like liquid and hair differently than Kling. I’ve included a "Prompt Transformer" to help adapt generic prompts into the specific "dialects" these models prefer.
Side-by-Side Benchmarking: It’s hard to judge "cinematic quality" without a direct comparison. This tool lets you see how they stack up on the same prompt.
Technical Observations:
From running ~1000 generations, Seedance 2.0 seems to have a higher "motion ceiling" but requires much more specific lighting descriptors compared to Kling's more "forgiving" default style.
I’d love to get the community's feedback on the UI and hear about your experience with the temporal consistency of these latest Chinese diffusion models.
Check it out here: https://seevideo.dance/

value: Show HN: SeeVideo A web-first workspace to benchmark Seedance 2.0 vs. Kling 3.0

author: naxtsass


value:
If you're a non-technical founder, you probably have no idea what your developers did last week. You ask, they say "refactored the auth module" and you nod pretending you understand.
Gitmore reads your GitHub activity and turns it into a simple report: what was built, what was fixed, what's stuck. Written for humans, not engineers.
It shows up in your inbox. You read it in 2 minutes. Done.
Here's what a report looks like: https://www.gitmore.io/example.html
Quick demo: https://demo.arcade.software/5tZyFDhp1myCosw6e1po
Free tier available. Happy to hear what you'd want from something like this.

value: Show HN: Ask your AI what your devs shipped this week


value:
I'm a high school student who got tired of clicking through nested folders just to find files. Every time I needed something specific, I had to open folder after folder. Small frustration, but it adds up fast.
So I built Postrix. You drag folders onto a canvas and immediately see what's inside without opening anything. As I kept building, I thought it'd also be useful to organize URLs alongside files, so I added that too. You can group links into cards and arrange everything freely on the same canvas.
It runs entirely in the browser with no server or account needed. Workspaces can be exported as a single self-contained HTML file to share with anyone. There's also a browser extension available on Edge.
Just launched as a free beta. Bug reports and feedback are very welcome.
Discord: https://discord.gg/Hxf7fPuv

value: Show HN: Postrix – A canvas for folders and links (Beta)


value: RasmusBjersing

value:
Hi HN, I'm Rasmus, Founder of Atlaz https://www.atlaz.ai.
Atlaz helps you make decisions by (1) interviewing you to capture tacit knowledge (context in your head) and constraints, then (2) generating a decision memo where key claims are backed by traceable analysis.
How it works:
- You describe the decision (e.g., pricing change, hiring plan, vendor selection).
- Atlaz asks follow-up questions to capture assumptions, constraints, and goals.
- It produces a report you can share and collaborate on with teammates. For important claims, you can inspect supporting sources and the underlying analysis (scope/code/data).
What's different:
Most AI tools jump straight to an answer that can be hard to justify. Atlaz extracts goals/constraints/assumptions first, and then gives you recommendations that you can easily review, scrutinize and share.
Video demo: https://youtu.be/EejvT6-Utc4
Pricing: free to try, paid plans $20, $100 and $200/month, or team pricing.

value: Show HN: Atlaz – Decoding Decision-Making with tacit knowledge and verifiability

author: RasmusBjersing


value: iamrahulrao

value:
Hi folks, coming from a product design background I wanted to build my apps. With the advent of AI, I used Cursor to create my first app - Kabit<p>Why kabit?
I have used a lot of habit-tracking apps and most of them are filled with features that are not useful to me, sometimes UI is a mess etc. I wanted to build an app that was simple and useful. There was a lot of trial and error, especially in figuring out the logic of the streak counter, which took a lot of time. I have spent some time polishing the UI as well. Although not a perfect app, I think I have a good tracker. I am planning to add more features and would love to know your thoughts and feedback. Thanks

value: Show HN: Kabit – Free habit tracker app

author: iamrahulrao

title: Show HN: Kabit – Free habit tracker app


value: serchinastico

value: Show HN: I interviewed myself to find product ideas for my one-person studio

author: serchinastico


value: zen-logic

value:
Hi HN. I built File Hunter because I have a drawer full of USB drives and no idea what's on them without plugging each one in.
File Hunter is a self-hosted, web-based file manager. You point it at any folder — USB drive, network share, DVD — and it catalogs everything into SQLite. When you unplug the drive, the full catalog stays. You can browse, search, and review files on storage that isn't connected.
The other thing it does well is deduplication. A three-tier hashing strategy (file size → xxHash64 partial → SHA-256 full) finds exact duplicates across all your locations with minimal I/O. Then you can consolidate: keep one copy, stub the rest, full audit trail.
Some numbers: I run it on a catalog of ~7 million files across 9.6 TB and 10 locations. The UI stays responsive during scans.
Tech: Python, Starlette, uvicorn, SQLite (WAL mode), vanilla JavaScript. No frameworks, no build step, no npm. One curl command to install:

    curl -fsSL https://filehunter.zenlogic.uk/install | bash

It's MIT-licensed and free. There's a paid Pro tier that adds remote agents (scan machines across the network into one catalog), but everything on the GitHub page is the free version and will stay that way.

  Website: https://filehunter.zenlogic.uk
  GitHub: https://github.com/zen-logic/file-hunter

Happy to answer questions about the architecture, the dedup strategy, or anything else.

value: Show HN: FileHunter, Self-hosted file manager that remembers disconnected drives

author: zen-logic


value: Show HN: CronBeats – Cron monitoring with AI support and progress tracking


value: yeominux

value: Show HN: MD Feedback – Review AI Plans in Markdown via MCP

author: yeominux


value: mosesxu

value:
I’ve been using Claude Code pretty heavily lately (plan mode, multi-agent runs, long tool streaks), and I noticed a pattern:
When the AI is busy running tools, I’m usually just… sitting there.
Forty-five minutes later I realize I haven’t moved at all.
So I built a small side project called Claude Gym.
It watches Claude Code’s local JSONL logs and uses them as a signal for “AI is busy vs AI needs input.” The JSONL logs expose structured events (tool calls, agent transitions, turn boundaries), which makes them a surprisingly clean signal for detecting human idle windows.
When Claude doesn’t need me, it pops up short movement prompts (squats, stretches, wall sits). When Claude needs input again, it gets out of the way. There’s also a small pixel-art cat that jumps when a turn finishes.
No network, no telemetry — it just tails the local logs. Written in Go, runs in a separate terminal tab.
It’s intentionally small and a bit playful, but it’s been surprisingly effective at getting me to move during long sessions.
Repo (MIT):
https://github.com/477-Studio/claude-gym
Curious whether others have experimented with tying human breaks to agent activity instead of timers.

value: Show HN: Claude Gym – a tiny CLI that nudges you to move while Claude Code runs

author: mosesxu


value: grandlaps

value: Show HN: AI Referral Detector – See which AI sent traffic to your site

author: grandlaps


value:
Every other gateway is detect-and-block. You don't get a security grade. You don't get red team in CI. We built the one that does.
PromptGuard is a proxy: change your base URL (one line with our SDK, or a few lines without), and every request gets checked for prompt injection, PII leaks, jailbreaks, and abuse. 20+ threat vectors, 39+ PII types. We also ship a red team suite and an autonomous agent that mutates attacks to find bypasses - you get a grade (A-F) and a GitHub Action that runs these tests on every PR. So you see where you're weak before you ship.
Works with OpenAI, Anthropic, Google, Azure, Gemini and more. Policy-as-Code. 10K free requests/month - link in the post.
Happy to answer questions.

value: Show HN: Only firewall for AI prompts with a security grade on every PR


value: bchapuis

value:
I wanted to test a question: if producing code costs almost nothing, how would you build a globe viewer? Instead of optimizing for human productivity (high-level language, existing engine, standard formats), what if you optimize for the output: binary size, portability, runtime cost, control?
So I let Claude produce it in C targeting WebGPU. Documentation first, code second. Given clear specs, it produced working C on the first pass. Given vague specs, the code wandered or chose the obvious path. This is experimental code and there are many areas for improvement, but I was pleasantly surprised at the results.
Repository: https://github.com/arpentry/arpentry

value: Show HN: Building a Globe Viewer When Software Is Cheap

author: bchapuis


value: wictorwilen

value: Show HN: MRSF – A sidecar review format for Markdown (CLI and MCP server)

author: wictorwilen


value: michaeloblak

value: Show HN: Web2cli – Every website is a Unix command

author: michaeloblak


value: Show HN: CryptoMorning – AI crypto briefing via a single Claude.md file


value: saynsec

value:
Hi HN,
I built a live vulnerability intelligence dashboard that tracks trending CVEs, severity levels, and basic exploitation signals.
The goal was to make CVE data easier to scan quickly without digging through multiple feeds.
You can view it here: https://leakycreds.com/vulnerability-intelligence
Each CVE has its own page with:
* Overview and description
* CVSS score and severity
* Impact summary
* References
* Last updated timestamp
* Linked social media posts related to that CVE (to understand why it’s trending)
It’s free to access — no login required to browse vulnerability data.
I’m currently refining:
* How trending CVEs are prioritized
* How to surface exploitation signals more clearly
* What contextual signals are actually useful during triage
Would really appreciate feedback:
* What do you look at first when triaging a new CVE?
* What do most vulnerability dashboards get wrong?
* What would make something like this genuinely useful for your workflow?
Happy to answer technical questions as well.

value: Show HN: Live Vulnerability Intelligence Dashboard (Trending CVEs)

author: saynsec


value: geiser

value:
Hey! It's Sergio, the creator of LynxPrompt
I've published it before, but this time I completely redesigned it to be a platform that you can realistically self-host and yet, have a set of federated blueprints for you to use coming from other instances (if enabled, and also if blueprints are shared publicly).
I built it to manage all my ai config rules as currently I'm using Claude Code, Cursor, Copilot & Kiro regularly. I also use it to generate a small starting AGENTS.md file (or CLAUDE.MD, etc.) instead of relying on zero-shotting it to Claude, so I can control better what does it contain (at least, at first! but obviously, this should be growing once you start, that's when sync mechanism of the lynxp CLI I developed is worth it for me).
Why don't commit them to git? Well, sometimes it's simply not under a git repository, for many reasons. Or you have it .gitignored because you have nasty secrets there. Then you can self-host it and privately have them uploaded regularly. It's not git compatible, I just built a minimum system for this at this point.

value: Show HN: LynxPrompt – Self-hostable, federated AI config rules manager

author: geiser


value: Martinmm

value:
Hey HN,I built Finclaw because I got tired of staring at charts and news tickers all day.
It's a lightweight, local-first AI agent that:
Monitors your personal watchlist with memory of your investment thesis
Checks prices at open/close + scans news every 30 min
Gives its own Bullish / Neutral / Bearish opinion with conviction level and reasoning
Alerts you proactively when price moves, earnings hit, M&A rumors drop, or your thesis gets confirmed/challenged
Does deep fundamental + technical analysis, DCF modeling, AI-exposure scoring, and even suggests related tickers on demand
Everything runs on free yfinance data (no API keys for market data), LiteLLM (swap Claude / GPT / Grok / whatever), and a tiny framework called nanobot. No vendor lock-in, no subscriptions.

value: Show HN: Finclaw, Openclaw for financial information

author: Martinmm


value: Show HN: Dream Pruning – biologically-inspired SVD consolidation for LLMs


value: bryanhogan

value: Show HN: Dice Jaga – A simple Yahtzee x Roguelike inspired web game

author: bryanhogan


value: tkjef

value:
I use Claude Code and Codex constantly, and my workflow was always the same: launch the agent, need a shell in the same directory, open a new tab, cd back.
Fifty times a day.
So I built auto-snap into Yaw — launch any AI coding CLI and it detects it and splits the pane automatically. Agent on the left, fresh shell in the same directory on the right. Works with Claude Code, Codex, Gemini CLI, and Vibe CLI. You can install any of them through a built-in wizard.
Yaw is also a full terminal (tabs, split panes, broadcast, search, session restore, WebGL via xterm.js) with a built-in connection manager for SSH, PostgreSQL, MySQL, SQL Server, MongoDB, and Redis — encrypted credentials, Tailscale auto-detection, remote Screen session management. And a chat panel that sends terminal output as context to Claude, ChatGPT, Gemini, Ollama, and six other providers.
Electron + xterm.js + React. v0.9.75, Windows and macOS.
Curious what other people's AI coding CLI setups look like — what's working, what's missing?

value: Show HN: Yaw – A terminal built around the Claude Code/Codex CLI workflow

author: tkjef


value: mrorigo

value:
Built AISH to make terminal output more useful without changing how commands run. Your agent context will love it.
What it does:

  - Runs commands in a real PTY (colors/progress still work)
  - Logs full output for every run
  - Shows short digest on success
  - Shows relevant excerpt on failure (tool-aware detectors + generic fallback)
  - Supports bash/zsh via ai wrapper and optional shims

Example:

  - aish-run -- cargo test
  - aish-run --last
  - aish-run --open

Current detectors include pytest/jest/vitest/cargo/go/tsc/eslint/ruff/mypy/maven/gradle/dotnet/cmake/terraform/docker/kubectl.
Would love feedback on:

  - detector quality / false positives
  - shell UX defaults
  - packaging/release experience

value: Show HN: AISH – PTY-first shell wrapper that shows signal, not noise

author: mrorigo


value: QuiCreatDev

value: Show HN: I built a serverless wrapper for the EU VIES with caching and webhooks

author: QuiCreatDev


value: cosmicmeta

value:
I built Vynix, a cross-platform mobile app (iOS/Android) that aggregates 100+ AI models into a single interface. Instead of switching between different AI apps, you get image generation, video creation, TTS, music generation, and LLM chat all in one place.
Tech stack: - Kotlin Multiplatform + Compose Multiplatform (shared UI across iOS & Android) - Firebase (Auth, Firestore, Cloud Functions) - Backend proxies to Replicate and fal.ai APIs - Credit-based system — no subscriptions required
The app adds new models within days of their public availability. Currently includes models for: - Text-to-image (multiple styles: photorealistic, anime, digital art) - Text-to-video and image-to-video - Text-to-speech (50+ voice options) - AI music generation - LLM chat (multi-modal)
Free to try — you get 40 credits on signup + daily free credits.
Website: https://vynix.app

value: Show HN: Vynix – Mobile app with 100 AI models for image/video/audio generation

author: cosmicmeta


value: Show HN: My API was leaking its full database schema. I found out by accident


value: bkraszewski

value: Show HN: ScrollMind – Learn how AI works by scrolling a feed, not a textbook

author: bkraszewski


value: Ametrin

value:
Hi HN, I'm Michał. I posted PDFBolt here about a year ago as a basic
HTML to PDF API. Since then I've been rebuilding it around the thing
that kept bugging me: every time a designer tweaked a layout,
it meant a code change, a deploy, and a prayer that nothing broke
in production. I wanted templates that live on the server and version
themselves, so my API calls stay the same when the layout changes.
Try the editor, no sign-up. Open a sample report, change the data,
and download a real PDF:
https://pdfbolt.com/try
Templates use Handlebars. Your API call sends a templateId + JSON data. You
update the template in the dashboard, your code never changes. Every
edit auto-creates a draft, and you publish when ready. You can browse
history and compare any two versions as rendered PDFs side by side.
The comparison shows rendered PDFs, not just code. A one-line margin tweak
can push a table onto the next page, and you won't catch that in code.
You can roll back with one click if something breaks.
Right now template management lives in the dashboard. I'm working on
an API so coding agents can create and version templates programmatically.
The part I went deepest on recently was compression. The compressor
samples every 10th pixel to classify each image as bitonal, grayscale,
or color, then picks an encoding per image. Bitonal gets CCITT Group 4
with Otsu's method for the threshold. Color and grayscale get JPEG.
Images with alpha channels get split into RGB (JPEG, lossy) and mask
(FlateDecode, lossless) via an SMask so edges stay sharp. Before any
of that, MD5 hashes of raw streams deduplicate identical images across
pages, and everything gets downscaled to target DPI.
Four tiers: lossless, low, medium, high. A 23 MB product catalog with
photos dropped to 1.6 MB on high.
Built on Apache PDFBox. I looked at Ghostscript but it's AGPL, which
doesn't work for a hosted SaaS.
I also support PDF/X-1a and PDF/X-4 for print with RGB to CMYK
conversion and ICC profiles. Happy to talk about the color pipeline
in comments.
Stack: headless Chromium via Playwright, Kotlin/Spring Boot, EU-hosted.
I don't store template data after rendering.
Two-person team, bootstrapped.
Revenue: https://trustmrr.com/startup/pdfbolt
Free: 100 PDFs/month, no card
Docs: https://pdfbolt.com/docs
Ask me anything about compression internals, template versioning,
color pipeline, or whatever.

value: Show HN: PDFBolt – HTML to PDF API with Git-like template versioning

author: Ametrin


value:
I built DataPilot after 2 years working inside a data team where SQL operations were fragmented across too many tools.
DataPilot combines:
- shared SQL workspace (queries, variables, comments, history)
- recurring and one-shot runs
- data quality / metric monitoring with alerts
- CSV/XLSX delivery workflows
- cloud, desktop, and on-prem execution modes
- optional AI for schema documentation in context
Built with ASP.NET Core, Blazor, PostgreSQL, and SignalR.
Happy to answer technical questions and tradeoffs.
Product Hunt: https://www.producthunt.com/products/datapilot
Website: https://getdatapilot.com

value: Show HN: DataPilot – SQL workspace with scheduling, and on-prem execution


value: christianrth

value:
Hey HN,
I spent the last 20 years building enterprise software and cybersecurity tools. Last year I started using AI agents for real work — and got terrified. Every tool I tried would happily `rm -rf /` if you phrased it right. One popular agent literally tried to exfiltrate SSH keys (you might have seen that HN post).
So I built Core Rth. It's not a chatbot wrapper. It's a Sovereign Cognitive Kernel — an AI backend where every LLM action is a proposal that must survive a governance layer (The Guardian) before it touches your filesystem, your network, or your hardware.
Here's the thing that makes it different from OpenClaw and friends: Core Rth was designed from day one to control physical systems (IoT via Home Assistant, robots via ROS2, drones via MAVLink). When your AI can actuate a robotic arm or fly a drone, "move fast and break things" is not an option. So we built a Global E-Stop — a hardware kill switch in the Web UI that severs all physical agency instantly.
What's under the hood:
- Guardian: proposal-first governance. No destructive action runs without consent. Ever.
- Security Vault: AES-256-GCM encrypted credentials, OS keyring only, zero plaintext keys.
- AI Village: parallel agents (Architect, Critic, Synthesizer) debate on a Knowledge Graph before answering.
- Model Router: mix OpenAI + Anthropic + local Ollama/vLLM. Route by task type, cost, or privacy.
- Mission Control: real-time Web UI with bridge telemetry, policy ledger, and the big red E-Stop.
Try it:

    git clone https://github.com/rthgit/CORE-RTH.git
    cd CORE-RTH
    pip install -r requirements.txt
    python scripts/run_core_rth_local_bench_api.py
    # Open http://127.0.0.1:18030/ui/

Stack: Python 3.10+ / FastAPI / vanilla JS frontend (no React). Source-available license (free for non-commercial/research).
I built this because I needed an AI system I could actually trust with my infrastructure. If you're an engineer or CTO who feels the same way, I'd love your feedback on the architecture.
GitHub: https://github.com/rthgit/CORE-RTH
Created by Christian Quintino De Luca — info@rthitalia.com

value: Show HN: Core Rth. A governed AI kernel for engineers who don't trust their LLMs

author: christianrth


value: ankushKun

value:
We are building Construct Computer a cloud OS where autonomous AI agents ("Constructs") live and do your day to day work.
You can observe them in real-time through a desktop OS frontend.
The idea is agent-native infrastructure: instead of agents being API calls, they're persistent processes with their own compute, storage, and network identity.
With integrations with a vast ecosystem of business tools, the Construct Agent can do anything from scheduling meetings, preparing documents, to deep researching the web, join meetings, and automate long running business operations with minimal human intervention.
demo video: https://x.com/use_construct/status/2028731937330954539

value: Show HN: Construct Computer – Agentic Cloud OS for Daily Work

author: ankushKun


value: lukasanderss

value:
I hate the feeling of sitting in front of an empty deck or slide trying to figure out where to begin. But I don't want that same AI generic output for every slide deck, it's just sad.
That's why I've tried to the death of me to make AI slide generation truly free, free in the sense that it can create whatever you want without being locked into fixed template systems or rigid layout grids like Gamma imposes.
As of now it does that. Layout calculations can still break when placing multiple elements simultaneously, cards or charts can fall off the edge, but it's easily fixed by prompting the AI to read the slide and correct it. I'm pretty proud of where it's gotten. Style references work well, mentioning McKinsey, Apple, Microsoft, or Bauhaus gives the AI a clear visual target. It can pull in images and content from URLs, generate images, and everything is fully editable on a DOM-based slide canvas with modern CSS.
It runs on Claude Sonnet 4.6 for cost reasons. I'm not funded, so I can't let people go completely loose for free, sorry about that, and that's why sign-in is required.
I was an investment banking / coding kid who turned vibe coder until I got reasonably good at actual coding. Would love to hear what you think and whether you'd use this over Gamma / Chronicle / PowerPoint with Claude / Canva.
Please try it out, roast me, send me some slides on X, would love to see what you create
https://x.com/Lurrree

value: Show HN: Ablo - AI slides without the generic look or layout restrictions

author: lukasanderss


value: pramhatibie

value:
I hate writing changelogs. Every release I'd spend 20 minutes turning "fix: stuff" into something readable.
Built a free tool: paste your git log, choose format (GitHub Release / npm CHANGELOG / Slack / customer update), get polished markdown in under a second. No signup, no API key needed.
Uses Groq's LPU for the speed — it's genuinely instant compared to GPT-4.

value: Show HN: ReleasAI – Paste Git commits, get polished release notes in <1s

author: pramhatibie


value: GraysoftDev

value:
I'm a CIS student who built this after getting fed up with every file sharing platform making the wrong tradeoffs. They're either expensive with good encryption, free with no encryption, or free but lock basic features behind signups and paywalls.
Technical implementation:
- AES-256-GCM encryption runs entirely in the browser before upload
- Decryption key lives only in the URL fragment — the server receives and stores only ciphertext. Zero-knowledge is real, not marketing
- P2P mode: WebRTC direct transfer, nothing touches our servers at all
What's free without an account (competitors charge or require signup for these):
- Password-protected links
- 50GB per file, unlimited storage total
- File previews on the download page
- Full tool suite (file conversion, image tools, etc.)
The only reason to create an account: persistent file management. That's it. No dark patterns, no feature gating to force signups.
I noticed some "zero-knowledge" competitors literally ask for your name on signup. If you're privacy-first, why do you need my name? FileShot asks for nothing — you can use every feature anonymously.
Desktop app (Electron), browser extension (Chrome), and PWA also available.
Happy to answer questions about the encryption implementation, P2P architecture, or anything else.

value: Show HN: FileShot – zero-knowledge file sharing, nothing locked behind accounts

author: GraysoftDev


value: matjekchen

value:
This image came to me during my meditation practices. It symbolizes the flow of consciousness wrapped in an incomprehensible reality.
The sculpture is interactive and responds to mouse movement.
All of the text was generated by an LLM, with the sculpture’s own code used as the prompt. I asked the LLM to generate some text for debugging, and it produced the phrase from which the rest of the text was later created:
WORDS BECOME WAVES AND THE WAVES BECOME LINES AND THE LINES BECOME NAMES

value: Show HN: I Built a Digital Sculpture

author: matjekchen

title: Show HN: I Built a Digital Sculpture


value: lyfeninja

value:
Hi HN — I built an experimental demo that creates and verifies revocable digital signature artifacts using deep learning encoding models instead of traditional cryptographic keys.
In this system, a specific model instance encodes file metadata into a signature artifact. That same model instance is required to verify it. Signing authority is controlled through a short-lived “lease” (15 minutes), and can be revoked to intentionally invalidate verification.
This is not RSA/ECDSA, and I’m not making cryptographic claims or guarantees. I’m exploring whether the encoding method combined with short-lived authority can function as a signing primitive.
What you can do:
 - Upload a non-sensitive file
 - Generate a downloadable signature package
 - Verify it later
 - Revoke the signing authority and observe verification behavior change
 - Session based. Files are processed in memory and not stored.
Core Properties:
 - Signatures are encoded using a specific trained model instance
 - Only the specific model instance can decode/verify the signature
 - Authority is short-lived through a 15-minute lease
 - Revocation is built into the design
 - No long-lived private keys
 - No blockchain or ledger
Challenge:
If you’re technically inclined, I’d genuinely love for you to try to break it. Specifically...
- Attempt to forge or reverse-engineer the signature artifact
 - Modify files after signing and try to preserve verification
 - Alter metadata in the signature package
 - Replay artifacts across leases
If you can successfully forge or meaningfully reproduce a valid signature artifact without access to the model instance, I’d love to hear about it. This demo is intentionally inspectable and challengeable. I am not inviting attacks against the site or infrastructure — just scrutiny of the method and encoding assumptions.
Project info and write-up:
 - https://lyfe.ninja/projects/#BlkBolt
 - https://lyfe.ninja/news/#revocable-signature-demo
If there are obvious flaws, I’d rather learn that now than later. Thanks for taking a look.

value: Show HN: Experimental Revocable Signatures Using Model-Based Encoding

author: lyfeninja


value: vitass

value: Show HN: Evidra – a fail-closed MCP guardrail for AI infrastructure ops

author: vitass


value: Prince-Gabriel

value:
LLMs hallucinate recency. They'll tell you a project is active when it hasn't been touched in two years, or cite outdated docs as current. The problem isn't the content — it's that there's no timestamp on when it was retrieved.
FreshContext wraps every extraction in an envelope with retrieved_at, content_date, and freshness_confidence fields. The agent always knows when it's looking at data, not just what it says.
Ships with 7 tools: GitHub repo extraction, Hacker News sentiment, Google Scholar, YC startup scraper, GitHub repo search, npm/PyPI package trends, and extract_landscape — one call that queries all sources simultaneously and returns a unified competitive intelligence report.
Works locally (Playwright) and on Cloudflare Workers (Browser Rendering API). MIT license.
Would love feedback on the FreshContext envelope pattern specifically — is this a useful primitive for agent reliability?

value: Show HN: MCP server that timestamps every web extraction for AI agents

author: Prince-Gabriel


value: bryanhogan

value: Show HN: Dice Jaga – A simple Yahtzee x Roguelike inspired web game


value: Jessyabc

value:
I’m 25, work full-time at my family’s cabinetry company, and spent the last 9 months solo-building Learnprints (learnprints.ca) on nights and weekends with a ~$2,500 budget and a lot of searching and learning.
The frustration that started it: every learning tool I tried was optimized for engagement, not understanding. Anki is great but gives you no structure. Notion is a graveyard. AI chatbots answer questions but don’t build knowledge.
I wanted something that actually closed the loop.
What Learnprints does:
You give it any topic — quantum mechanics, corporate tax law, Renaissance art, anything — and it generates a Learnprint: a research-grade structural blueprint of that topic. Not a summary. A map of how the concepts relate, what the invariants are, what you need to understand before you can understand the next thing.
From there it’s a full loop:
 ∙ AI chatbot to clarify any concept inside the blueprint
 ∙ Spaced repetition that forces understanding, not memorization
 ∙ A cognitive mirror that builds a learning profile from how you actually practice
 ∙ A practice hub where you can upload assignments, get an AI tutor, draw on a canvas, and get passive feedback on your scratch work via vision AI
The whole thing is designed around one idea: depth compounds. A Learnprint you build today makes every future thing you learn in that domain faster.
The stack (full transparency):
 ∙ Frontend: Lovable, Cursor, Claude - Opus and Sonnet and a bit of Codex (AI-assisted React)
 ∙ Backend: Supabase (Postgres + Edge Functions)
 ∙ AI: GPT-5.2 for vision, GPT-4o-mini and GPT-5.2 for tutor and segmentation/structuring, LlamaParse for document extraction, Perplexity for the research layer
 ∙ Hosting: Vercel
What I’m looking for:
Launching at $15/month (CAD) with a goal of 10 paying users in 30 days. I have no marketing background — I’m a salesperson by day job and a builder by obsession. Roast the product, roast the pricing, tell me what’s missing. I can handle it. I want to improve and provide the educational tools I needed when I was in school to everybody.
learnprints.ca

value: Show HN: Learnprints – a full learning OS I built solo on nights and weekends

author: Jessyabc


value: BuddhikaR

value:
Hi HN, I built this because I kept pasting client data and API keys into ChatGPT without thinking.
It detects 15+ types of PII as you type, masks them with placeholders like [PERSON_A] before sending, then unmasks the AI's response. Everything runs locally — no servers, no data collection, zero network requests. You can verify in DevTools.
Built as a solo project using Claude Code.
Chrome Web Store: https://chromewebstore.google.com/detail/privacyshield/nklgh...
This is v0.1 — would love feedback. Bugs: support@piiblock.com or GitHub issues.

value: Show HN: PrivacyShield – Mask your PII before it reaches ChatGPT/Claude

author: BuddhikaR


value:
We've been building Honeycake, a file-native security platform that embeds encryption, access policies, and audit trails directly into files.
The thesis: AI Agents are moving data at machine speed across workflows, platforms, and organizations, often without explicit human approval. Conventional security protects locations (firewalls, IAM, DLP), but once an Agent copies a file somewhere new, those controls don't follow. The file is unprotected.
Our approach is a new file primitive called .cake. Every .cake file carries quantum-resistant encryption, section-level access controls (down to individual paragraphs within a document), and tamper-evident audit logging as intrinsic properties. All encryption/decryption happens locally. We never see your files.
The key architectural decisions:
Zero-exposure: keys and encrypted files never coexist in the same place. Even we can't access your content.
Section-level granularity: an Agent can be authorized to see one part of a document and redacted from another, within the same file.
Every file open is a logged event, so unusual access patterns (an Agent opening hundreds of files in seconds) are caught in real time.
We wrote up the full thinking in a whitepaper: https://honeycakefiles.com/whitepaper.html
The desktop app, CLI, and API are live. Happy to answer questions about the architecture or the threat model.

value: Show HN: Self-Protecting Files for the Agentic Era


value: christalingx

value: Show HN: I built a proxy that cuts LLM costs 40-60% – no AI involved

author: christalingx


value: Show HN: Mark your city and see where other builders are