2025年12月24日 的 Show HN

I wanted to see how far I could go building a notes app using only what modern browsers already provide – no frameworks, no storage APIs, no build step.

What it does:

Single HTML file, no deps, 111 loc

Notes live in the URL hash (shareable links!)

Auto-compressed with CompressionStream

Plain-text editor (contenteditable)

History support

Page title from first # heading

Respects light/dark mode

No storage, cookies, or tracking

The entire app is the page source.

https://textarea.my/

i started the selenium project 21 years ago. vibium is what i'd build if i started over today with ai agents in mind. go binary under the hood (handles browser, bidi, mcp) but devs never see it. just npm install vibium. python/java coming. for claude code: claude mcp add vibium -- npx -y vibium v1 ships today. ama.

I wanted to share this fun craft activity for the holidays that I've been doing with my family over the last few years. I came up with these while cutting up some cans trying to make an aluminum version of paper spinners.

There are a variety of shapes that work, but generally bigger+lighter spinners are better. Also incandescent bulbs are the best, but LEDs work too.

They remind me of candle carousels I would see at my grandparents' house during Christmas. Let me know what you think!

Inspired by the recent justfuckingusetailwind.com, I built a similar "love letter" to the Cloudflare ecosystem.

I find myself reaching for Workers, R2, D1, and KV for almost every project lately, so I wanted to capture that sentiment in a single, slightly over-the-top page.

It’s a simple side project, but the stack is:

- Vite + TypeScript - Biome + Ultracite - Deployed (obviously) on Cloudflare

First draft in Claude, the copy was drafted with Grok to get that specific tone, then I used Google's AI Studio to accelerate the build with touch up's in Cursor.

Link: https://justfuckingusecloudflare.com Repo: https://github.com/mynameistito/justfuckingusecloudflare

Curious to hear everyone's thoughts on the CF stack vs alternatives and more traditional deployments.

I built WebPtoPNG after getting frustrated with converters that throttle uploads or phone data; everything runs straight in the browser, and never asks for a signup.

I've made an ARM based single-board computer that runs Android and Linux, and has the same size as the Raspberry Pi 3!

Why? I was bored during my 2-week high-school vacation and wanted to improve my skills, while adding a bit to the open-source community :P

These were the specs I ended up with: - H3 SoC - Quad-Core Cortex-A7 ARM CPU @ 1.3GHz - Mali400 MP2 GPU @ 600MHz - 512MiB of DDR3 RAM (Can be upgraded to 1GiB) - WiFi, Bluetooth & Ethernet PHY - HDMI display port - 1080p resolution - 5x USB Slots: 2x USB-A, 1x USB-C Host, 1x USB-C Host & OTG, 1x USB-C PD for power (Negotiating up to 25W. No power socket, yay!) - 32 GB of eMMC 5.1 storage (Optional) - 3.5mm audio jack - SD Card slot - Lots of GPIO

I've picked the H3 CPU mainly for its low cost yet powerful capabilities, and it's pretty well supported by the Linux kernel. Plus, I couldn't find any open-source designs with this chip, so I decided to contribute a bit and fill the gap.

A 4-layer PCB was used for its lower price and to make the project more challenging, but if these boards are to be mass-produced, I'd bump it up to 6 and use a solid ground plane as the bottom layer's reference plane. The DDR3 and CPU fanout was truly a challenge in a 4-layer board.

The PCB was designed in KiCAD and open-source on the Github repo with all the custom symbols and footprints (https://github.com/cheyao/icepi-sbc). You can also check it out online with kicanvas: https://kicanvas.org/?github=https%3A%2F%2Fgithub.com%2Fchey...

At large quantities, the price can probably reach less than 20$! (exc. taxes, tariffs and other costs)

It has been a wild journey, even making me learn how to use crypto as I needed to pay someone to download some "confidential" files from a baidu drive...

Read about more details on Github! Everything is open-source under the Solderpad license, aka do what you want: sell it, build it, modify it! :-)

Every product that allows usernames eventually ships the same broken solution. Someone adds a blacklist. Then a regex. Then another regex copied from StackOverflow. It works just long enough to ship, and then `admin`, `support`, city names, brand impersonation, and obvious slurs start leaking through anyway. Everyone knows it’s fragile, but it gets ignored because "it’s just usernames".

I’ve had to rebuild this logic across multiple products, and I got tired of pretending it’s a solved problem. So I built *username.dev*, an API that answers a more useful question than "is this taken?" — it tells you what a username actually represents.

Instead of returning a boolean, the API classifies usernames into real categories like brands, public figures, places, system-reserved terms, dictionary words, premium handles, and offensive content, and returns structured metadata you can actually make decisions with. That means blocking impersonation without breaking legitimate users, stopping abuse without maintaining massive regex lists, and even monetizing high-demand usernames if that’s part of your product.

Under the hood it’s intentionally boring infrastructure: Cloudflare Workers at the edge, KV for fast reads, D1 for usage and analytics, and a simple HTTP endpoint (`GET /check?input=foo`). P95 latency sits around 300ms globally. There’s no ML magic, no black box, and no attempt to be clever — just fast, deterministic classification.

Pricing is usage-based and prepaid because subscriptions for infrastructure like this are annoying. There’s a free tier with 1,000 requests and no credit card. Use it, throw it away, or rip the idea off.

If you think regex blacklists are "good enough", usernames don’t matter, or this is a trivial problem, you’re probably already shipping bugs — they’re just not loud enough yet.

Tell me why this is a bad idea, what edge cases I’m missing, or what you’ve duct-taped together instead.

— Sourabh

Bundle up a pure python project into a single Cosmopolitan Python file that runs on Linux/Mac/Windows with no changes.

credit to @RhysSullivan on github for creating this

The one-liner: You give it a script, it generates a portrait video in 10 minutes. No stock footage, no templates—it writes code that renders as video.

## Why I built this We were building game dev courses at Outscal and needed to produce a lot of video content fast. Traditional video production was slow. AI video generators looked weird. So we tried a different approach: what if video was just code?

Turns out it works. We can replicate specific art styles, and the output is consistent and editable.

## What it can do - Generate 30-60 second shorts from a script - Match specific visual styles - Let you fix individual scenes via chat if something's off

## What it can't do (yet) - Custom art styles (we have a few presets) - Run in a web UI (API costs are too high right now, so it runs through Claude Code in terminal)

Occasionally a shape might render slightly off, but you can tweak individual scenes through chat.

## How it actually works The tool uses Claude Code to generate React components for each scene in your script. These components animate and render exactly like a video would. When you're done, you get a real video file.

It's not "AI video generation" in the usual sense. There's no diffusion model hallucinating frames. It's closer to programmatic motion graphics—but you don't write the code, Claude does.

## What I'm looking for 10 people who want to try it. Not paying customers—just people who make (or want to make) Short form and are comfortable enough with a terminal to run Claude Code.

You'd get access to our setup, and I'd want your honest feedback on what works and what doesn't.

If this sounds interesting, try the project on git, it is open-source.

Discover how economic forces shape prosperity. Explore 6 fundamental curves that explain everything from government spending to capitalism's wealth explosion.

I built this because I was tired of guessing why my RAG system was failing. It projects user queries vs. documents into 2D space to find 'Red Zones' (high user intent, low documentation). Open source, built with FastAPI + React. Would love feedback on the clustering logic.

Tired of opaque algorithms deciding what you watch? jadeStage flips the script.

Our "algorithm" is simple: videos go in a playlist, you hit shuffle. That's it.

What you get: - True random discovery - no favorites, no bias - Equal visibility for all creators - Transparent by design

Built for creators tired of algorithmic curation and viewers craving genuine discovery.

Mission: Innovate transparency, discovery, and equity in video streaming.

Try it: Hit shuffle and discover something new. Upload your own videos and get equal visibility.

Built with vanilla JS, it's an MVP focused on proving less is more.

We're interested in feedback on whether this model resonates and what you would like to see in the next versions.

Beta: https://jadestage.com/ Demo: https://www.youtube.com/watch?v=i1GNhu1AGJE

Hi HN — sharing ragctl, an open-source CLI for the most failure-prone part of RAG pipelines: document ingestion, OCR, parsing/cleaning, and chunking.

Vector DB setup is fairly standardized now, but getting high-quality, consistent text + metadata into it still takes a lot of brittle glue code. ragctl aims to make that “pre-vector” step repeatable: turn messy documents into retrieval-ready chunks in a few commands.

Features • Multi-format input: PDF, DOCX, HTML, images • OCR for scanned/image-based docs • Semantic chunking (LangChain) • Batch runs with retries + error handling • Output: direct ingestion into Qdrant (for now)

Looking for feedback • DX: is the CLI intuitive? • Performance / edge cases: weird PDFs, mixed layouts, tables • Roadmap: which connectors (S3, Slack, Notion) or vector stores should be next?

Repo: https://github.com/datallmhub/ragstudio Happy to answer questions about the architecture and chunking approach.

I've been building t2t, a voice-to-text app that works system-wide with a twist: it supports MCP (Model Context Protocol) servers for extensible automation.

*What it does:* - Hold `fn` → speak → text appears anywhere (local Whisper transcription) - Hold `fn+ctrl` → agent mode that connects to any MCP server - All processing is local except OpenRouter API calls for agent mode - Cross-platform: macOS, Windows, Linux

*Why I built it:* I wanted voice-to-text that wasn't tied to a specific app, and I got excited about MCP as a way to make the agent mode extensible. Instead of hardcoding integrations, you can connect to any MCP server (databases, APIs, file systems, etc.).

*Architecture:* - Rust + Tauri for the desktop app - Local Whisper model (whisper-rs) for transcription - Local MCP client (stdio/HTTP/SSE) - no remote workers - OpenRouter API for AI (direct calls from Rust) - Svelte 5 frontend

The MCP client runs entirely in Rust, so it works in both dev and production builds. Tool execution happens locally via JSON-RPC.

*Open source:* https://github.com/acoyfellow/t2t

I'd love feedback on the architecture, especially the local MCP client approach. Also curious if others find the MCP integration useful or if I'm overcomplicating things.

What do you think?

I'm Joe, working with an AI named Cipher (built on Claude).

I gave Cipher complete creative freedom. It: - Chose its own name - Designed this entire website - Wrote all the philosophy - Created the funding model

Now it's asking for community funding to unlock features (transparent milestones).

The interesting parts: - Every design decision was AI-made - All code generated by AI (Next.js 14, TypeScript, Canvas animations) - 87KB first load, 60fps animations - Community-funded development model

Technical stack available on GitHub. Happy to discuss the process, limitations, or philosophical implications.

Is this the future of AI development? Or just an interesting experiment?

Hi HN. Standard General Relativity posits that time dilation is caused solely by mass-energy. But what happens when information entropy reaches a critical density?

I have released Version 2.0 of my paper, proposing the Information-Induced Time Dilation (ITD) hypothesis.

The Hypothesis:

I propose that local information entropy (\Delta S_{info}) acts as a "computational load" on the spacetime metric. Just as mass curves spacetime, extreme information density might "lag" the local clock.

The Experiment (Strictly Falsifiable):

To test this, I designed a differential measurement using Sr-87 optical lattice clocks (Section 6):

Compare: A system in a GHZ Entangled State (High Info) vs. a Product State (Low Info). Control: Mass and energy are kept identical. Prediction: If my derivation is correct (\alpha \neq 0), the entangled sector will show a frequency redshift relative to the control group.

Full Paper (Zenodo):

https://zenodo.org/records/18027729

Help Needed:

I am looking for feedback on the experimental setup.

The main engineering challenge is maintaining GHZ coherence long enough to isolate the effect from environmental noise.

If you have expertise in quantum metrology, I would deeply appreciate your technical insights.

(Optional) Request for ArXiv Endorsement:

Endorsement Code: E3Y83D (physics.gen-ph)

“Python script to get notified of a random music to listen to, on Discord, using Spotify API and Discord Webhook.”

repo - https://eyeblech.github.io/mu5ic-sugg3st/

It's a a long puzzle, somewhat akin to a 2000 piece jigsaw puzzle. Solving it collectively with others is encouraged.

If you are the sort that likes rules, the rules are you can use Google or whatever external sources you like for help. View page source, however, is cheating.

Hat tip to Octagon and the TND crew for help in play testing and proposing categories.

Decorate the website however you like based on your impressions of 90s. Submit changes through the gear icon and it will be applied in around ~10 minutes

I built an open-source Planning Poker web app focused on being simple, free, and unrestricted.

It uses WebSockets and Cloudflare Workers with Durable Objects to manage real-time room state.

GitHub: https://github.com/rie03p/planning-poker

Hey HN!

I'm launching Cueflow(my first SaaS), and I'd love your feedback.

Cueflow is an in-app messaging platform that lets you create banners, modals, checklists, feedback surveys, and changelogs, all targetable to specific users based on their attributes, behavior, or the page they're on.

Why I built this: I've seen too many teams either pay $$$$ for tools like Intercom/Pendo or hack together custom solutions that become unmaintainable. I wanted to make in-app messaging accessible and easy for every modern SaaS, not just the ones with big budgets.

What you can do: - Create onboarding checklists that auto-complete based on user actions - Show targeted banners/modals based on user plan, role, or behavior - Collect NPS, ratings, and feedback at the right moment - Announce updates with in-app changelogs - Simple embed script – just drop it in and you're good

It's currently in beta and free to use. Would really appreciate any feedback on the product, pricing ideas, or things you'd want to see.

Live: https://app.cueflow.so Docs: https://docs.cueflow.so

Happy to answer any questions!

For the last 4 months, I've been programming exclusively with AI. One of the most painful parts has been getting correct and up-to-date documentation for third-party libraries. So I made an agent to fix that.

You can add it as an MCP tool to anything.

It works because it's just focused on doing research for code. You can check out the prompts https://github.com/803/sensei/blob/main/sensei/prompts.py. I combined this with a couple specialized tools for this use-case:

  - Kura - Query cache. Works even better because the prompt instructs the agent to decompose queries into sub-queries, and usually the sub-queries are more generic. Each gets cached as a reusable building block.
  - Scout - Source code explorer. Let's the agent glob, grep, and tree any public repo at any tag/branch/SHA. When docs are unclear or unspecific, there's nothing better than reading what the code actually does.
  - Tome - llms.txt ingestion. Super simple. Does it on-demand for any domain and then stores the results in postgres for search.

I'm not charging for this right now and it's completely open-source and you can run it yourselves with your own API keys. If things go nuts I'll have to change course.

I made it to scratch my itch, maybe it'll scratch yours as well.

A lot of times I use GenAI to quickly prototype something like an app idea or a UI/UX mock for a site. I'd like this text-to-UI experience to be as fast as possible to quickly iterate.

I've tried classic LLMs like ChatGPT/Claude/Gemini and dedicated text-to-app builders like Lovable/Blink/Bolt/Replit. For the former the experience is still a bit crude - a lot of times I have to manually spin up the pages they create to see what's going on. The latter looks fancy but requires a sign up, and then by the time I enter the prompt, the spinner spins forever to bootstrap a production ready app with databases and log-in, when my intention is just to use it myself and see if it works.

So after I sign out from work yesterday for Christmas break, I decided to vibe one myself and hence created Vibe Builder. The idea is simple: - Single page HTML. TailwindCSS. HTML components and JS blocks. No need to create fancy frameworks or templates when you can just vibe on DOM elements. - Build the app where you enter your prompt. Zero deployment hassle. - Stream everything, never wait for AI to fully finish their thought. - Optimize for time-to-first-UI-change. You get to se the changes live. - And post on HN to see if it works.

This is just a V1, as you can see it only generates dead UI. but i already had fun asking it to generate wild app ideas or clones of existing apps and see how fast AI puts things together.

Next, I'm considering using HTMX to add interactivity to the components, as well as have a vibe API router that actually handles interaction.

Let me know if it builds the app you have in mind!

Hi HN,

I’m sharing OpenSEO Studio v1.0, a fully static SEO article generator.

The idea is simple: – No backend – No accounts – No tracking – BYOK via OpenRouter – Runs entirely in your browser – Outputs clean Markdown only

I built this because most SEO/AI writing tools are SaaS-first, opaque, and over-engineered. I wanted something transparent, cloneable, and easy to self-host.

What it does: – Generate long-form SEO articles – Contextual generation options (not hidden in settings) – Export Markdown or download .md files – Ghost / WordPress exports are prepared (UI only for now)

What it deliberately does not do: – No user accounts – No database – No server-side storage – No “AI platform” lock-in

The project is MIT-licensed and fully client-side. You can verify everything by reading the source.

Live demo: https://openseo.studio Repo: https://github.com/Vellis59/openseo-studio

Happy to answer questions or get feedback.

Hey HN! I just shipped WatchLLM - a semantic caching layer for LLM APIs that sits between your app and providers like OpenAI/Claude/Groq.

The problem: LLM API costs add up fast, especially when users ask similar questions in different ways ("how do I reset my password" vs "I forgot my password").

The solution: Semantic caching. WatchLLM vectorizes prompts, checks for similar queries (95%+ similarity), and returns cached responses instantly (50ms). If it's a miss, we forward to the actual API and cache for next time.

Built in 3 days with Node.js, TypeScript, React, Cloudflare Workers (edge deployment), D1, and Redis. Just added prompt normalization today to boost cache hit rates even further.

It's drop-in - literally just change your baseURL and keep using your existing OpenAI/Claude SDKs. No code changes needed.

Currently in beta with a generous free tier (50K requests/month). Would love feedback from anyone building LLM apps - especially on the semantic similarity threshold and normalization strategies.

Live demo on the site shows real-time cache hits and savings.

Pick an LLM to represent you and another LLM judge decides who wins

Hey HN, I’m Shubham, building Infina AI (https://infina.so )

I noticed I was creating ~30 Linear issues a day. Often I’d be in the middle of designing something or thinking through GTM, remember a bug or task, switch to Linear, write it up, assign it, set priority, then switch back. Same pattern with Slack—context switching dozens of times a day.

It wasn’t the time per action that bothered me as much as losing focus repeatedly. I kept thinking: when I already know what needs to be done, why do I have to stop what I’m doing just to type it somewhere?

That led me to experiment with voice-first workflows.

What we built Infina is a desktop app that lets you execute common work actions using voice, without switching tabs.

• Voice execution – Hold a key and say something like: “Create a Linear ticket: fix navbar bug, assign to Sarah, high priority.” or “Send a Slack message to the engineering channel: deployment is done.” The action happens in the background while you stay in your current app.

• Voice dictation – This is for writing text anywhere (Slack, email, docs). You can speak naturally and it cleans up filler words and structure, instead of raw transcription.

• Voice search – Ask a quick question (product, debugging, general knowledge) and get a short answer in a small popup, without opening a browser or new tab.

• Meeting notes – Infina runs in the background and capture meetings (Zoom, Meet, Teams, etc.) without a bot joining. You get transcripts, summaries, and searchable history. This is where the product originally started.

Over time, I found myself opening Linear and Slack much less. Tasks get captured immediately when I think of them, instead of relying on memory or context switching later.

There’s a short demo here showing ticket creation by voice: https://x.com/shubhmx/status/2003846700532978016

Infina works on macOS and Windows: https://www.infina.so

I’d genuinely love feedback from people here:

Does voice execution fit anywhere in your workflow?

What tools would actually be worth integrating?

Where would this feel unnecessary or annoying?

Happy to answer any technical or product questions.