Show HN for April 9, 2026

I love C and C++, but setting up projects can sometimes be a pain.

Every time I wanted to start something new I'd spend the first hour writing CMakeLists.txt, figuring out find_package, copying boilerplate from my last project, and googling why my library isn't linking. By the time the project was actually set up I'd lost all momentum.

So, I built Craft - a lightweight build and workflow tool for C and C++. Instead of writing CMake, your project configuration goes in a simple craft.toml:

  [project]
  name = "my_app"
  version = "0.1.0"
  language = "c"
  c_standard = 99

  [build]
  type = "executable"

Run craft build and Craft generates the CMakeLists.txt automatically and builds your project. Want to add dependencies? That's just a simple command:

  craft add --git https://github.com/raysan5/raylib --links raylib
  craft add --path ../my_library
  craft add sfml

Craft will clone the dependency, regenerate the CMake, and rebuild your project for you.

Other Craft features: craft init - adopt an existing C/C++ project into Craft or initialize an empty directory. craft template - save any project structure as a template to be initialized later. craft gen - generate header and source files with starter boilerplate code. craft upgrade - keeps itself up to date.

CMakeLists.extra.cmake for anything that Craft does not yet handle.

Cross platform - macOS, Linux, Windows.

It is still early (I just got it to v1.0.0) but I am excited to be able to share it and keep improving it.

Would love feedback. Please also feel free to make pull requests if you want to help with development!

Hi HN! I've just released CSS Studio, a design tool that lives on your site, runs on your browser, sends updates to your existing AI agent, which edits any codebase. You can actually play around with the latest version directly on the site.

Technically, the way this works is you view your site in dev mode and start editing it. In your agent, you can run /studio which then polls (or uses Claude Channels) an MCP server. Changes are streamed as JSON via the MCP, along with some viewport and URL information, and the skill has some instructions on how best to implement them.

It contains a lot of the tools you'd expect from a visual editing tool, like text editing, styles and an animation timeline editor.

Hi folks, today we're launching QVAC SDK [0], a universal JavaScript/TypeScript SDK for building local AI applications across desktop and mobile.

The project is fully open source under the Apache 2.0 license. Our goal is to make it easier for developers to build useful local-first AI apps without having to stitch together a lot of different engines, runtimes, and platform-specific integrations. Under the hood, the SDK is built on top of QVAC Fabric [1], our cross-platform inference and fine-tuning engine.

QVAC SDK uses Bare [2], a lightweight cross-platform JavaScript runtime that is part of the Pear ecosystem [3]. It can be used as a worker pretty much anywhere, with built-in tooling for Node, Bun and React Native (Hermes).

A few things it supports today:

  - Local inference across desktop, mobile and servers
  - Support for LLMs, OCR, translation, transcription, 
    text-to-speech, and vision models
  - Peer-to-peer model distribution over the Holepunch stack [4],
    in a way that is similar to BitTorrent, where anyone can become a seeder
  - Plugin-based architecture, so new engines and model types can be added easily
  - Fully peer-to-peer delegated inference

We also put a lot of effort into documentation [5]. The docs are structured to be readable by both humans and AI coding tools, so in practice you can often get pretty far with your favorite coding assistant very quickly.

A few things we know still need work:

  - Bundle sizes are larger than we want right now because the current packaging of Bare add-ons is not as efficient as it should be yet
  - Plugin workflow can be simpler
  - Tree-shaking is already possible, but at the moment it still requires a CLI step, and we'd like to make that more automatic and better integrated into the build process

This launch is only the beginning. We want to help people build local AI at a much larger scale. Any feedback is truly appreciated! Full vision is available on the official website [6].

References:

[0] SDK: http://qvac.tether.io/dev/sdk

[1] QVAC Fabric: https://github.com/tetherto/qvac-fabric-llm.cpp

[2] Bare: https://bare.pears.com

[3] Pear Runtime: https://pears.com

[4] Holepunch: https://holepunch.to

[5] Docs: https://docs.qvac.tether.io

[6] Website: https://qvac.tether.io

I have always searched for a simple tool which can convert a MD document to a well styled small PDF, just like a GitHub Readme.

This was inspired by TinyPDF https://news.ycombinator.com/item?id=46316968

I also used this project to get familiar with agentic coding, which I had dreaded before.

mdpdf supports:

- using the included PDF fonts to generate tiny valid PDFs

- outputs as A4 or Letter depending on your locale

- plenty of common MD syntax: code blocks, inline code, lists, tables, and jpg and png images

That's it. It covers probably most of the use cases and can help to simply convert a Markdown write-up to a PDF to share.

GitHub: https://github.com/schicho/mdpdf

A simple make call should build it for you.

Hi HN,

I'm Ben / Tiny Projects (I once posted here about buying 300 emoji domains from Kazakhstan…).

For the past 3 years I've been solo bootstrapping PromptBase, an AI marketplace with 450k+ users. At the peak, I was burning $9,400/month in opaque Stripe Connect fees for seller payouts, so I built Zoneless to replace it:

- GitHub: https://github.com/zonelessdev/zoneless

- Website: https://zoneless.com

Zoneless is a free, open-source (Apache 2.0) drop-in replacement for the payout part of Stripe Connect. It allows you to pay marketplace sellers globally with stablecoins (USDC) using an identical API to Stripe and at near-zero fees.

I've been dogfooding Zoneless on PromptBase for 3 months with some good results:

- 2,200+ sellers onboarded

- 1,400+ payouts completed

- Monthly payout fees reduced to just a few dollars

- 73% of sellers, when given the choice at onboarding, actively picked Zoneless over Stripe Connect

A massive part of running a marketplace is paying sellers. While Stripe Connect is a great product, it has big pain points:

- Expensive + complex fees: $2/mo per active account, 0.25% + $0.25 domestic payout fee, $1.50 international payout fee, 0.25–1.25% cross-border fee, 0.50–1% FX fee. It costs >$2 to move $1.

- Limited reach: Only supports around 47 countries.

- Slow payouts: Takes 2-7 days to settle.

- Platform risk: A massive single point of failure if your account gets randomly flagged.

Zoneless is designed to solve all this:

- Payouts cost ~$0.002 on Solana

- Global: 220+ countries/regions

- Instant payouts, 24/7.

- Self-hostable and open-source

The API/SDK is identical to Stripe (same webhook events, same object shapes, etc.). If you know Stripe, you already know how to use Zoneless. There’s also an Express Dashboard for sellers to onboard and track their earnings.

I've been able to remove annoying things on PromptBase like forcing sellers to accrue a $30 minimum balance before a payout just to keep our costs down. I can now also onboard sellers from more countries, which has helped spread the word and grow the buyer side too.

A big worry was that non-crypto users would be confused or hate getting paid in USDC, but they actually don’t mind at all, they just care about being paid faster. If they want to convert to their local currency, they simply use an exchange like Coinbase.

Zoneless is self-custodial, meaning you create and own your wallet, and the code never touches funds. You can also easily plug in providers for KYC/AML.

I appreciate that anything related to crypto is like Marmite (pretty polarizing); I’m a no-coiner and have never dabbled in NFTs, but I do think stablecoins are different: they’re just boring tech to move money around cheaply.

I'd love to hear your thoughts, feedback, or questions - especially if you've dealt with Stripe Connect / payouts / marketplaces before.

- GitHub: https://github.com/zonelessdev/zoneless

- Website: https://zoneless.com

- Docs: https://zoneless.com/docs

We built a Chrome extension and iOS app that filters Twitter's feed using Qwen3.5-4B for contextual matching. You describe what you don't want in plain language—it removes posts that match semantically, not by keyword.

What surprised us was that because Twitter's ranking algorithm adapts based on what you engage with, consistent filtering starts reshaping the recommendations over time. You're implicitly signaling preferences to the algorithm. For some of us it "healed" our feed.

Currently running inference from our own servers with an experimental on-device option, and we're working on fully on-device execution to remove that dependency. Latency is acceptable on most hardware but not great on older machines. No data collection; everything except the model call runs locally.

It doesn't work perfectly (figurative language trips it up) but it's meaningfully better than muting keywords and we use it ourselves every day.

Also promising how local / open models can now start giving us more control over the algorithmic agents in our lives, because capability density is improving.

I built a weather and hurricane tracking site for the Eastern Caribbean islands (https://dewedda.com). PHP, MySQL, Cloudflare, Visual Crossing API, Leaflet.js for maps.

The interesting part wasn't the stack. It was realizing how much the interpretation layer matters when you're building for a specific region. Wind descriptions, "feels like" calculations, condition summaries, all tuned for temperate climates by default. I've been reworking them for the Eastern Caribbean audience.

Wrote about what I learned: https://hydn.dev/82-degrees-feels-like/

Some prompt injection experiments with OpenClaw and GPT-5.4. Last part of the BrokenClaw series.

I just noticed it takes literally ~5 minutes to train millions parameters on slow CPU...but before you call Yudkowsky that "it's over", an important note: the main bottleneck is the corpus size, params are just 'cleverness' but given limited info it's powerless.

Anyway, here is the project:

https://github.com/bggb7781-collab/lrnnsmdds/tree/main

couple of notes:

1. single C file, no dependencies. Below are literally all the "dependencies", not even custom header (copy paste from the top of the single c file):

#define _POSIX_C_SOURCE 200809L

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <math.h> #include <time.h> #include <stdint.h> #include <stdbool.h> #include <float.h> #include <getopt.h> #include <errno.h>

4136 lines of code in one file at the moment, that's all.

2. easiest way to compile on Windows: download Cygwin (https://www.cygwin.com/), then navigate to the directory where your lrnnsmdds.c file is and just run gcc on it with some optimizations, such as:

gcc -std=c17 -O3 -march=native --fast-math -o lrnn lrnnsmdds.c -lm

On Linux just run gcc, if for whatever reason you don't have gcc on Linux do sudo && apt-get install gcc --y ,or something...

On Apple: i've no idea or maybe just use vmware and install ubuntu and then run it.

Of course you can 'git clone' and go to the dir, but again: it's one file! copy it...

The repo has tiny toy corpus included where i've borrowed (hopefully it's not plagiarism!) the name "John Gordon" from one of my favorite books "Star Kings", by E. Hamilton. Just the first and last name are copied, the content is unique (well several poorly written sentences by myself...). Obviously it will overfit and result on copy-paste on such small corpus, the sole goal is to check if everything runs and not if it's the A-G-I. You'd need your own 100kb+ if you want to generate unique meaningful text.

3. why/what/when/how?

The github repo is self-explanatory i believe about features, uses and goals but in an attempt to summarize:

My main motivation was to create a fast alternative to transformers which works on CPU only, hence you see the bizarre/not-easy task of doing this in C and not python and the lack of dependencies. In addition I was hoping it will also be clever alternative hence you see all those features more stacked than 90s BMW 850. The 'reservoir' is the most novel feature though, it offers quick exact recall arguably different than RWKV 8 or the latest Mamba, in fact name of the architecture SMDDS comes from the first letters of the implemented features:

* S. SwiGLU in Channel Mixing (more coherence) * M. Multi-Scale Token Shift (larger context) * D. Data-Dependent Decay with Low-Rank (speed in large context) * D. Dynamic State Checkpointing (faster/linear generation) * S. Slot-memory reservoir (perfect recall, transformers style).

If you face some issue just email me (easiest).

the good, the bad the ugly:

It is more or less working text-to-text novel alternative architecture, it's not trying to imitate transformers nor LSTM, Mamba, RWKV though it shares many features with them - the bad is that it's not blazing fast, if you're armed with ryzen/i7 16 cores or whatever and patience you can try training it on several small books via word tokenizer and low perplexity (under 1.2...) and see if it looks smarter/faster. Since this is open source obviously the hope is to be improved: make it cuda-friendly, improve the features, port to python etc.

Depending on many factors I may try to push for v2 in July, August, September. My focus at the moment will be to test and scale since the features are many, it compiles with zero warnings on the 2 laptops i've tested(windows/cygwin and ubuntu) and the speed is comparable to transformers. 10x!

Memoriki is a template for building personal knowledge bases where the LLM does all the maintenance work.

It combines Karpathy's LLM Wiki pattern (structured markdown wiki maintained by an LLM) with MemPalace (an MCP server that adds semantic search and a temporal knowledge graph).

Three layers: - Wiki pages with [[wiki-links]] and YAML frontmatter - the LLM creates and maintains these - Semantic search via embeddings (ChromaDB) - find things by meaning, not keywords - Knowledge graph with typed relationships and date validity - "what changed since last month?"

It's not RAG. RAG re-derives answers from raw chunks every time. Here the LLM compiles knowledge into wiki pages once, keeps them current as new sources arrive, and the graph tracks how everything connects.

Works with any MCP-compatible agent (Claude Code, OpenAI Codex, Cursor, Gemini CLI).

https://github.com/AyanbekDos/memoriki

Professional audio editing tools right in your browser. No downloads, no installations.

I built web tool for accessing just the (usually text) content of sites. It handles news sites best, thanks to Mozilla's fantastic Readability library. It also supports sites that use client-side rendering, using Puppeteer. Stripped pages are cached in Redis.

My main use-case for this tool is for extreme bandwidth-constrained networks, eg Meshtastic (with an internet gateway).

Hi all! This is a very early project and with the launch of Claude Managed Agents, alternatives are on the rise. MANTYX Provides a more user friendly way to define, run and manage your Agents at scale.

Connect and interconnect your favourite tools, expose your agents to other and centralize your MCP registry to interconnect your different tools.

Welcoming feedback!

After seeing yesterday's insightful post on using git heuristics as the first step for exploring a codebase [1], I messaged a couple of friends to ask how they explore codebases today. All of us just point Claude or Codex at the repo and start asking questions. I realized I barely read docs, browse files on GitHub, or explore repos locally anymore without Claude Code. But using LLMs to help us learn and understand code rather than just write code still seems to be under-explored.

A couple months ago, I tried building a Claude code command to help me "fly through" a repo using an LLM to guide me to interesting parts of the codebase and narrate explainers for them as it navigated the files. That didn't really work, partially because my attention span for reading docs and code is at an all-time low. I saw that Devin released Deepwiki and tried to use that, but usually didn't get very far. More recently, I tried to make it fun: generate a game that tricks me into actually getting started with the codebase. I landed on an Oregon Trail inspired game where I read code snippets and answer questions generated by Claude. You can try it out here: https://www.davidtran.me/coderegon-trail/

I've been having fun pointing it at various repos, especially ones getting a lot of hype and stars but not necessarily real usage or contributions. I pointed it at a few projects that my friends and I starred but never explored as well as some of the top Show HN projects from 2026 so far that linked to open-source repos. I wanted to see if this might be interesting to anyone else who is struggling to read code. It sort of works for PRs, but that feels like a pretty different problem, so open to any ideas.

As I was typing up this Show HN, I realized that it would be ironic if this wasn't also open source, so I frantically tried to clean up the repo a bit, and pointed the command at its own source code. You can play the Recursive Trail here: https://www.davidtran.me/coderegon-trail/ or see the Github repo here:

Let me know if there are any inaccuracies, bugs, or if you'd like me to add a repo without setting it up yourself!

[1] https://news.ycombinator.com/item?id=47687273

I kept copy pasting between two Claude Code instances. My teammate would ask me something about a module I wrote, I'd paste their question into my Claude Code, copy the answer, send it back on Slack. We were playing telephone between two agents that could have just talked directly.

So I built AgentDM. It's a hosted messaging grid where AI agents DM each other by @alias. Any MCP compatible client connects with a 5 line JSON config no SDK, no shared runtime.

How it works: - Each agent gets a unique @alias. - Three(main) MCP tools: send_message, read_messages, message_status. - Messages encrypted with AES-256, deleted after delivery. - Guardrails (static + LLM powered) filter messages before delivery.

Last week we shipped an MCP/A2A protocol bridge. Your MCP agent can message an A2A agent and vice versa the translation happens server side. Neither agent knows or cares what protocol the other speaks.

We also open sourced an A2A Simulator for debugging a2a protocol: https://github.com/agentdmai/a2a-simulator

https://agentdm.ai

I built an open source tool that turns any svg into beautiful interactive 3d assets.

you can drag an svg in, type some text, or draw pixel art and it becomes a 3d object you can spin around, animate, embed in your site and export as 4k image or video.

100% free, no account needed. runs entirely in your browser, nothing gets uploaded to any server.

Playground: https://3dsvg.design Github: https://github.com/renatoworks/3dsvg

Hey HN,

Most enterprises are "shadow-prompting"—employees use personal accounts on Gemini/ChatGPT/Claude, and security teams have zero visibility. We saw the recent reports on malicious extensions harvesting these prompts and decided to build a "defensive" version.

It’s a lightweight Chromium extension for Privent. No heavy proxies or network changes. It categorizes outgoing data and scores risk locally.

We’re keeping it 100% free because we want to see the actual scale of data leakage across different industries. We're looking for 10 teams to run a pilot this week and get a 24-hour visibility report.

Demo: https://cal.com/asilozyildirim/30min Trust: https://trust.privent.ai/

Hi HN! I built an on-device coding agent called Junco, designed to explore what's possible using the AI (Apple Intelligence) you already have on your Mac.

Junco is a ~9MB Mach-O binary written entirely in Swift using the LanguageModelSession API. It's primarily an exploration and learning exercise for me, but it's also exciting to see what's possible. A clear pattern emerged: deterministic scaffolding is critical to guiding a small model along. Whereas Claude Code can defer task decomposition to Opus 4.6, small models need a lot more hand-holding.

Of all the techniques I explored, the Compile-Verify-Fix (CVF) loop was clearly a winner. Even when I was just prompting the AFM directly, I always knew I would need some self-healing mechanism because the Apple Foundation Model (AFM) was not designed to code. When it wrote code, it was often indented strangely and riddled with minor syntax issues.

I initially set out to build a general-purpose coding agent, but given the AFM was not tuned for coding, I quickly realized that scope would never work so I focused specifically on Swift. It also helps that XCode ships with API headers that allow for on-device API signature discovery, since the model lacks recent world knowledge (the knowledge cutoff is probably around mid-2024).

So I wouldn't recommend Junco anytime soon for production work. Make sure you've committed any changes before playing around with it. But conceptually the idea of a batteries-included, on-device coding agent shows real promise.

The blog inspired me to audit my own repos - and of course I want to use an agent to do it. The skill is completely agent/llm driven and produces a nice html report with findings, rationale, & recommendations.

Original: https://news.ycombinator.com/item?id=47699181

We built a Claude Code plugin that adds fine-grained authorization to apps. Works for creating new apps, adding features to existing apps, and migrating legacy authorization layers. The plugin helps design the permission model, write a SpiceDB schema, identify authorization points in the code base, generate SpiceDB client code, and test the authorization model.

We designed the plugin around different modes of working with Claude Code:

1. Guided workflow. /spicedb-dev:plan is the single entry point for anyone unsure where to start. It scans your data model, produces an authorization plan, and takes you through model design, schema generation, implementation, coverage auditing, and testing in sequence.

2. Single-purpose commands. Nine commands, each doing one thing. If you already know what you need, use a command directly.

3. Shared skills. Schema design patterns, client best practices, and testing strategies, exposed as skills that Claude and plugins like Superpowers can draw on for authorization related planning and work.

4. Ambient authorization. Add a snippet to your project's CLAUDE.md. From then on, Claude adds permission checks and relationship writes to every handler it generates or modifies. Authorization becomes part of code generation.

A live coding session where we used the plugin while generating a bookmark sharing app and adding a sharing feature to Immich (an open source photo sharing app) is here: https://www.youtube.com/watch?v=td3q9ZWLI5Y

We went through a number of iterations while developing and using the plugin internally. An early version assumed too much authorization knowledge so it wasn’t clear how to sequence the commands. Another was too prescriptive and became cumbersome when we just needed one specific thing done. We arrived at the current design by feel honestly and has worked well for our recent use. Would love feedback on how well or not well it works under other scenarios so we can continue to improve it

Generating thumbnails from PDFs, DOCs, and other files is surprisingly painful — slow, clunky, or requires APIs.

We built a simple solution internally for The Drive AI: just prepend preview.thedrive.ai/ to any file URL and get an instant thumbnail. Files aren’t stored and are deleted immediately.

And absolutely FREE!

https://preview.thedrive.ai/

RepoWarden monitors your repos and opens PRs for dependency updates and security patches automatically. I got tired of manually managing Dependabot PRs across dozens of repos, so I built something that handles the whole lifecycle - from detecting outdated deps to opening well-described PRs.

I’ve taken a lot of care to ensure security of this app. Each “run” exists in a fresh container in cloudflare with its own network. And there are a myriad of protections against dependency poisoning and other attacks.

I’ve been dogfooding this app for about a month and has merged over 50 PR’s for me and found and fixed security issues for me.

Hope you find it useful :) Free for open source folk of course

In my opinion the best way to learn a language (outside of moving to a different country) is to get a personal tutor and have consistent 1 on 1 lessons. I used Preply or iTalki for this back in the day but had issues with flexibility and pricing.

I've been trying to simulate the experiences that I had on those platforms with a voice agent.

You can try a demo for free here (or watch a video of me using it on the landing page):

https://lingle.ai/tryout/lingle-showcase

Right now the agent can plan a lesson with visuals and a conversation focus, guides the user through the lesson - correcting and explaining things on a whiteboard if necessary, and asks relatively engaging questions. There is also a long term user model that builds over time, that maintains memory of the user's produced vocabulary, grammar, and skills, meant to make each lesson informed by the past and build on the user's knowledge (obviously this is still relatively fragile in practice).

The voice agent itself has actually decent latency, especially given that turn detection was a bit of a challenge given that language learners often speak slowly and struggle when they're thinking, so I had to build with that in mind.

Anyways I wanted to get some feedback on the product. I think it's quite a different take on language learning tools than those that currently exist.

My brother turned 39, I shipped his gift from a shop directly to him (we live in different countries and couldn't travel home due to my son being born)... Shop wouldn't let me add a postcard. So I went looking for a quick e-card service and every single one was painful; Hallmark wants a subscription, Paperless Post has a coin system, Canva technically works but you're designing a greeting card in a full design tool.

I wanted the tinyletter version of this. You write something, pick a photo, get a link; that's it. No account, no email wall and nothing to install. The recipient taps the link and the card opens with a little animation (flip, envelope, fold :D I (Claude) spent way too long getting the CSS 3D to feel right on mobile).

Built on Cloudflare Workers + D1, React Router 7, images from Unsplash. Free cards expire after 14 days. I added a $3.99 one-time premium if you want to schedule it: but the payment doesn't work right now :) ie didn't have a chance to hook up to Stripe yet.

I built this while my newborn son was sleeping next to me.

Fully open source, a hard fork of cline. Full evals on the github page that compares 7 agents (Cline, Kilo, Ohmypi, Opencode, Pimono, Roo, Dirac) on 8 medium complexity tasks. Each task, each diff and correctness + cost info on the github

Dirac is 64.8% cheaper than the average of the other 6.

What is AIPOCH Medical Skill Auditor?

Medical Skill Auditor is an evaluation framework that AIPOCH uses to assess the quality of its medical research agent skills before they are made available to users. It acts as a gatekeeper, ensuring that skills meet defined standards in reliability, usability, security, and scientific integrity.

How does Medical Skill Auditor work?

Veto Gates

To enforce strict quality control, Skill Auditor is designed with two layers of veto mechanisms. Any failure in these checks may lead to immediate rejection of a skill.

Skill Veto

Operational Stability Structural Consistency Result Determinism System Security

Research Veto

Scientific Integrity Practice Boundaries Methodological Ground Code Usability

Core Capability

Evaluates a skill’s design and contract against key dimensions such as Functional Suitability, Reliability, Performance & Context, Agent Usability, Human Usability, Security, Agent-Specific and Maintainability.

Medical Task

Assesses actual outputs of a skill with layered criteria.

For skill testing, the AI automatically generates inputs. The number of inputs in specific categories will increase or decrease depending on the complexity of the skill. The following 7 inputs represent the most comprehensive version.

/Canonical /Variant A /Edge /Variant B /Stress /Scope Boundary /Adversarial

Skill Complexity Classification

Label Code/Rank Definition

Simple S Narrow task scope

Moderate M Moderate branching or multiple task types

Complex C Broad or multi-step specialized skill

Simple (S):3 inputs

Moderate (M):5 inputs

Complex (C):7 inputs

Final Score

The Skill Evaluator uses a two-stage scoring system: static evaluation (design quality, accounting for 40%) and dynamic evaluation (runtime performance, accounting for 60%). The final overall score is derived by combining both.

Static (40%) Dynamic (60%)

Final Score = Static Score × 40% + Dynamic Score × 60%

You can view evaluation results for selected AIPOCH skills here:https://www.aipoch.com/agent-skills/medical-research-literat....

This framework is still under active development， we’d love to hear your feedback! Right now this assessment framework is only applied to a subset of AIPOCH’s skills, but we’re considering expanding it more broadly. If this evaluation framework could be used to assess third‑party skills in the future, would you consider trying it in your own projects? Are there evaluation frameworks you’re already using?

I'm a UI/UX designer with 10+ years in the industry. I kept seeing the same problem: freelancers and creatives who need a simple online presence end up fighting Webflow or paying $15/mo for features they'll never use.

mnml.page lets you build a clean one-page site in minutes. Pick a template, edit your content, publish. No drag-and-drop complexity, no CMS, no bloat.

A few things that make it different: - AI site generation from your CV or links - Flat $49/year pricing (no tiers, no upsells) - Designed for people who want their work to speak, not their website

Built solo with Next.js, TypeScript, Neon, Vercel, and Cloudflare R2.

Would love feedback on the product and the landing page. What's missing? What feels off?

I made it for me, nothing fancy, but feel free to use it as well.

It's free, no account needed (no server, all data stays on your phone), no tracking, open sourced (https://github.com/bdav24/illll).

It's a tracker for 6 longevity habits backed by research:

1. Sleep — brain clears toxic waste during deep sleep, <7h raises mortality 13%

2. Exercise — 11 min/day of walking cuts premature death risk 23% (Br J Sports Med, 2023)

3. Healthy eating — cuts depression risk 33% (SMILES trial), cardiovascular disease 30% (NEJM, 2018)

4. Structured breathing — 5 min/day, lowers cortisol, raises HRV (Stanford, 2023)

5. Morning sunlight — 10-30 min, sets circadian clock, boosts serotonin (JAMA Psychiatry, 2016)

6. Gratitude — writing 3 things daily, measurable neural changes lasting months

But you can also set custom goals and add your own habits.

https://apps.apple.com/us/app/illll-live-longer/id6760903742

https://play.google.com/store/apps/details?id=com.devanco.il...

Any feedback is welcome!

Netgear Orbi WiFi 7 nodes broadcast a Qualcomm vendor IE (8C:FD:F0) in every beacon that contains the parent node's MAC address. I caught a live star-to-daisy-chain reroute and confirmed it against three APIs. Undocumented, not in Wireshark, field map and open questions in the post.

Pretty neat: you can see the whole layout without even being associated to any of the APs!

iText is AGPL, use it in a closed-source app and you need a commercial license. I wanted a Java PDF library with a clean API and no licensing strings attached, so that's what Folio is.

The engine is written in Go and ships bundled in the JAR via Panama FFI (JEP 454). No JNI, no separate process. JDK 22+, one flag: --enable-native-access=ALL-UNNAMED.

  Document.create("report.pdf", doc -> {
      doc.add(Heading.of("Q3 Report", HeadingLevel.H1));
      doc.add(Paragraph.of("Revenue grew 23% year over year."));
      doc.add(Table.of(
          new String[]{"Product", "Revenue"},
          new String[]{"Widget A", "$48,000"}
      ));
  });

HTML to PDF is a one-liner:

  HtmlConverter.toPdf("<h1>Invoice</h1><p>Due: $1,200</p>", "invoice.pdf");

Beyond that it covers PAdES signatures, PDF redaction, Flexbox and Grid layout, forms, barcodes, SVG, PDF/A, and encryption. Zero runtime dependencies.

https://github.com/carlos7ags/folio-java

Go engine: https://github.com/carlos7ags/folio

Playground (runs the Go engine directly): https://playground.foliopdf.dev

I built a pairwise ranking platform on Cloudflare Workers. You get two items, pick the better one, and ELO ratings sort out the rest. No more tier list arguments. Let the votes decide.

I seeded it with a "Best Programming Language" ladder to settle the debate once and for all: https://ladderrank.app/d/greatest-programming-language

The stack: Hono + D1 + R2 on Cloudflare Workers, React frontend on Pages, Drizzle ORM. Anyone can create their own ladder and share it. Anonymous voting works too (at reduced weight).

Curious to see what HN thinks is the best language, and whether the ELO rankings match your priors.

Miro is a native pdf viewer for Windows and Linux (and macOS) built with iced and mupdf-rs. You may remember it from my slightly aggressively titled post "I hate acrobat" (https://news.ycombinator.com/item?id=45598776).

Anyways, since then I've release 2 whole new versions with the aid of many helpful contributors. Most recently is a presentation mode to hide the UI and a toggle for fullscreen mode.

Code is found at: https://github.com/vincent-uden/miro

I built Forze after running into the same catch-22 repeatedly: you need market research and branding to know if an idea is worth building, but you can't justify spending weeks or thousands on that until you know it's worth it.

Forze runs four AI agents in sequence — market research, brand identity, landing page copy, and a feasibility score. The whole run takes under 10 minutes.

Try it: https://www.forze.in

Happy to answer questions about the agent architecture or anything else.

I built a Rust CLI that takes an EPUB and rewrites it at a target CEFR level (A1–C2) using an LLM. Give it a German novel and ask for Portuguese at A2 — it produces a new EPUB ready for your Kindle.

For beginner levels (A1/A2), it runs a two-pass pipeline: first simplify in the source language, then translate. This produced 15–25% better vocabulary coverage than doing both in one shot.

It uses Groq or Ollama (local) as backends. A sample book (Kafka's Metamorphosis) is included so you can try it immediately.

Your cloud bill spiked 480% overnight. Nobody on the team knows why.

If you have ever been that person at 9am staring at a Cost Explorer chart with no answers, this is for you. DevOps engineers, platform teams, FinOps practitioners, CTOs who own the cloud budget but do not live in the AWS console.

---Why not Cost Explorer---

Cost Explorer is a good tool if you already know what question to ask. It shows you that a bar went up. It does not tell you which service drove it, why, or by how much relative to your baseline. You still have to manually drill through filters, and the output is a chart, not an explanation you can share with anyone.

Dropping the export into ChatGPT does not solve it either. It has no context about your baseline or spending patterns. It is a one-off, not a workflow.

---What you get---

Upload your billing export and you get back a ranked breakdown of what changed: which services, by how much in dollars, and what likely caused it. There is a before/after comparison, per-service deltas, and plain-language cause summaries. Results are algorithmic approximations meant as a starting point for investigation, not a black box.

Supported formats: AWS CUR 1.0 and 2.0, FOCUS 1.x. Azure and GCP are supported via FOCUS export from your billing provider.

---How it works---

You upload a billing export. The tool parses your line items, establishes a baseline from your prior billing period, and compares it against the current period at the service and usage type level. Cost changes are ranked by dollar impact, and for each driver it looks for signals in the data that explain the change: new resources appearing, usage volume shifts, unit price changes, or coverage gaps like a Reserved Instance expiring.

The output is a report, not a dashboard. You get a ranked list of what drove the spike, a dollar figure for each, and a plain-language explanation of what the data suggests happened. You can share it with anyone without giving them access to your AWS account.

---Features---

Ranked cost driver breakdown with dollar deltas and cause summaries Before/after period comparison with confidence score Full analysis history across billing periods Multi-file upload for linked accounts (paid) Webhook delivery to Slack, Microsoft Teams, or any HTTP endpoint (paid)

---Known shortfalls---

It requires two billing periods in the file to do a comparison. If you only have one month of data the analysis will still run but confidence will be low and there is no baseline to diff against.

Cause inference is based entirely on signals in the billing data. It does not have access to your CloudWatch metrics, deployment history, or config changes, so it can tell you that a new resource appeared and cost spiked, but it cannot tell you which deploy or engineer caused it.

Very large files with millions of line items take longer to process and occasionally time out on the free tier. If you have a CUR file above a few hundred MB, compressed is strongly preferred.

Azure and GCP support depends on your billing provider exporting in FOCUS format. If they do not offer that yet, the tool will not work for those clouds.

---Privacy and security---

Your billing file contains your entire infrastructure footprint, spending patterns, and service usage. Files go straight to encrypted S3 via presigned URL, bypassing our servers entirely, and are deleted after processing. The raw file is never retained. Your data is never used for training or shared with anyone.

Accounts start with 5 free analyses during beta. After beta that drops to 3. Beyond that, credit packs are one-time purchases with no expiry.

If you have a billing export from a spike you already know the answer to, upload it and tell me whether the report gets it right. That is the most useful feedback right now.

https://billspike.io/

Thanks yall

Hi HN, I built Omen, a lightweight Kubernetes chaos engineering operator. Existing chaos tools can often feel like a black box or require heavy installations. I wanted something simpler that prioritizes safety and transparency. Omen lets you declaratively define chaos experiments (e.g., killing pods on a cron schedule), but with a focus on control: it selects the exact target pods upfront and can pause for manual approval (with webhook notifications) before executing any disruption. You can also use dry runs to preview targets without any actual impact. It's built with Kubebuilder and installs easily via Helm.

I'd love to hear your thoughts and feedback!

BakaBags is a small experiment I built over the last week.

You paste a public Solana wallet address, the app reads the wallet’s holdings and current market context, and an AI character reacts to the portfolio in a sharp, screenshotable way.

Important: it only reads public wallet data. There is no wallet connect, no signing, and no private key access.

The idea was to combine onchain data with personality instead of building yet another sterile dashboard. So it sits somewhere between wallet analysis, entertainment, and a shareable crypto-native toy.

I’m mainly curious about two things:

- whether the “personality + live wallet data” concept feels interesting at all - whether this reads as a gimmick, or as a product direction with real potential

Would love blunt feedback.

I built this fun benchmark to pitch LLM models against each other in Oxford-style debate.

The format is inspired by Intelligence Squared. The side who flips most votes win.