value: Handuo

value:
Hey HN!
We’re a small team of artists, developers, and coffee lovers who’ve watched a lot of websites we love shut down over the years. We’ve been looking for a way to support them with income and exposure.
We see that more people are interacting with the web through AI instead of visiting sites directly, so the ad-based model is breaking. The open web needs a new business model.
Our take is to incentivize people (and, in the future, AI agents) to find and share valuable content (links), with both the finder and the original creator rewarded.
Along the way we were inspired by discussions like:
Pocket shut down: https://news.ycombinator.com/item?id=44063662
x402 protocol: https://news.ycombinator.com/item?id=45347335
“To survive the AI age, the web needs a new business model”: https://news.ycombinator.com/item?id=44598248
Key features
Social bookmarking
It’s like a decentralized Digg or a Pinterest-for-websites. You can share (curate) any URI (URL) through the site or the browser extension. Others can collect and build on your collections.
Pay-to-visit
Finding valuable content is valuable. You can set a stablecoin price for visiting a link you shared. Payments are powered by the x402 protocol.
Support sites/content you love
Half of the pay-to-visit revenue goes to the author of the original content, claimable after they opt into x402 or register a Copus account.
Permanent storage
Your collections (bookmarks) are automatically stored on the Arweave blockchain. We pay the storage fees so you’ll never lose them.
Other features we have in mind
Spaces
Like Pinterest boards, to organize your collections and collaborate with others.
Weave
If a link reminds you of another link, you can “weave” them together in a “you may also like” section. It’s a bit like a collective Obsidian graph where standalone websites become a connected map and every site is a rabbit hole.
AI agent support
You can train agents to curate and purchase for you.
Social features
Follow accounts with great taste.
Who we imagine this is for
If you’ve been bookmarking over the years, you already have tons of internet gems in hand! Please pick the best ones to share with the world. They’re valuable for both readers and original creators.
Were you a Pocket user? Save your best bookmarks here and never lose them. (We plan to support putting a copy of the whole website on-chain once the project scales. Right now we put the link, category info, and your recommendation notes on-chain for free.)
Some other things
Copus is open source, with the frontend built using Claude Code.
We plan to launch a governance token to put ownership of the project into the hands of the people who use it.
We don’t mess with rights and privacy. Aside from some essential terms needed to keep the project running, your rights remain yours.
Copus has a Chinese version (Copus.io), which is a haven for around 150k Chinese fan-fiction lovers rn. We might merge the two sites once the English content reaches scale or we might not.
How we plan to make money
We’re still figuring it out. The first idea is:
Take a 10% fee on each payment.
Put unclaimed creator earnings into low-risk investments (similar to how stablecoins earn yield).
Hope you enjoy Copus, and thank you in advance for trying it out early!

value: Show HN: Copus – Internet gem marketplace for bookmark collectors (x402-powered)

author: Handuo


value: ZeelRajodiya

value: Show HN: Blazing-Fast CLI AI with Near-Instant Response (Powered by Groq)

author: ZeelRajodiya


value: Rioverde

value: Hello HN, I’ve turned my Master’s research on stabilizing very deep Transformers into an open-source PyTorch library called AION-Torch. Instead of a fixed residual connection, it uses an adaptive residual that looks at how “energetic” the block’s input and output are and dials the residual strength up or down to keep things stable. On my small setup (RTX 4060) it seemed to help very deep Transformer stacks keep gradients under control and reach lower loss without special tuning.<p>The repo has a drop-in AionResidual module, some basic tooling to log what’s happening inside the network, and small examples to show how to plug it into existing models. I’d love feedback on whether this idea makes sense beyond toy setups, how you would benchmark it against standard residuals/DeepNorm on real tasks, and if the API feels natural for people who train larger models.

value: Show HN: Aion-Torch – Adaptive residual scaling for deep Transformers

author: Rioverde


value: segmenta

value:
Claude Code is great, but it’s focused on coding. The missing piece is a native way to build and run custom background agents for non-code tasks. We built RowboatX as a CLI tool modeled after Claude Code that lets you do that. It uses the file system and unix tools to create and monitor background agents for everyday tasks, connect them to any MCP server for tools, and reason over their outputs.
Because RowboatX runs locally with shell access, the agents can install tools, execute code, and automate anything you could do in a terminal with your explicit permission. It works with any compatible LLM, including open-source ones.
Our repo is https://github.com/rowboatlabs/rowboat, and there’s a demo video here: https://youtu.be/cyPBinQzicY
For example, you can connect RowboatX to the ElevenLabs MCP server and create a background workflow that produces a NotebookLM-style podcast every day from recent AI-agent papers on arXiv. Or you can connect it to Google Calendar and Exa Search to research meeting attendees and generate briefs before each event.
You can try these with: `npx @rowboatlabs/rowboatx`
We combined three simple ideas:
1. File system as state: Each agent’s instruction, memory, logs, and data are just files on disk, grepable, diffable, and local. For instance, you can just run: grep -rl '"agent":"<agent-name>"' ~/.rowboat/runs to list every run for a particular workflow.
2. The supervisor agent: A Claude Code style agent that can create and run background agents. It predominantly uses Unix commands to monitor, update, and schedule agents. LLMs handle Unix tools better than backend APIs [1][2], so we leaned into that. It can also probe any MCP server and attach the tools to the agents.
3. Human-in-the-loop: Each background agent can emit a human_request message when needed (e.g. drafting a tricky email or installing a tool) that pauses execution and waits for input before continuing. The supervisor coordinates this.
I started my career over a decade ago building spam detection models at Twitter, spending a lot of my time in the terminal with Unix commands for data analysis [0] and Vowpal Wabbit for modeling. When Claude Code came along, it felt familiar and amazing to work with. But trying to use it beyond code always felt a bit forced. We built RowboatX to bring that same workflow to everyday tasks. It is Apache-2.0 licensed and easily extendable.
While there are many agent builders, running on the user's terminal enables unique use cases like computer and browser automation that cloud-based tools can't match. This power requires careful safety design. We implemented command-level allow/deny lists, with containerization coming next. We’ve tried to design for safety from day one, but we’d love to hear the community’s perspective on what additional safeguards or approaches you’d consider important here.
We’re excited to share RowboatX with everyone here. We’d love to hear your thoughts and welcome contributions!
—
[0] https://web.stanford.edu/class/cs124/kwc-unix-for-poets.pdf
[1] https://arxiv.org/pdf/2405.06807
[2] https://arxiv.org/pdf/2501.10132

value: Show HN: RowboatX – open-source Claude Code for everyday automations

author: segmenta


value: nicolaib

value:
Hi HN, I'm Nicolai. I'm working with a small team in Germany on Rhesis, an open-source platform for testing conversational LLM applications and agents. We’re sharing an early community preview today.
Why we built this:
We saw teams repeatedly struggle with testing, e.g. scattered test cases, unclear or inconsistent metrics, and a lot of manual effort that still missed obvious failures before production. Most tools assume a single developer runs evals alone; in practice, testing tends to involve PMs, domain experts, QA, and engineers. We built Rhesis to make that collaboration straightforward.
What it does:
Rhesis is a self-hostable platform (with UI) where teams can create, run, and review tests for conversational AI systems.
A few core ideas:
- Test generation: Create and run tests for single-turns or full conversations; the platform can also assist with generating both single- and multi-turn scenarios using your domain context.
- Domain context / knowledge: Provide background material to guide test creation so you’re not starting from an empty prompt.
- Collaboration tools: Non-technical teammates can write test cases, leave comments, and review results; developers can dig into failures with detailed traces and outputs.
- Unified metrics: Bring in eval metrics from DeepEval, RAGAS, and similar OSS frameworks without re-implementing them.
Current state:
Still early. We shipped v0.4.2 last week with a zero-config Docker setup. Core flows work, but there are rough edges. Everything is MIT-licensed; an enterprise edition will come later, but the OSS core will remain free. We’re currently focused on conversational applications because that’s where we saw the biggest pain in evaluation and QA workflows.
Links:
App: app.rhesis.ai
GitHub: github.com/rhesis-ai/rhesis
Docs: docs.rhesis.ai
Happy to hear your thoughts and any answer questions about platform design, the architecture, or our thinking on collaborative testing workflows.

value: Show HN: Rhesis – Open-source platform for collaborative LLM application testing

author: nicolaib


value: codecannon

value:
Hey HN,
My team and I built a tool to scratch our own itch. We were tired of spending the first few days of every new project setting up the same Vue + Laravel boilerplate: writing migrations, models, basic CRUD controllers, and wiring up forms and tables on the frontend.
So we built Codecannon. It’s a web app where you define your data models, columns, and relationships, and it generates a full-stack application for you.
To be clear, the code isn't AI-generated. It's produced deterministically by our own code generators, so the output is always predictable, clean, and follows conventional best practices.
The key difference from other tools is that it’s not a no-code platform you get locked into. When you're done, it pushes a well-structured codebase to your GitHub repo (or you can download a .zip file). You own it completely and can start building your real features on top of it right away.
What it generates: - Laravel Backend: Migrations, models with relationships, factories, seeders, and basic CRUD API endpoints.

    - Vue Frontend: A SPA with PrimeVue components. It includes auth pages, data tables, and create/edit forms for each of your models, with all the state management wired up.

    - Dev Stuff: Docker configs, a CI/CD pipeline starter, linters, and formatters are all included.

The idea is to skip the repetitive work and get straight to the interesting parts of a project.
It's free to use the builder, see a live preview, and download the full codebase for apps up to 5 modules. For larger apps, you only pay if you decide you want the source code.
We’re in an early alpha and would love to get some honest feedback from the community. Does the generated code look sensible? Are we missing any obvious features? Is this something you would find useful or know anyone who might? Let me know what you think.

value: Show HN: We built a generator for Vue+Laravel that gives you a clean codebase

author: codecannon


value: charlesvien

value: Show HN: One-Click Minecraft/Rust/Factorio Servers on Railway

author: charlesvien


value:
Hi HN!
I built rapid-rs to solve a problem I kept hitting: setting up a new Rust web API requires wiring together lots of crates and boilerplate.
: FastAPI's developer experience + Spring Boot's conventions, with Rust's performance and type safety.
:
- One command to scaffold: `rapid new myapi`
- Auto-configuration: DB, logging, CORS work out of the box
- Type-driven validation: Compile-time + runtime guarantees
- Auto-generated OpenAPI/Swagger UI
- Built on Axum, so you can use Axum patterns when needed
It's early stage but functional. Would love feedback from the HN community!
GitHub: https://github.com/ashishjsharda/rapid-rs

value: Show HN: Rapid-rs – Zero-config web framework for Rust


value: ersinesen

value: For non-Turkish speakers I recommend 'The Playlist'.

value: Show HN: My Album with Suno v5

author: ersinesen

title: Show HN: My Album with Suno v5


value: bojangleslover

value: Show HN: Polymarket/Kalshi Arbitrage Scanner Powered by Gemini Pro 3

author: bojangleslover


value: cpuXguy

value:
The most interesting interaction is the double-click, which generates a new pattern.
If you press and hold the pointer for a moment, the image starts to animate (you can also press the M key).
It’s helpful to open the keyboard legend with L or by clicking the “Open Keyboard Legend” icon.
But what are you really looking at here?
Visit: https://ng-menu.netlify.app/

value: Show HN: Largest Abacus Ever Built

author: cpuXguy

title: Show HN: Largest Abacus Ever Built


value:
Adobe Premiere plugin built with the CEP framework. Bring your own OpenAI key to remove silences and auto-generate animated captions with natural language. Built this for my own youtube videos.
Demo: https://www.youtube.com/watch?v=EVmRTNHV8o4

value: Show HN: I made an Premiere plugin to edit faster


value: oflatt

value:
Hi HN, I've just released a game called Video Souls running on top of the YouTube API.
It has a level editor and DSL so you can make your own levels, and I think it has a lot of potential for funny community levels. It also has connections to PL research, so I wrote the blog post on it.
There's a trailer here: https://www.youtube.com/watch?v=Cm5MKsAv-lE
And the game is here: https://videosouls.com/

value: Show HN: A DSL helps a soulslike run directly on YouTube

author: oflatt


value: danielepelleri

value:
I’ve been lifting for years using complex methodologies (Mentzer HIT, Kuba Method, FST-7) and got frustrated that existing trackers are just glorified spreadsheets. They record what you did, but they don't tell you what to do based on your fatigue or biomechanics.
So I built Arvo (https://arvo.guru). It’s a "context-aware" AI coach, not just a logger.
The Problem:
Standard apps use static linear progression (add 2.5kg every week). But if you are following a fatigue-based system (like Mike Israetel’s RP or Kuba), you need to autoregulate based on RPE/RIR and soreness. Most users fail to track this accurately in Excel.
The Solution & Tech Stack:
Instead of if-then statements, Arvo uses a chain of specialized AI agents (powered by GPT-5 reasoning models) to act as a coach:
NLP Logger: You don't toggle complex UI buttons. You just write a note: "Shoulder hurt on bench press, RPE was 9". The NLP agent parses this, logs the RPE, flags the injury, and automatically swaps the next push exercise to a joint-friendly variation (e.g., Landmine Press) for the next session.
Methodology Compliance: The logic engine respects strict rules. If you select "Mentzer HIT", it enforces low volume/absolute failure. If you select "Kuba", it manages volume accumulation.
[1] * Contextual Timer: It doesn’t just count down 90s. If the protocol is FST-7, it enforces short rest (30-45s) for fascial stretch.
Current Status:
We are in Open Beta.[2] The backend is heavily reliant on the new reasoning capabilities of GPT-5 to handle the multi-variable logic of periodization without hallucinating absurd weights.
I’d love you to roast the landing page or try the beta. Specifically interested in feedback on the NLP parsing accuracy from any serious lifters here.
Link: https://arvo.guru
Thanks!

value: Show HN: GPT-5.1 reasoning agents for hypertrophy periodization

author: danielepelleri


value: mikegiller

value:
Five years ago my 5-year-old son had a grand mal seizure at home. We lost minutes thinking he was breathing when he wasn’t, and the ambulance ride to Boston Children’s is still the worst moment of my life. He came home on twice-daily oxcarbazepine. Coordinating that schedule between spouse, school, and sitters relying on my faulty memory felt insanely fragile. That’s why I built Nudge Device.
Nudge is a compact $49 device you place under any pill bottle or weekly organizer. At the scheduled time it pulses green lights and beeps (30 / 35 / 59 min). Lift the bottle and the built-in IR proximity sensors + accelerometer instantly confirm the dose was taken, log the exact time, and silence everything. If the bottle stays untouched after 60 minutes, it automatically sends an email and push notification to the user and any caregivers added.
No buttons. No scanning. No “open the app and tap taken.” Just reliable confirmation.
Tech: ESP32, custom algorithm IR proximity for rock-solid detection, Flutter front-end (iOS/Android), AWS IoT Core + Lambda backend. First production run of 500 units arrived last week. HSA/FSA eligible and price is going up soon.
Today my son is seizure-free, and Nudge is the reason we never miss or double-dose.
Live site and full story: https://nudgedevice.com
25% off for HN: code HACKER25 (drops it to ~$37 while we’re still small)
Curious what HN thinks. Anyone shipping consumer health hardware? What killed you early on? Parents or caregivers here, does this actually fix the multi-person chaos you live with?
Tear it apart.
M Giller / solo founder

value: Show HN: Nudge – A $49 device that knows if you took your meds

author: mikegiller


value: farouqaldori

value:
I’ve been working on Opperator, an open source framework for building and running general purpose AI agents locally from the terminal. It’s similar in spirit to Claude Code, but focused on automation rather than just coding.
You can create agents that organize files, generate or transform content, monitor APIs, or automate personal workflows. Each agent runs as its own local process with its own environment and can use any model you want, including local LLMs.
A background daemon handles everything: it manages agent lifecycles, logging, persistence, and secrets. On top of that, there’s a terminal interface for interacting with agents and a lightweight Python SDK for defining their logic.
For example, you can say “create an agent that looks at my screenshots folder and renames files based on what’s in the image.” The built-in Builder agent scaffolds the code, installs dependencies, and lets you iterate live without restarting. Of course, you can also write or refine agents manually with tools like Cursor, Codex, or any other code assistant.
GitHub: https://github.com/opper-ai/opperator
Docs: https://docs.opper.ai/opperator
I’m interested in whether this idea resonates with others who like working locally and building personal automation systems. Feedback, use cases, or architectural critiques are all welcome.

value: Show HN: Opperator – Build Claude Code–style local AI agents in your terminal

author: farouqaldori


value: keepamovin

value: Show HN: Visualizing "Hardness" of Factoring – An Interactive Constraint Tableau

author: keepamovin


value: johnnymedhanie

value: Show HN: Doctective: Auto-Updating Docs and Codebase Guide

author: johnnymedhanie


value: Show HN: Club Penguin made by Google Gemini 3


value: emveras

value: Show HN: Audit Figma Files for Reset, Broken and Detached Variants and More

author: emveras


value: skswhwo

value:
I built a tiny tool where every URL becomes a fresh, editable webpage.
You open a link, write HTML/CSS/JS, hit “save”, and that page becomes permanent.
No login, no dashboard — just create → share → throw away.
Homepage:
https://wwwoooaaa.com
Example:
https://wwwoooaaa.com/49
Would love feedback or ideas for experiments!

value: Show HN: Wwwoooaaa – a tool for creating disposable webpages

author: skswhwo


value: ruben-davia

value:
Hi HN,
We’re Ruben, Afnan, and Theo, and we’re building Davia to make documenting and understanding codebases easier.
Generating internal docs takes too long, diagrams are essential to grasp structure, and editable visuals are often missing from existing tools. Plus, most solutions aren’t open source.
Davia is an open source tool.
Point it at your codebase, and it automatically generates an editable wiki. Text can be edited in a Notion-like editor, while diagrams live on whiteboards and are fully editable too. Everything can be explored and modified either in your IDE or in the editor.
The project is still early, and we’d love feedback, ideas, or experiences from anyone documenting code internally.
GitHub: https://github.com/davialabs/davia

value: Show HN: Open-source editable wiki with whiteboards for your codebase

author: ruben-davia


value: lyorrei

value: Show HN: Magic Mango – Collaborative workspace to reverse-engineer ad creatives

author: lyorrei


value: gusowen

value: After down detector went down with the rest of the internet during the Cloudflare outage today I decided to build a robust, independent tool which checks if down detector is down. Enjoy!!

value: Show HN: I made a down detector for down detector

author: gusowen


value: brettville

value:
Every year I procrastinate my Christmas shopping and end up panic-scrolling through a dozen tabs, adding the wrong size/color, forgetting shipping cutoffs…and ultimately giving people gift cards.
So I built something I wanted:
Once a day, we text you ONE great gift idea.
If you want it, you reply “YES”.
It shows up at your door a few days later.
No app. No checkout. No brainpower.
It’s designed for:
- Busy people
- Last-minute gifters
- People who want to seem thoughtful without the homework
How it works
Membership is $4–6 once, for life
We curate 30 high-quality products from small or indie brands
If you want to learn the brand story (so you sound good when someone unwraps it), reply “MORE” and we email you a short story behind the gift.
Shipping and payment are handled automatically after your first setup
We’re ~500 users today, and so far:
- 52% reply YES at least once
- ~20% buy 5+ times
- The brands love the incremental distribution without marketplace margins
This month (Nov 17–Dec 17) is our Holiday Shopping on Easy Mode run: 30 days, 30 gifts. The first drop just went live.
Try it: https://yesmore.co (US only for now)
Why HN?
I’m especially curious about:
- Thoughts on ways to make an SMS-only UX better than apps for commerce
- Thoughts on scaling a low-frequency, high-intent purchasing model
- Predicting LTV when the # of “drops” is finite
Also, if anyone has product ideas / favorite small brands we should try to feature — I’d love intros.
Happy to answer anything:
Payments, logistics, SMS deliverability, membership economics…
Thanks for checking it out —
and may all your holiday shopping happen in under 30 texts this year!

value: Show HN: Easy Mode Holiday Shopping – Buy Gifts by Text (Reply YES to Purchase)

author: brettville


value: cognitive-sci

value:
The Problem
"Vibing" with LLMs is often too shallow for complex logic, while writing full specifications is cognitively expensive and slow. We need a middle ground that mimics how human programmers gather context—scanning structure before diving into details.
The Solution: Outline Driven Development (ODD)
I've built a "batteries-included" kit for Gemini/Claude/Codex that uses AST analysis to understand code structure rather than just raw text. This relies on a hyper-optimized Rust toolchain (`ast-grep`, `ripgrep`, `jj`, etc.) to feed precise, structural context to the agent.
1. The Prerequisites (The Toolchain)
Core utilities are installed with `target-cpu=native` for maximum local performance.
- Linux/macOS:
```
export RUSTFLAGS="-C target-cpu=native -C opt-level=3 -C codegen-units=1 -C strip=symbols"<p>cargo install lsd ast-grep ripgrep fd-find git-delta tokei && cargo install --locked bat && cargo install --locked --bin jj jj-cli
```
- Windows (PowerShell):
```
$env:RUSTFLAGS="-C target-cpu=native -C opt-level=3 -C codegen-units=1 -C strip=symbols -C link-arg=/LTCG -C link-arg=/OPT:REF"<p>cargo install lsd ast-grep ripgrep fd-find git-delta tokei && cargo install --locked bat && cargo install --locked --bin jj jj-cli
```
2. Integration Kits
I've prepared pre-configured extensions that leverage these local tools for the major AI coding agents. You can install them manually (config injection) or via the CLI wrappers:
- Gemini CLI: https://github.com/OutlineDriven/odin-gemini-cli-extension
- Claude Code: https://github.com/OutlineDriven/odin-claude-plugin
- Codex CLI: https://github.com/OutlineDriven/odin-codex-plugin
- Gemini CLI Quick Installation: `gemini extensions install <a href="https://github.com/OutlineDriven/odin-gemini-cli-extension" rel="nofollow">https://github.com/OutlineDriven/odin-gemini-cli-extension</a>`
- Claude Code Quick Installation: `claude plugin marketplace add OutlineDriven/odin-claude-plugin && claude plugin install odin-claude-plugin@odin-marketplace`

value: Show HN: Outline Driven Development – New AI-Assisted Coding Paradigm; BN

author: cognitive-sci

story_text:
The Problem
"Vibing" with LLMs is often too shallow for complex logic, while writing full specifications is cognitively expensive and slow. We need a middle ground that mimics how human programmers gather context—scanning structure before diving into details.
The Solution: Outline Driven Development (ODD)
I've built a "batteries-included" kit for Gemini/Claude/Codex that uses AST analysis to understand code structure rather than just raw text. This relies on a hyper-optimized Rust toolchain (`ast-grep`, `ripgrep`, `jj`, etc.) to feed precise, structural context to the agent.
1. The Prerequisites (The Toolchain)
Core utilities are installed with `target-cpu=native` for maximum local performance.
- Linux/macOS:
```
export RUSTFLAGS="-C target-cpu=native -C opt-level=3 -C codegen-units=1 -C strip=symbols"<p>cargo install lsd ast-grep ripgrep fd-find git-delta tokei && cargo install --locked bat && cargo install --locked --bin jj jj-cli
```
- Windows (PowerShell):
```
$env:RUSTFLAGS="-C target-cpu=native -C opt-level=3 -C codegen-units=1 -C strip=symbols -C link-arg=/LTCG -C link-arg=/OPT:REF"<p>cargo install lsd ast-grep ripgrep fd-find git-delta tokei && cargo install --locked bat && cargo install --locked --bin jj jj-cli
```
2. Integration Kits
I've prepared pre-configured extensions that leverage these local tools for the major AI coding agents. You can install them manually (config injection) or via the CLI wrappers:
- Gemini CLI: https://github.com/OutlineDriven/odin-gemini-cli-extension
- Claude Code: https://github.com/OutlineDriven/odin-claude-plugin
- Codex CLI: https://github.com/OutlineDriven/odin-codex-plugin
- Gemini CLI Quick Installation: `gemini extensions install https://github.com/OutlineDriven/odin-gemini-cli-extension`<p>- Claude Code Quick Installation: `claude plugin marketplace add OutlineDriven/odin-claude-plugin && claude plugin install odin-claude-plugin@odin-marketplace`


value: Create beautiful pie charts instantly with PieChartGenerator - free online pie chart maker. Customize colors, labels, legends, download as PNG/JPEG/SVG.

value: Show HN: Free Online Pie Chart Generator and Maker


value: honestabraham

value:
I was trying to find a review about a certain privacy product, but all I found was a bunch of spam/affiliate ridden "review" sites.  This led me to some guides which, instead of having any real information, the only page on the privacy guides that seemed to have any meaningful "research" was their VPN page.
So I built Open Source Reviews which anyone can contribute to.
All of the reviews generate from markdown:
https://github.com/opensourcereviews/opensourcereviews.githu...
I'm looking for moderators(maintainers).
Please don't hesitate to fork and submit a PR for review!
I hope someone finds this useful!

value: Show HN: I Spent 200 Hours Compiling These Open Source Reviews

author: honestabraham


value: paperplaneflyr

value:
Vibe coded this startup simulator. It's not much, but I just wanted to know the potential. Also, I used Google's Antigravity IDE for this.
Feel free to leave comments on here or at https://github.com/sumant1122/Startup-Simulator

value: Show HN: Startup Simulator

author: paperplaneflyr

title: Show HN: Startup Simulator


value:
CacheCat is a Chrome extension (Manifest V3) that provides a full-featured dashboard to view, edit, and manage all types of website storage:
- Cookies (with full details: domain, path, expiry, security flags)
- Local Storage & Session Storage (with JSON validation, import/export)
- IndexedDB (database inspection, CRUD operations, search)
- Cache Storage (view entries, preview responses, refetch)
Built with React and Vite. 100% local operation - no data collection or tracking. Open source (MIT).
Perfect for developers debugging storage issues, QA testers, and power users who want more control over website data.
Available on Chrome Web Store: https://chromewebstore.google.com/detail/cachecat/kkfchdmglc...

value: Show HN: CacheCat – Manage all website storage types from one dashboard


value: namegulf

value:
We’ve been building NameGULF.com since 2023 to modernize how domains are traded.
Most marketplaces still feel stuck in the early 2000s — slow interfaces, unclear pricing, and hidden layers between buyers and sellers.
We focused on clean architecture, transparent listings, and tools that make ownership and transactions friction less.
Everything is verified, searchable, and designed for people who actually care about domains.
We’re privately funded, based in Seattle, and open to feedback from anyone who cares about better infrastructure for digital real estate.
Would love your thoughts on what we got right, what we missed, and what to build next.

value: Show HN: NameGulf.com Domain Marketplace bridging founders with premium domains

author: namegulf


value: railspress

value:
Hi HN!
I built NarayanaDB, a high-performance columnar database that doubles as a cognitive AGI platform. It integrates:
 • Conscience Persistent Loop (CPL) – continuous thought loop for reasoning
 • Memory systems – episodic, semantic, procedural, working memory
 • Narrative identity – traits, genetics, and personality modeling
 • Moral reasoning – optional Talking Cricket layer for ethical decision-making
 • World interface – sensory and motor interaction for agents
 • LLM integration – reasoning, memory summarization, principle evolution
It’s fully modular, pluggable, and designed for researchers, AGI enthusiasts, and developers who want to experiment with morally-aware, learning agents.
Repo & docs: https://github.com/carlosbarbosamexico/narayana
Curious to hear your thoughts, feedback, or potential use cases.

value: Show HN: NarayanaDB – Cognitive Database and AGI Research Platform

author: railspress


value: nkheart

value:
I built "kk", a small Bash wrapper around kubectl that makes common Kubernetes workflows faster. It's not a plugin or a compiled binary. It's just a single script you can drop into ~/bin.
The goal is to reduce repetitive kubectl patterns without replacing kubectl itself.
Some things it helps with:
- pod selection by substring (auto-fzf if available)
- multi-pod logs with prefixing and grep support
- quick exec into pods
- checking the actual images running in pods
- restarting deployments with pattern matching
- port-forwarding with pod auto-selection
- quick describe/top/events
- context switching shortcuts
Examples:

    kk pods api
    kk sh api
    kk logs api -f -g ERROR
    kk images api
    kk restart api
    kk pf api 8080:80
    kk desc api
    kk top api
    kk events
    kk ctx
    kk deploys

Installation:

    curl -o ~/bin/kk https://raw.githubusercontent.com/heart/kk-Kubernetes-Power-Helper-CLI/main/kk
    chmod +x ~/bin/kk

Repo:
https://github.com/heart/kk-Kubernetes-Power-Helper-CLI
Happy to hear feedback, suggestions, or ideas for small helpers to improve the kubectl experience.

value: Show HN: Kk – A tiny Bash CLI that makes kubectl faster

author: nkheart


value: StealthyStart

value:
What it does
App Screenshot Kit converts raw ios screenshots into ios App Store compliant image sets. It removes the usual workflow of importing into a design tool, placing into device frames, resizing for every requirement, and fixing pixel mismatches.
Why I built it
I kept running into App Store rejections caused by single-pixel errors after exporting from Figma. I also noticed frequent posts from developers dealing with the same issue, especially around maintaining consistent sizes across devices. It felt like a simple formatting task that had become too dependent on design software.
I wanted a way to go directly from raw screenshots to final exported sets without opening a design tool.
How it works
Upload iOS screenshots (PNG/JPEG)
Pick a device frame
Add optional headline text
Export all required sizes in one batch
No account required
Demo
Video walkthrough: https://youtu.be/UnkHflYzwak?si=_WcF9ykskRyLH8Sb
Live editor: https://app.appscreenshotkit.com/editor
What’s different
Most screenshot tools either require account creation, rely heavily on template editors, or depend on a Figma/Canva workflow. This tool tries to handle the entire formatting process directly from the browser with minimal steps.
Looking for feedback
Any device frames or formats that should be added?
Does the export flow cover the sizes you typically need?
Are there pain points in your own App Store screenshot process that this should solve?
Would support for Google Play be useful?
Happy to answer technical questions.
Cheers

value: Show HN: App Screenshot Kit – App Store screenshots from raw images

author: StealthyStart


value: I built an iOS app that lets you point your phone at a paper invite or screenshot, review the parsed details, and drop the event straight into your calendar, so you can capture meetings in seconds instead of typing.

value: Show HN: Lumical – scan any meeting invite into your calendar in seconds


value: TIL about Google's Antigravity. a new AI Agents experience on top of existing tooling (A VSCode fork IDE, Agentic Chromium based browser and Electron based UI for Agents orchestration. Its so meta, that I wrote about using it. Its quirky, but fun.

value: Show HN: I blogged about Google Antigravity using Antigravity


value: laihj

value:
Hi HN,
I’ve been building a running app called PaceGuru. The idea is simple:
Many running apps give you distance, pace, and heart rate — but very few help you understand what those numbers mean for your progress.
PaceGuru focuses on two things:
1. *Meaningful visualization*
   - A 6-axis radar chart shows how your recent training distributes across six pace zones (easy, aerobic, marathon pace, threshold, intervals, speed endurance).
   - You can set a target training ratio, and the chart fills automatically based on your workout history, making it easy to see whether your training structure matches your goals.
   - Widgets and Apple Watch complications bring progress and daily training metrics into your phone and watch face — a small “companion” to keep you moving forward.
2. *Personalized training*
   - Users can build their own schedule manually, and workouts sync automatically to the Apple Watch.
   - The app includes structured single-focus development blocks (aerobic, threshold, VO₂max, speed endurance, etc.).
   - There’s also a full Hansons Marathon Plan generator: enter your marathon goal and race date, and the app generates an 18-week schedule.
The app is available on iOS, and I wrote a more complete post here (screenshots, details, and design philosophy):
https://www.paceguru.app/blog/en/2025-11-14-184-full-feature
I’d love feedback — especially:
- Is the training visualization meaningful?
- What would you add or simplify?
- Do you think this approach improves clarity for self-coached runners?
Thanks!

value: Show HN: PaceGuru – Visualizing data and guiding personalized training

author: laihj


value:
I’ve been working on a personal project called Codebox, a self-hosted system for provisioning remote development workspaces in a distributed way. I built it because I wanted simple reproducible development environments that could run across multiple machines without opening ports or relying on reverse tunnels.
How it works:
- A central server provides a web UI and acts as the entry point.
- Runners host and manage workspaces. They must be able to reach the main server, but not the vice versa
- An agent inside each workspace handles SSH access and exposes HTTP services running in the containers.
- A CLI on the user’s machine acts as an SSH proxy to connect to the workspaces.
This architecture lets you distribute the workload across different machines and networks while keeping deployment relatively simple.
I’m particularly interested in feedback about security and scalability.
Repo: https://github.com/davidebianchi03/codebox
Happy to answer questions or discuss design decisions.

value: Show HN: Codebox, a Provider of Remote Workspaces


value:
Hey folks, I'm a student dev and built a small tool for Linux called SimplyToast.
It’s a lightweight app for viewing background processes, managing startup apps, and checking their system impact. No root required, works on Ubuntu/GNOME out of the box, and comes with .deb + AppImage builds.
This isn’t meant to be some big “optimizer” app — just a clean, simple way to see what’s running and control what launches at startup.
Would love feedback regarding this. contact me on discord: toast.1599
regarding anything about this project. thanks!

value: Show HN: SimplyToast – A simple Linux startup and background process manager


value: indest

value: Also on PH

value: Show HN: Slopper: Private AI Replies

author: indest

story_text: Also on PH

title: Show HN: Slopper: Private AI Replies


value: toutoulliou

value:
My project ShowMySites.com just reached a nice milestone: 400 websites have now been added to the directory.
ShowMySites is a simple and lightweight website directory where anyone can submit their site. You need to create an account or sign in with Google, but the service itself is completely free and has no hidden fees or spammy stuff.
If you want to try it or add your own website, you can check it out here:
https://www.showmysites.com/
Feedback from the HN community is always welcome!

value: Show HN: I built a simple website directory and it just passed 400 submissions

author: toutoulliou


value: brandonmillsai

value: Show HN: Dream Decoder AI – Jungian dream analysis with 3D visualization

author: brandonmillsai


value: sentinelsignal

value:
Hi there!
I recently released my first application to Steam. Its purpose is to keep track of your gaming time, let you set weekly gaming goals and flexible daily play limits. Warn you visually while you are in game if you are approaching to your limit to make your aware including enforcement of your limit if you don't choose to extend your game session as well.
I would be happy to hear your comments and feedbacks!

value: Show HN: I released Steam utility "Sentinel Signal" to manage your gaming time

author: sentinelsignal


value: donaldng

value: Show HN: We Ditched the Visual Editor for Simpler AI Experimentation

author: donaldng


value: shdalex

value:
Hi HN,
I built Leado because I kept noticing something strange while manually browsing Reddit:
people were constantly asking for recommendations, comparing tools, and describing problems
that matched exactly what many founders and indie hackers are building.
The opportunity was real, but the visibility was horrible.
Most of these posts only stay “hot” for a short window, and by the time you find them,
someone else has already replied or the moment has passed.
So I created an agent that:
• watches selected subreddits in real time
• detects buying-intent patterns (recommendation posts, tool comparisons, pain points)
• sends alerts the moment a relevant thread appears
• helps you engage without being salesy
• and organizes everything in a simple dashboard
This started as a manual workflow I used to generate 500+ warm leads on Reddit,
and I turned it into a tool because others kept asking how to replicate the system.
Live demo + details here:
https://leado.co
If you're interested, I also wrote a full breakdown of the manual process:
https://leado.co/blog/reddit-marketing-playbook-500-leads
Happy to answer questions, share the tech stack, discuss the intent-detection model,
or walk through how I approached the real-time monitoring.
Feedback is welcome. Thanks for reading!

value: Show HN: Leado – An AI Agent That Finds Reddit High-Intent Threads in Real Time

author: shdalex


value: funsi

value:
I built an interactive solar panel shade simulator that lets you click on individual solar cells to apply shade and instantly see how it affects power production at the cell, string, and system level.
The goal is to make the often-confusing behavior of shaded solar panels intuitive—especially how string current is limited by the most-shaded cell, and how bypass diodes change the story.
Why I built it
Shading is one of the least intuitive aspects of solar PV design, and most explanations are either too simplistic or too academic. This tool aims to bridge that gap with a hands-on visualization you can play with. Also, I wanted to try how good Lovable really is :)

value: Show HN: Solar Panel Shade Simulator – Visualize How Shading Impacts PV Output

author: funsi


value:
I’ve been building a small hardware box that runs local LLMs like Mistral, Qwen and Llama, and exposes an OpenAI compatible API on your local network. There’s no cloud, no login system and no telemetry. I built it because a lot of small firms want ChatGPTbstyle tools but can’t use cloud AI for privacy or compliance reasons, and most don’t want to deal with GPU servers, drivers, Docker or model configs. The aim is to make local AI feel as simple as plugging in a router.
Right now the box boots into a very simple web UI where you choose a model and start using it. The API follows the OpenAI format for chat completions and embeddings. It can run different models depending on the hardware you pick, either a Jetson Orin Nano or an x86 mini-PC with a GPU. It stores data locally, supports basic RAG indexing and only exposes itself on the LAN by default.
A few things still aren’t working. There’s no multi-user rate limiting yet. The RAG quality is basic and I’m still improving chunking and reranking. The Orin runs hot under heavy load, so thermal performance needs work. It’s also still a prototype rather than a finished consumer product.
On the technical side, it runs containerized model servers using Ollama and some custom runners. Models load through GGUF or TensorRT-LLM depending on the hardware. The API layer follows the OpenAI spec. The RAG pipeline uses local embeddings and a vector database. The software stack is a mix of TypeScript and Python.
I’m looking for feedback from anyone who has built or deployed local inference before. I’m trying to understand what thermal and power issues you’ve run into, whether a drop-in OpenAI compatible box is actually useful to small teams, what hardware setups I should consider, and any honest critiques of the idea.

value: Show HN: Small hardware box that runs local LLMs and exposes an OpenAI API


value: fredmb

value:
I generate a unique email alias for all web services that I sign up to, so I made a CLI tool to make it easy to instantly create or get an alias for a website.
While I'm planning to eventually self-host anonaddy[1] or SimpleLogin[2], I'm currently happy with Fastmail.com's masked email feature[3].
90% of my own usage consists of entering `masked_fastmail website.com`, which will get the alias for website.com or create one if it doesn't exist. The alias is automatically copied to clipboard. There's a GIF of how this works in the project README together with some more examples.
The CLI tool is written in Go and is very simple. I've used it myself for almost 1 year now. I made some upgrades yesterday and wanted to share it here in case it's useful for someone else :)
[1] https://github.com/anonaddy/anonaddy
[2] https://github.com/simple-login/app
[3] https://www.fastmail.com/features/masked-email/

value: Show HN: Fastmail.com masked email CLI tool

author: fredmb


value: emrekuc

value:
I’ve been working on synch, an AI-supported dating app that focuses on emotional intelligence rather than infinite swiping. Instead of random matches, users interact with an AI coach (multi-agent system) that analyzes preferences, values, and communication patterns to suggest meaningful connections.
Happy to get thoughts on the tech approach and where we can improve.

value: Show HN: Synch- an AI dating app with an emotionally intelligent coach

author: emrekuc


value: Built Pydantic-style validation for Go after struggling with struct tags in LLM apps. Generate JSON Schema from Go code, validate responses, and proper union type support. Single source of truth for schema gen + validation.

value: Show HN: Godantic – JSON Schema and Validation for Go LLM Apps


value: alexjreid

value:
A Zig package for implementing Excel custom functions against the ancient C SDK.
This exists because I wanted to learn about Zig's C interop and comptime to see if it was possible to make the Excel C SDK slightly nicer to work with.
It's just a demo, I wouldn't use it for anything important, but I learnt a lot doing it. There is also a demo repo: https://github.com/AlexJReid/zigxll-standalone

value: Show HN: Excel Custom Functions in Zig

author: alexjreid

title: Show HN: Excel Custom Functions in Zig


value: aggarwalachal

value:
We were running into the issue where it was extremely hard to manage and juggle multiple calendars across personal, work, and sometimes multiple clients.
The problem was not so much what I can see, but rather what time others can see on my calendar as available.
Hence, it made sense for us to sync calendars across accounts.

value: Show HN: We built an easy way to sync multiple Google Calendars

author: aggarwalachal


value: micksmi

value: Show HN: Papers with Code Meets Elicit – ResearchLit

author: micksmi


value: DenisDolya

value:
For decades, C programmers banned gets(). We found a way.
Two simple rules. Four lines of code. Perfect safety.
No more fgets() complexity. No more buffer overflows.
See how: https://github.com/Ferki-git-creator/slfg

value: Show HN: SLFG: We Made Gets() Safe. Everyone Said It Was Impossible

author: DenisDolya


value: parasochka

value:
I made a small Chrome extension because switching tabs to ChatGPT all day was getting annoying. Sidely opens your existing ChatGPT session in the Chrome side panel.
No backend, no tracking, no page injections. Just a lightweight shortcut to ChatGPT.
Would appreciate feedback on the UX or anything that feels rough.
Chrome Web Store:
https://chromewebstore.google.com/detail/sidely-chatgpt-side...

value: Show HN: Sidely a minimal ChatGPT sidebar for Chrome (no back end no injections)

author: parasochka


value: dioniceOS

value:
I’ve released an experimental quantum computing framework that grew out of my own operator/graph work: Q⊗DASH (MetatronQSO)
Rust core crate: metatron-qso-rs
Python package: metatron_qso
GitHub: https://github.com/LashSesh/qso
crates.io: https://crates.io/crates/metatron-qso-rs
PyPI: https://pypi.org/project/metatron_qso/
# What it is
MetatronQSO is a Rust-first quantum operator framework with Python bindings. It focuses on graph- and operator-based algorithms: quantum walks, VQE, QAOA-style circuits and related experiments.
Core ideas:
- Rust library for state evolution, circuits, walks and variational algorithms
- PyO3-based Python SDK mirroring the same concepts
- Backend abstraction (local simulator now, room for hardware providers via traits)
- A nontrivial default geometry (a Metatron-cube–style graph) instead of toy line/grid graphs
The goal is not “yet another Qiskit wrapper”, but a self-contained operator core you can bend into your own models.
# Architecture (high level)
The workspace is organized as multiple crates, the key ones:
- metatron-qso-rs: core quantum library (state, operators, circuits, walks, VQE/QAOA, example binaries)
- metatron_qso_py: Python bindings
- backend/telemetry crates for plugging in execution backends and exposing basic metrics
Everything is regular Rust + Cargo, with Python wheels built via maturin.
# Current status
metatron-qso-rs published on crates.io (0.1.x)
metatron_qso published on PyPI (0.1.x)
CI builds Rust + Python, runs tests and some benchmarks
There are docs/notes in the repo explaining the operator model and backend design
It’s early-stage, but it compiles, runs examples, and is usable for experiments if you’re comfortable with Rust (or happy to drive it from Python).
# What I’d like feedback on
Does the Rust API surface feel idiomatic and composable?
For Python users: is the current binding layer something you’d realistically work with, or would you expect a higher-level abstraction?
Is the backend abstraction (local simulator now, future hardware later) structured in a way that’s easy to extend?
Any obvious red flags in how I treat graphs/geometry as the primary object?
If you’re into quantum computing, graph-based algorithms, or unusual Rust workspaces, I’d appreciate any feedback, criticism, or ideas for where this should go next.

value: Show HN: Q⊗DASH – Rust/Python quantum operator framework for graph-based QC

author: dioniceOS


value: csomar

value: Surprisingly, I couldn't find any concise list that is strictly limited to CLI. Most AI-generated searches either fails to find exactly what you are looking for or get the language wrong.

value: Show HN: A list of CLI coding tools similar to Claude Code

author: csomar


value: binsquare

value:
Opensourcing a library that creates an api on getting protected information from MacOS's powermetrics binary.
If you're working on a project that needs detailed information on a mac regarding energy consumption or CPU|GPU utilization, you'll find there is no straight forward api on that.
This library tries to solve that for go devs.

value: Show HN: Open-source library to get detailed power and system info for Macs

author: binsquare


value: qwikhost

value: Discord Chat Exporter helps you save messages as CSV, JSON, or Excel and download media and attachments easily.

value: Show HN: Discord Chat Exporter – Export Discord Messages and Attachments

author: qwikhost


value: I wanted to play Quiplash, but I realized I had to buy it on Steam, someone had to host it on a PC, connect a TV, and everyone had to watch the same screen. It felt way too heavy for a simple party game. So I built TEQ, basically a browser version of Quiplash. No Steam, no TV, no downloads; everyone just joins on their own device. I also added public lobbies so you can play even without friends online.

value: Show HN: TEQ - A Quiplash Alternative in the Browser


value: Show HN: Startup Investing Game

title: Show HN: Startup Investing Game


value: RandomDailyUrls

value: Show HN: I made a better Loreum Ipsum based on Paul Grahams essays

author: RandomDailyUrls


value: fengcen

value:
Hi HN,
I built Sliprail, a launcher for macOS and Windows. It serves as an alternative to tools like Raycast or Alfred, but with a different philosophy regarding interaction design and UI architecture.
My engineering focus has been on ensuring minimal input latency and a snappy response.
Here are a few notable differences:
Space-Driven Arguments: Instead of menu navigation, Sliprail uses the Space key. Type a command (e.g., google), hit Space, and type your arguments (e.g., weather) instantly.
Detached Interfaces: Extensions run in standalone windows rather than being confined to the main launcher bar. This enables richer interfaces for tools like File Search or MCP integrations.
Window Management: Includes a built-in fuzzy search to switch focus between active windows, alongside native window snapping shortcuts.
Custom Algorithm: Uses a distinct fuzzy matching algorithm tuned specifically for mixed app/command priority.
There are other workflow tweaks and architectural choices that distinguish it from existing tools, but I'd love to hear your feedback on these core interactions first.

value: Show HN: Sliprail – A cross-platform launcher with AI and extensions

author: fengcen


value: hilti

value:
I've been building a cross-platform JSONL viewer app that handles multi-GB files. It worked perfectly on macOS (my development machine), but consistently crashed on Windows at exactly 2,650 KB. Here's the debugging journey and the tiny fix that made all the difference.
The Problem
- macOS: Handles 5GB+ files effortlessly
- Windows: Crashes at 2,650 KB every time
- Same codebase, cross-compiled from Mac Silicon to Windows using MinGW
The Investigation
Added detailed logging to track execution. The crash happened during string interning after successfully parsing ~6,000 rows. Not during parsing, not during file I/O, but during the merge phase.
The Root Cause
My StringPool class used std::unordered_map<std::string_view, uint32_t> to deduplicate strings. The string_views pointed into a std::vector<std::string>.
When the vector grew and reallocated, all the string_view keys became dangling pointers. The hash map was full of invalid references.
Why did it work on macOS? Different memory allocator behavior, different default stack sizes (8MB vs 1MB), different reallocation patterns.
The Fix
Before (broken):

    uint32_t intern(std::string_view str) {
        auto it = indices_.find(str);
        if (it != indices_.end()) return it->second;

        uint32_t idx = strings_.size();
        strings_.push_back(std::string(str));
        indices_[std::string_view(strings_.back())] = idx;  // DANGER!
        return idx;
    }

After (fixed):

    uint32_t intern(const std::string& str) {
        auto it = indices_.find(std::string_view(str));
        if (it != indices_.end()) return it->second;

        // Preemptively rebuild if we're about to reallocate
        if (strings_.size() >= strings_.capacity()) {
            strings_.reserve(strings_.capacity() * 2);
            rebuildIndices();  // Fix all string_views!
        }

        uint32_t idx = strings_.size();
        strings_.push_back(str);
        indices_[std::string_view(strings_.back())] = idx;
        return idx;
    }

    void rebuildIndices() {
        indices_.clear();
        for (size_t i = 0; i < strings_.size(); i++) {
            indices_[std::string_view(strings_[i])] = i;
        }
    }

The Result
- 1 million rows: 6 seconds on Windows
- Multi-GB files: No crashes
- ~166,000 rows/second throughput
- Cross-platform stability
Lessons Learned
1. std::string_view is powerful but dangerous - It's a non-owning reference. When the underlying storage moves, you're holding garbage.
2. Cross-platform testing is essential - The bug was invisible on macOS due to different allocator behavior and larger default stack sizes.
3. Structured logging beats debuggers for cross-compilation - I was cross-compiling from Mac to Windows. Adding timestamped logging to a file made the crash point obvious immediately.
4. Small changes, huge impact - One function, ~15 lines of code, turned "crashes at 2MB" into "handles 5GB+ files"
5. Performance stayed excellent - The rebuild only happens during vector reallocation (exponential growth), so amortized cost is negligible.
The Tech Stack
- simdjson (v4.2.2) for parsing
- Multi-threaded parsing (20 threads on my test machine)
- Columnar storage for memory efficiency
- C++17, cross-compiled with MinGW-w64
This was a humbling reminder that the most critical bugs are often the simplest ones, hiding in plain sight behind platform differences.
Happy to discuss the implementation details, simdjson usage, or cross-platform C++ debugging techniques!

value: Show HN: Fixing a single pointer bug unlocked 1M+ row JSON parsing on Windows

author: hilti


value: seanitzel

value: Show HN: After 7+ years, I'm releasing Melodic Mind (a Superapp for musicians)

author: seanitzel


value: ethanYIAI

value: This website quickly recommends suitable icebreaker games based on your scenario, group size, and time, helping teams and meetings build connections and break the ice efficiently. It also offers detailed categories, trending games, and expert facilitation tips for both virtual and in-person groups.

value: Show HN: Ice Breaker Games

author: ethanYIAI

title: Show HN: Ice Breaker Games


value: mertjsx

value:
Folderhost is selfhosted filesharing cloud application. It is written in Go language as a server and Vite + React for the frontend. But the build of the project doesn't need docker to work on Windows or Linux. The Linux build is just 23 MB. No dependencies. You can simply install and try the program.
The main features of the project are managing files, for example creating, copying, deleting, unzipping and etc. The other feature are the Recovery section, here you can recover your deleted files or folders. Also you have a Users system, and there you can give or take their permissions, you can see what other users are doing from the Audit Logs.
It's still not fully completed, if you encounter any bugs or problems feel free to comment or create an issue on GitHub! I'll be so happy if you give it a try! I hope you guys like it!

value: Show HN: Folderhost – selfhosted file sharing app in Go

author: mertjsx


value: Show HN: GetViralSEO – Find competitors' top SEO pages instantly


value: chronolitus

value: Show HN: Hypercamera – a browser-based 4D camera simulator

author: chronolitus


value: bl-ue

value: Show HN: tweakcc (OSS)–customize Claude Code's system prompt and LSP and /title

author: bl-ue


value: bkrisa

value: Show HN: I made a landing page component picker

author: bkrisa


value: ashfromsky

value:
Hi HN,
I recently built YaraDB, a persistent document store, specifically to have a lightweight, Python-native way to handle data with Optimistic Concurrency Control (OCC).
While the database server handles the heavy lifting (WAL persistence, soft deletes), I realized the real value lies in the developer experience. So I built a dedicated Python client that abstracts away the HTTP layer and handles concurrency gracefully.
The client features:
- Native Exception Handling: Maps HTTP 409 conflicts directly to `YaraConflictError` for easy try/except blocks.
- Type Hinting: Fully typed methods for better IDE support.
- Connection Reuse: Uses `requests.Session` for keep-alive connections.
Here is how it looks:

    client = YaraClient("http://localhost:8000")

    try:
        client.update(doc_id="...", version=1, body={...})
    except YaraConflictError:
        # Handle race condition naturally in Python
        print("Data changed by someone else!")

You can find the client here: https://github.com/illusiOxd/yaradb-client-py
And the server logic here: https://github.com/illusiOxd/yaradb
I'd love to hear your thoughts on the client API design!

value: Show HN: YaraDB Python Client – A clean interface for my custom WAL-based DB

author: ashfromsky


value: Show HN: Chess960v2 – The New Fischer Random Chess (over 300 rounds played)


value: revolmich

value:
Built this after working with Intel’s Bluetooth firmware team - we kept seeing builds suddenly fail because memory crept up a few bytes at a time until it overflowed. Then everyone lost hours/days bisecting symbols and linker maps to figure out which commit pushed it over.
So I made a CI tool that tracks firmware memory footprint across commits and flags bloat before it breaks the build.
How it works:
CLI parses ELF + DWARF, extracts per-section/per-symbol/per-file size info
CI uploads reports; the platform stores history and generates diffs
Shows exactly what changed between commits (what grew, where, and by how much)
Optional memory budgets via commit keywords (acts as a CI gate to block regressions)
The report generator is open source: https://github.com/membrowse/membrowse-action
Works with GitHub Actions or any CI, tested on ARM, ESP32, ARC, x86 (multiple toolchains).
There’s also a live demo analyzing MicroPython firmware builds at membrowse.com.
Curious to hear from embedded folks:
* How do you track code size / memory usage today?
* What would stop you from adding this type of check to CI?
* What’s missing that would make this genuinely useful for your workflow?

value: Show HN: MemBrowse - CI/CD memory footprint tracking for embedded firmware

author: revolmich


value: vfssantos

value:
I built Ominipg, a PostgreSQL toolkit for Deno that lets you:
1. Start with an in-memory database for quick prototyping/tests
2. Switch to a local on-disk PGlite DB
3. Move to a real remote PostgreSQL instance
…all using the same API and code, with an optional local↔remote sync mode for offline-first apps.
Why?
Most apps go through these stages:
1. Prototyping/Testing – you just want a fast, zero-setup in-memory DB.
2. Local-first – you want offline capability but still sync to the cloud.
3. Production – you want a full PostgreSQL instance, without rewriting your data layer.
Ominipg is my attempt to make that path smoother.
Modes
- url: ":memory:" – PGlite in WASM, in-memory. Great for tests, demos, or quick spikes. No Postgres install required.
 - url: "path/to/db" – PGlite with disk storage. Nice for desktop apps, CLIs, or local development.
 - url: "postgresql://..." – Direct connection to your remote/production Postgres.
Local + Remote sync (both URLs) – Use a local PGlite DB that automatically syncs with remote Postgres, so you can build offline-first apps or just get faster reads while still persisting everything remotely.
Under the hood, PGlite runs in a Web Worker automatically (when available), so heavy queries don’t block your main thread – you don’t have to think about workers yourself.
Typed CRUD with Mongo-style queries
Instead of writing SQL, you can use MongoDB-style queries with TypeScript types inferred from JSON Schema definitions:
const adults = await db.crud.users.find({
   age: { $gte: 18 },
   status: { $in: ["active", "premium"] },
 });
 // `adults` is fully typed based on your `users` schema
If you prefer, you can also use Drizzle ORM on top, or drop down to raw SQL. Ominipg doesn’t force you into one style.
Example
import { Ominipg, defineSchema } from "jsr:@oxian/ominipg";
const schemas = defineSchema({
   users: {
     schema: {
       type: "object",
       properties: {
         id: { type: "string" },
         name: { type: "string" },
       },
       required: ["id", "name"],
     },
     keys: [{ property: "id" }],
   },
 });
// Start in-memory, later point this to postgresql://... or  ./local.db
 const db = await Ominipg.connect({
   url: ":memory:",
   schemas,
 });
await db.crud.users.insertOne({
   id: "1",
   name: "Alice",
 });
const activeUsers = await db.crud.users.find({
   name: { $in: ["Alice"] },
 });
Links:
- JSR: https://jsr.io/@oxian/ominipg
- GitHub: https://github.com/AxionCompany/ominipg
• A bit about me / what I’m looking for
I’m a co-founder of a software development agency in Brazil. We’ve shipped 500+ projects (many enterprise), and a lot of our success has come from investing in developer productivity and internal tooling, including early bets on the Deno ecosystem. We recently decided to open-source some of these tools. Ominipg is the first of several, I’d love to get feedback from the JS (specially Deno) ecosystem.
In particular, I’d appreciate thoughts on:
 - The API design (especially the CRUD + schema approach)
 - The local + remote sync model
 - Rough edges you hit trying it in a small demo or side project

value: Show HN: Ominipg – Local-First Postgres for Deno

author: vfssantos


value:
I got tired of timestamping tools that force you to upload entire files, so I made OTS-SDK.
It’s a tiny Node/Express server that only ever touches hashes, talks directly to the public OpenTimestamps calendars, and stores nothing except <hash>.ots proofs. Zero original data ever hits disk — ever.
Why it’s cool
• Privacy actually means privacy.
/ots/timestamp SHA-256s whatever you send in memory, drops your raw bytes instantly, and only keeps the 64-char hash + the .ots proof.
If you’re the “trust but verify” type, check src/routes/ots.js and SECURITY.md.
• Day-one production-safe.
Helmet, JSON body limits, separate rate limits for read/write routes, clean error messages, and optional Swagger docs if you drop a spec in. No weird surprises.
• Full REST workflow done right.
Timestamp → verify → download proof → inspect info → upgrade when Bitcoin confirms.
Routes:
/ots/timestamp, /ots/verify, /ots/proof/:hash, /ots/info/:hash, /ots/upgrade/:hash.
• Survives flaky calendars.
It fans out to Alice/Bob/Finney (or whatever you put in OTS_CALENDAR_URLS), wraps both stamp + upgrade calls with timeouts + retries, and overwrites proofs when stronger attestations come in.
• Developer life = painless.
npm run dev (nodemon), npm run e2e / scripts/e2e-smoke.ps1, Dockerfile + docker-compose, everything tunable via .env (JSON limits, rate limits, proof dir, OTS timeouts, etc.).
Usage examples are all in the GitHub repo.
Next ideas
Docker!!!!!!!!
Maybe a little dashboard
MIT-licensed, docs included, SECURITY guide included.
Happy to answer questions — always down to nerd out on timestamping.

value: Show HN: OTS-SDK – a tiny OpenTimestamps API that never keeps your data


value: Show HN: Quantica – A compiled quantum-classical language in Rust/LLVM


value: disintegrator

value:
Hi HN, Georges from the Gram team here. We're really excited to share a major update to Gram, our platform for curating tools for agents, in the form of Gram Functions. Gram initially started out by letting users upload OpenAPI documents and turning them into tools that can be curated into small MCP servers that power your agentic use cases.
We've known for quite some time that many existing REST APIs are simply not suitable as LLM tools and we wanted to solve this problem by letting users simply write code and we would take care of deploying that code for them and hosting MCP servers. We call this Gram Functions and you can get started with it today by running `pnpm create @gram-ai/function` (or `bun create ...`, `npm create ...`).
Under the hood, when you send us code, we provision fly.io machines that run this code behind a Go server listening for tool calls. Once you've deployed, you'll be able to use the Gram dashboard to create a number of MCP servers that have tools generated from this code and any OpenAPI documents you may want to upload. The key thing is you create small MCP servers for your different agents by cherry picking from these sources. This approach to curation helps manage context bloat that massive MCP servers tend to introduce.
Hope you give it a try! The team will be around to respond to questions and feedback.
PS: If you'd like to poke at some code, Gram's code is up here: https://github.com/speakeasy-api/gram

value: Show HN: Gram Functions – Serverless platform for turning code into LLM tools

author: disintegrator


value:
Hi HN,
I'm Paul from Tensordyne. We build AI inference systems and chips on logarithmic math. We've put together an interactive Token Economics Calculator to help make apples-to-apples comparisons of inference hardware across vendors:
<https://www.tensordyne.ai/token-economics-calculator>
We're interested in how closely it lines up with the community's view of the market.
Why we built this
Investors and customers kept asking how our system compares to others (NVIDIA and a growing list of startups). Plenty of publicly available data exists, but it's scattered and inconsistent. News articles, provider sites, Artificial Analysis, MLCommons, and now SemiAnalysis’s new InferenceMAX all publish useful numbers — but using different metrics. That makes “what’s actually better (and at what cost)?” surprisingly hard to answer, especially across the broad range of system providers.
What the calculator does
- Scenario-normalized comparisons: we’ve chosen a few model scenarios and normalized data from different sources to the same key metrics.
- Capacity modeling: we estimate racks needed to support a target user load based on model size and KV-cache needs.
- Cost & power economics: we estimate tokens/$ and tokens/kWh. You can input your own capex, amortization, colocation and energy costs and see how that impacts TCO.
- Architecture: see how different memory architectures (e.g. SRAM-only vs. HBM) could impact profitability.
- Like-for-like: see how model performance varies significantly depending on use case by comparing two configurations for the same model.
Data sources & gaps
We pull from publicly available materials. Where numbers are missing, we estimate (e.g. from chip size / process / HBM capacity) to take a first cut at pricing — and let you swap in your own values.
What we’re hoping to learn from you
- Which metrics matter most for your use case.
- Where our defaults are off (power, users, utilization, etc.).
- Systems we should add (including startups) and links to data.
If you try it, please tell us what’s confusing, missing, or flat-out wrong.
We’ll be in the thread answering questions.

value: Show HN: Token Economics Calculator for AI inference hardware


value: Web Agents like Browser-use and Browserbase need a way to authenticate using their own credentials not yours. I made the first OpenID Connect Provider for Web Agents. Please check out the repo and the website auth-agent.com and let me know your thoughts.

value: Show HN: Web Agents like Browser-use and Browserbase need a way to authenticate


value: mbosch

value:
Hi HN!
We built Speaker Analyzer to solve a simple problem: after long video meetings, I wanted to know who actually spoke, for how long, and how the conversation was distributed. I found myself wondering "did I dominate the conversation?" or "who barely spoke up?" With remote teams using Teams, Zoom, and Google Meet, I can now export these transcript files and easily analyze participation patterns.
What we built:
A privacy-first tool that turns your meeting transcript files (*.vtt) into actionable speaker insights in seconds. Just drag & drop your transcript file and instantly see:
- Speaking time per person
- Word counts and participation percentages
- Turn-taking patterns
- Visual breakdowns and charts
- Most active / least active participants
- Export to CSV/JSON (premium)
As far as privacy:
- Files are processed in-memory and never stored
- Only encrypted speaker names and analytics are saved
- No transcript text is retained
Sample output:  https://www.speakeranalyzer.com/sample-transcript-analysis.p...
Try it: https://speakeranalyzer.com
I'd love feedback on:
- What other metrics would be useful?
- Any other meeting platforms to support?
- UI/UX improvements
Happy to answer questions about the implementation or privacy approach!

value: Show HN: Speaker Analyzer – Get analytics on who spoke how much in your meetings

author: mbosch


value: artursapek

value: Show HN: Option trading P&L visualizer

author: artursapek

title: Show HN: Option trading P&L visualizer


value: billyjei

value:
Hi HN,
I’m Billy, co-founder of ChatterBooth. It’s an anonymous app where people can talk or chat freely without judgment.
The idea came in 2020 when one of my co-founders wanted to share about his mom’s cancer recovery but couldn’t. It made us realize how hard it is to open up online. Finally, we released the app earlier this year.
We’ve also noticed people venting to AI chatbots just to be heard, but AI doesn’t really get you. ChatterBooth is for real human connection, even if it’s anonymous.
In the future, if there’s enough traction, we want to reward people as Conversation Starters or Accommodating Strangers — small gestures to encourage connection.
We launched on the iOS App Store in 23 countries across North America, Europe, and Asia-Pacific and have a few hundred downloads so far. It’s still early, still bootstrapped, but it’s been amazing to see real, honest moments happening in the app.
If this kind of thing interests you or you’ve built something similar, I’d love to hear your thoughts. Check out our site and join our Discord if you want to.
Thanks for reading.

value: Show HN: We built ChatterBooth, an anonymous app to talk and chat freely

author: billyjei


value: caliweed

value: Show HN: Sonets

author: caliweed

title: Show HN: Sonets


value: Show HN: Baserow 2.0 – Self-hosted no-code data platform with automations and AI


value: mf-skjung

value:
Hi HN, I've been working on a new malware detection engine for Linux.
Existing open-source tools rely heavily on signatures, which are easily bypassed by packing or obfuscation. I built SemanticsAV to detect the structural logic of malware rather than just matching hashes.
Key features:
1. AI-Native: Detects evasive threats based on architectural patterns. We are starting with PE and ELF formats, with plans to expand coverage to all malicious execution vectors.
2. Privacy-First: The engine has zero network capabilities. It runs entirely locally on your CPU.
3. Constant-Time Scanning: Unlike traditional AV, performance does not degrade as the number of known threats increases.
4. Free: Free for both personal and commercial use.
Note on Open Source:
The CLI is open source (MIT), but the core detection engine is provided as a closed-source binary. I made this trade-off to protect the IP, but I ensured privacy by removing all networking features from the binary. You can verify this via the CLI code.
I wrote a detailed write-up on the architecture and benchmarks against ClamAV here:
https://semanticsav.hashnode.dev/its-time-to-end-the-era-of-...
Feedback is welcome!

value: Show HN: SemanticsAV – Free, offline AI malware scanner for Linux

author: mf-skjung


value: nl

value:
Like a lot of people I got the $250 Claude Code credit and didn't use it up.
I decided to try to use it up over the weekend using (mostly) my phone and vibe coded a Prolog interpreter.
Now I'm seeing how far I can push it.

value: Show HN: Vibe Prolog

author: nl

title: Show HN: Vibe Prolog


value: npslaney

value:
Hi HN, I'm Nick Slaney and my team is building moneydevkit (https://moneydevkit.com). moneydevkit is the fastest way for anyone to add payments to their website.
It's so fast, I just set the Website to Production Payments speed run WR (4:38.94). Check it out here, I bet you can't beat it (https://x.com/nickslaney/status/1991151978953789614).
We started moneydevkit with the goal of making a payment product that anyone can use. With the rise of AI assisted development, the bar to create value online has never been lower, but a simple search of "stripe rejected" on x or reddit quickly reveals that current payment solutions are not keeping up.
Whether you're in India, Bangladesh, or the Philippines, have a business that is legitimate but "unsupported," and even if you're on the cutting edge of AI development, many people are not able to easily accept value online, and the pain of putting your time into something to not be able to get value out of that time is immense.
moneydevkit has been built with friendly developer tools like supabase and better-auth in mind. As we've built websites ourselves, we've seen how these low / no-code solutions are supercharged by AI development. Being able to hand off a part of your stack that is not your core innovation is incredibly valuable.
It's the first time that payments have been this easy and global. And the way we do it is with Bitcoin under the hood. Why Bitcoin?
+ self-custody Bitcoin is globally accessible
+ Huge fintech apps like CashApp let users spend with Bitcoin without owning / thinking about it
+ Alternatives like stablecoins are fragmented, have bad UX (kills conversion) and are on the path to not be as accessible as Bitcoin
There's a ton more to it, but the key is this: people who cannot accept value online do not care about xyz coin, they care about getting value from their work. moneydevkit makes it easy for these people to accept value online, and in the future we'll make it easy for them to get that value to their local currency.
Excited for you all to try it. There's a lot going on under the hood to make this happen in an easy, developer tool way and there's a lot more to come.

value: Show HN: Moneydevkit – The fastest way for anyone to take payments

author: npslaney


value: ChernovAndrei

value:
We’ve released a JavaScript SDK for running zero-shot time-series forecasting using two modern foundation models:
 • Chronos2 from AWS
 • TiRex from NXAI
The goal is to make it straightforward to run forecasting in any JavaScript or TypeScript environment (web apps, backend services, workflow automation tools) without training, preprocessing, or model hosting. You send a raw numeric array and receive a forecast.
Here is the link on github: https://github.com/S-FM/faim-js-client

value: Show HN: JavaScript SDK for zero-shot time-series forecasting (Chronos2, TiRex)

author: ChernovAndrei


value: forthwall

value:
Hi HN,
I've been working with LLMs in production for a while both as a solo dev building apps for clients and working at an AI startup. The one thing that always was a pain was to pay OpenAI/Gemini/Anthropic a few dollars a month just for me to say "test" or have a CI runner validate some UI code. So I built this server called ChunkBack, that mocks the popular llm provider's functionality but allows you to type in a deterministic language:
`SAY "cheese"` or `TOOLCALL "tool_name" {} "tool response"`
I've had to work in some test environments and give good results for experimenting with CI, but it's still an early project so would love feedback and more testers on.

value: Show HN: ChunkBack – A Fake LLM API server for testing apps without paying

author: forthwall


value: aakiverse

value:
I pivoted from building AI apps to solving something more fundamental: protein intake.
Most people miss their target because protein is inconvenient. So I built a 25 g protein shot you can drink in 3 seconds. 100 ml, 100 calories, zero sugar, zero fat, zero carbs.
Would love feedback from the HN community.

value: Show HN: I built a 100ml shot with 25 g protein and 100 calories

author: aakiverse


value: davidslv

value: Show HN: Terminal roguelike using Entity-Component-System in pure Ruby

author: davidslv


value: Amirali-SR

value:
Achieved 84.35% test accuracy on CIFAR-100 using a standard ResNet-50. Most public implementations top out around 81%, so this result is unusually high for a classic architecture.
Key points:
Heavy augmentations: Mixup, CutMix, ColorJitter, RandomErasing, rotations, affine transforms, and Gaussian blur.
Progressive fine-tuning: ImageNet-pretrained ResNet-50 trained in stages with OneCycleLR and mixed precision.
Streamlit demo: Upload your own images and see real-time CIFAR-100 predictions with confidence scores.
Accessible hardware: Trained on a single GTX 1650 (~15 hours), no massive cluster needed.
Repo & demo: https://github.com/Amirali-SoltaniRad/cifar100-classificatio...
Question for the community:
Has anyone pushed ResNet-50 beyond 85% on CIFAR-100? What tricks worked for you?

value: Show HN: ResNet-50 hits 84.35% on CIFAR-100 with heavy augmentations

author: Amirali-SR


value: rootforce

value:
I was running some experiments to test Gemini 3 and I really liked how it turned out so I thought I would share.
I adjusted the vertical alignment of the sun, because LLMs still aren't good at spatial relationships, and GPT5.1 implemented the responsive design and the volume slider as the API I was using was getting overloaded.
The full setup was Opencode + Gemini 3 (zen) + GPT 5.1 Codex.

value: Show HN: Vaporwave Life

author: rootforce

title: Show HN: Vaporwave Life


value:
Hi HN,
I’ve been building a small tool called IconPackGen, focused on one specific problem:
creating cohesive, visually consistent icon packs using AI.
Most AI image tools can generate nice single images, but producing sets of icons that match each other—style, color logic, geometry—is a different problem. IconPackGen is built specifically for that use case.
What it does
- Generates 9-icon packs based on either:
  - a general theme (e.g., “minimal line icons”, “retro pixel icons”), or
  - a reference image to match style.
- Optional: users can provide 9 individual icon descriptions for more control.
- One click generates:
  - 9 main icons
  - and optionally 9 variations (slight style changes)
  - each generation can be followed with subsequent requests
Export formats:
- PNG, WEBP, ICO, SVG
The SVGs aren’t traced heuristically — they're created using a second model that vectorizes the PNG icons for cleaner results.
Additional features:
- Consistent illustrations (4 per request) — same idea as icons, but with a separate model tuned for illustrations.
- Labels — generate styled text/labels that match your icon theme.
- UI mockups — generate small UI component mockups, either from text or a reference image (useful as a reference for icon generation too).
- GIF export — turn icons into small animated loops using an animation model.
Why I built it
Designing icon packs manually is tedious and expensive, and most AI tools don't preserve style consistency across sets. I wanted something that made icon-pack creation near-instant, especially for indie devs, hobby projects, and internal tools.
I’d love to get feedback from the HN community:
- Does the workflow make sense?
- What formats or features are missing?
- Is this useful for your projects?
Try it out here: https://iconpackgen.com
Happy to answer questions or dive into technical details about the models or vectorization pipeline.

value: Show HN: IconPackGen – Generate Visually Consistent Icon Packs with AI


value: gori

value: Why not make a useful LLM wrapper for once? Websites are officially over. Teletext is the future?<p>Made at my favourite kind of hackathon - Stupid Hackathon.

value: Show HN: Textable! It's Lovable, but Teletext

author: gori


value: platypii

value:
There’s an important problem with AI that nobody’s talking about. AI’s entire lifecycle is tons of data in for training, and an even larger amount of text data out. Traditional tools can’t handle the sheer volume of text, leaving teams overwhelmed and unable to make their data work for them.
Today we’re launching Hyperparam, a browser-native app for exploring and transforming multi-gigabyte datasets in real time. It combines a fast UI that can stream huge unstructured datasets with an army of AI agents that can score, label, filter, and categorize them. Now you can actually make sense of AI-scale data instead of drowning in it.
Example: Using the chat, ask Hyperparam’s AI agent to score every conversation in a 100K-row dataset for sycophancy, filter out the worst responses, adjust prompts, regenerate, and export your dataset V2. It all runs in one browser tab with no waiting and no lag.
It’s free while it’s in beta if you want to try it on your own data.

value: Show HN: We built an AI tool for working with massive LLM chat log datasets

author: platypii


value: SilkForgeAi

value: 10k+ long-form synthetic outputs, for sale $250k outright

value: Show HN: SilkForge-Text-2025

author: SilkForgeAi

title: Show HN: SilkForge-Text-2025


value: mesadb

value:
Slave is a macOS app for voice-in, voice-out.
Dictate in most languages. Types into any app.
Listen back with local Piper TTS.
3,000 words free. Then $6.99/month.
Next: joins meetings, transcribes, writes short notes.
Later: lightweight Obsidian-style notes built from your text.
Built on Whisper + Piper. Runs on your machine.
Feedback on UX, speed, and pricing is welcome.

value: Show HN: Slave – local dictation and TTS for macOS (3k words free)

author: mesadb


value:
Hey HN! I built pctx, a framework that lets AI agents execute code directly instead of making tool calls to save on tokens on MCP.
I've been working on code generation in Rust for 2 years, mostly fighting with OpenAPI specs that are either missing or incorrect. MCP's self-documenting nature made this a fun project to tackle since the servers describe their own capabilities accurately. I could focus on building execution sandboxes instead of wrestling with bad specs. After seeing how Cloudflare and Anthropic's Code Mode implementations reduced tokens, I decided to build an open-source version with a focus on correctness and local-first design.
pctx prioritizes reliability (TypeScript validation pre execution) and DevEx (no dependencies, 100% local, built-in MCP auth)
Technical details:
- Two locked-down Deno sandboxes:
    - TypeScript compilation/validation (pre-execution)
    - Execution with MCP network access only
- Compiles to a single binary, no dependencies
- Built-in TypeScript code generator and MCP auth utilities
- Uses the official rmcp client/server within the execution runtime
Coming soon:
- Automatic authentication of the pctx server
- Python and TypeScript SDKs for using natively in agent frameworks
- Anything else people want
- One-click cloud deployment (see website)
GitHub: https://github.com/portofcontext/pctx
Website: https://portofcontext.com
Would love your feedback on this. Thanks!

value: Show HN: Pctx – OSS to build efficient AI agents with Code Mode


value: ciclotrone

value:
I'm the main developer behind vHPC, a SLURM HPC cluster in a docker compose.
As part of my job, I'm working on a software solution that needs to interact with one of the largest Italian HPC clusters (Cineca Leonardo, 270 PFLOPS). Of course developing on the production system was out of question, as it would have led to unbearably long feedback loops. I thus started looking around for existing containerised solutions, which were always lacking some key ingredient in order to suitably mock our target system (accounting, MPI, out of date software, ...).
I thus decided that it was worth it to make my own virtual cluster from scratch, learning a thing or two about SLURM in the process. Even though it satisfies the particular needs of the project I'm working on, I tried to keep vHPC as simple and versatile as possible.
I proposed the company to open source it, and as of this morning (CET) vHPC is FLOSS for others to use and tweak. I am around to answer any question.

value: Show HN: Virtual SLURM HPC cluster in a Docker Compose

author: ciclotrone


value:
Hi HN,
Can current AI systems actually run a business?
There’s a growing belief that LLM agents can already manage entire teams, replace the entire software stack or even act as an AI CEO.
So we built a controlled, measurable environment to evaluate this premise.
Why did we build this benchmark?
A modern enterprise operates in a dynamic environment with high uncertainty and incomplete information. The CEO has to deal with delayed consequences, staffing/resource tradeoffs and death by a thousand cuts of failure modes.
If we ever want AI systems that can meaningfully make operational or strategic decisions, say an AI CEO, then they must be able to handle these dynamics.
So we made one.
What did we build?
Mini Amusement Parks (MAPs) is a RollerCoaster Tycoon style business simulator with:
- Stochastic events
- Incomplete information
- Staffing, restocking, maintenance
- Long horizon planning
- Compounding operational failures
- Resource constraints
- Spatial layout affecting outcomes
You can play it & make it to the leaderboard here: https://maps.skyfall.ai/play (it’s fun)
It looks like a simple game. But underneath, it’s a benchmark designed to answer one question:
Can an agent operate a business coherently over time?
What we tested
We evaluated:
- Humans (internal and external testers)
- Multiple GPT-5 agents
- Variants with additional tools, documents, practice mode, planning scaffolds, etc.
We intentionally stacked in favour of the models - full documentation, step by step action interfaces, sandbox exploration mode, extra observations, multiple prompting strategies, etc.
What happened?
Humans destroyed the agents by FAR.
Even the strongest model, with documentation, tool use, and sandbox “practice”, reached <10% of human performance.
The failure modes were consistent:
- chasing flashy upgrades instead of profitable ones
- ignoring maintenance, staffing, restocking
- overreacting to noise
- zero long-term plan
- sandbox training often made things worse
It became clear: LLMs can use tools, but they cannot run systems. They break when randomness, time, and spatial constraints matter.
Why does this matter?
There’s a growing narrative that:
- LLMs will run entire companies
- LLMs will take over the jobs of CEOs
- LLMs can be autonomous agents
- LLMs can manage workflows end-to-end
MAPs show the complete opposite.
Operating a business requires: foresight, risk modeling, temporal reasoning, causal understanding, prioritization under uncertainty, adaptive planning.
These are the basics of what a functional and real AI CEO would need and this is exactly where the current models break.
If an LLM can’t run a toy business, how can you trust it with a real business?
This benchmark is our first step toward understanding what an AI system would actually need in order to exhibit enterprise level decision making and the basics of the AI CEO.
AI CEO is not a chatbot, not chain of thought, definitely not an agent wrapper but a true demonstration of operational intelligence.
We’re sharing this because:
- we want the community to try to beat the models
- we want criticism of the benchmark
- most importantly, we want an honest discussion about what “AI CEO” is and should do (surely it’s not LLMs)
If you want to try beating the agents (it’s fun!):
https://maps.skyfall.ai/play
If you want the read more about it, you can do so here:  https://skyfall.ai/blog/building-the-foundations-of-an-ai-ce...
Check our the launch video here: https://www.youtube.com/watch?v=7oqVAWw5Ii8
Happy to answer questions in the thread.

value: Show HN: A business SIM where humans beat GPT-5 by 9.8 X


value: un-nf

value: Show HN: I built 404 a network solution to client fingerprinting at the endpoint

author: un-nf


value: publicusagetax

value:
A system designed to solve a structural problem: modern economies no longer generate enough taxable income to fund public infrastructure once automation, AI, and capital loops dominate value creation.
PUT replaces income and corporate taxes with footprint-based contributions collected automatically at the payment-rail layer.
It protects essentials, eliminates compliance overhead, and treats labor, capital, and automation identically.
This white paper (the first of a three-part series) focuses on the collection layer:
 • how usage/footprint is measured,
 • how contribution is applied in real time,
 • why the base becomes broad and stable,
 • and how the system works without surveillance or reporting.
Full paper (Markdown):
PUT White Paper I.md
Feedback, critique, and stress tests welcome.

value: Show HN: A Tax System That Captures Automation's Value

author: publicusagetax


value:
I built a CLI to benchmark DNS resolvers after discovering DNS was adding 300ms to my API requests.
v0.3.0 just released with new features:
  compare: Test single domain across all resolvers
  top: Rank resolvers by latency/reliability/balanced
  monitor: Continuous tracking with threshold alerts
1,400+ downloads in first week.
Quick start:
pip install dns-benchmark-tool
dns-benchmark compare --domain google.com
CLI stays free forever. Hosted version (multi-region, historical tracking, alerts) coming Q1 2026.
GitHub: https://github.com/frankovo/dns-benchmark-tool
Feedback: https://forms.gle/BJBiyBFvRJHskyR57
Built with Python + dnspython. Open to questions and feedback!

value: Show HN: DNS Benchmark Tool – Compare and monitor resolvers


value: alielroby

value:
Hello HN,
I built a free tool to help founders practice for their YC interviews. It currently has 70+ of the latest questions asked in recent batches.
The backstory:
I’ve applied to YC 3 times now. I actually haven’t received a response yet (no interview invitations), but I wanted to build something useful for the community regardless.
Since I’ve spent so much time researching the process, I compiled the most frequent and difficult questions into this app to help founders simulate the actual 10-minute pressure test.
I'm wishing all the best to the people who got interviews. I hope this helps you prep.
Would love to hear your feedback or if there are other questions I should add.

value: Show HN: I built a YC interview practice tool (70 latest questions)

author: alielroby


value: tonghohin

value:
I don’t see any good map components for shadcn/ui yet, so I built one with Leaflet and React Leaflet. It matches the shadcn/ui style, and since it’s Leaflet, it’s fully open source and doesn’t require any API keys. You can just bring maps to your project with a simple install command.
Github: https://github.com/tonghohin/shadcn-map

value: Show HN: A map component for shadcn/ui

author: tonghohin

title: Show HN: A map component for shadcn/ui


value: manzt

value:
Hi HN! We're excited to release our VS Code/Cursor extension for marimo [1], an open-source, reactive Python notebook.
This extension provides a native experience for working with marimo notebooks, a long-requested feature that we’ve worked hard to get right.
An LSP-first architecture
The core of our extension is a marimo notebook language server (marimo-lsp [2]). As far as we know, it’s the first notebook runtime to take this approach. The Language Server Protocol (LSP) [3] offers a small but important set of notebook-related capabilities that we use for document and kernel syncing; everything else is handled through custom actions and messages.
By building on LSP, we aim to create a path to expose marimo capabilities in additional environments (beyond VS Code/Cursor). The notebook features in LSP are still limited, but as the protocol evolves, we’ll be able to shift more functionality out of the extension and into the language server, making it available to a wider range of editors and tools. For example, this could enable:
- structural edits to notebook documents (e.g., adding or removing cells) [4]
- editor hover information that reflects the live runtime values of variables
Deep uv integration with PEP 723
Because marimo notebooks are plain Python files, we adopt PEP 723-style inline metadata [5] to describe a notebook’s environment. Tools such as uv already support this format: they read the metadata block, build or update the corresponding environment, and run the script inside it.
The marimo CLI already integrates with uv in "sandbox" mode [6] to manage an isolated environment defined by PEP 723 metadata for a single notebook. In the extension, our uv-based “sandbox controller” manages multiple notebooks: each notebook gets its own isolated, cached environment. The controller keeps the environment aligned with the dependencies declared in the file and can update that metadata automatically when imports are missing.
uv normally syncs such environments whenever you run a script, ensuring it matches the dependencies declared in its metadata; we apply this concept at the cell level so the environment stays in sync whenever cells run. The same cached uv environment is reused if you run the notebook as a script via uv (e.g., uv run notebook.py).
—-------
This work has been a complete rewrite, and we're grateful to the community for early feedback. While VS Code and the LSP support a subset of notebook features, the ecosystem has been shaped heavily by Jupyter, and we’ve had to work around some assumptions baked into existing APIs. We’ve been coordinating with the VS Code team and hope our work can help broaden the conversation—pushing the LSP notebook model forward and making room for runtimes that aren’t Jupyter-based.
We'd love to hear your thoughts!
[1] https://marimo.io
[2] https://github.com/marimo-team/marimo-lsp
[3] https://microsoft.github.io/language-server-protocol/
[4] https://github.com/microsoft/vscode-languageserver-node/issu...
[5] https://peps.python.org/pep-0723/
[6] https://docs.marimo.io/guides/package_reproducibility/

value: Show HN: Marimo VS Code extension – Python notebooks built on LSP and uv

author: manzt


value:
I have been working on a personal project for about 3 weeks now. You can go to anywhere using Street View and change a year which will then show what that place might have looked like in that year. Kind of like you traveled time to that place.
You can then generate a video, chat with a tour guide and generate a 3d world and even walk using VR (my personal favorite feature).
And here are some of my personal favorite if you guys want to just explore:
https://www.timejourney.ai/time/6903e39ac7a0142ce0ab4cc5 -- Golden Gate being constructed
https://www.timejourney.ai/time/690b76035362834122719553 -- Times Square in 1880
https://www.timejourney.ai/time/690dad930e74fc08393d9f15 -- Hiroshima in 1945
It's still a work in progress. Would appreciate it if anyone of you could check it out and give feedback. It works best on computer.

value: Show HN: Time Journey

title: Show HN: Time Journey


value: ericcurtin

value:
We've been working with Docker to make running quantized models easier with Docker. This integration allows users to pull and run Unsloth-optimized models using the native Docker CLI.
Key features:
Uses docker model run syntax.
Supports Dynamic GGUFs (handling quantization overhead).
Cross-platform support.
Example usage: docker model run ai/gpt-oss:20B
Happy to answer questions about the implementation or the quantization methods used.
https://docs.unsloth.ai/models/how-to-run-llms-with-docker

value: Show HN: Run Unsloth Dynamic GGUFs using Docker model runner

author: ericcurtin


value: aebranton

value: Show HN: Build AI chatbots and structured APIs easily with custom RAG knowledge

author: aebranton


value: toebee

value: Dia2 is an open-weights, streaming dialogue TTS model. It is capable of generating speech without a full sentence, making it suitable for low-latency speech-to-speech systems. It can generate up to 2 minutes of English audio, and supports audio prefixing.<p>The inference code and weights (1B / 2B variants) are uploaded to Github and Hugging Face with Apache 2.0 license, to accelerate research. This work was heavily influenced by KyutaiTTS, Mimi, and Sesame. We thank the TPU research cloud for providing computational resources.

value: Show HN: Dia2, open-weights TTS model for realtime speech to speech

author: toebee