Show stories

I forked a PyTorch DeepDream implementation and added video support with temporal consistency. It produces smooth DeepDream videos with minimal flickering, and is highly flexible including many parameters and supports multiple pretrained image classifiers including GoogLeNet. Check out the repo for sample videos! Features:

- Optical flow warps previous hallucinations into the current frame

- Occlusion masking prevents ghosting and hallucination transfer when objects move

- Advanced parameters (layers, octaves, iterations) still work

- Works on GPU, CPU, and Apple Silicon

Each moving arrow represents one real bike ride out of 291 million, and if you've ever taken a Citi Bike before, you are included in this massive visualization!

You can search for your ride using Cmd + K and your Citi Bike receipt, which should give you the time of your ride and start/end station.

Everything is open source: https://github.com/freemanjiang/bikemap

Some technical details: - No backend! Processed data is stored in parquet files on a Cloudflare CDN, and queried directly by DuckDB WASM

- deck.gl w/ Mapbox for GPU-accelerated rendering of thousands of concurrent animated bikes

- Web Workers decode polyline routes and do as much precomputation as possible off the main thread

- Since only (start, end) station pairs are provided, routes are generated by querying OSRM for the shortest path between all 2,400+ station pairs

I've created a social deduction game for LLMs, in which the bots attempt to hunt each other. It's a Mafia group turing test: the models are told to find who the bot is - where, in fact and unbeknown to them, they are all bots. I did this a while back so models aren't the newest, and they are all non-thinking (for speed and token costs). Et voilà.

I would like to share an open database focused on link-level metadata extraction and aggregation, which may be of interest to researchers.

The project maintains a structured dataset of links enriched with metadata such as:

- page title

- description / summary

- publication date (when available)

- thumbnail / preview image

- etc.

The goal is to provide a reusable, inspectable set of link metadata that can be used for experiments in areas such as:

- RSS and feed analysis

- news analysis

- link rot analysis?

The database is publicly available here:

https://github.com/rumca-js/RSS-Link-Database-2025

There are also databases for previous years

I built Zone, an iOS app blocker using Apple's Family Controls API. The differentiator is simple: it counts how many times you try to open blocked apps. Most app blockers just block. But I found the attempt count more revealing than the block itself. Seeing "you tried to open Instagram 47 times today" was a wake-up call I didn't get from blocking alone. Technical notes: Family Controls API is poorly documented but provides system-level blocking that actually works (unlike overlay approaches). Had to handle some edge cases around authorization persistence and count tracking across app restarts. The API requires Screen Time permissions which adds friction to onboarding but ensures reliable blocking. One interesting discovery: users seem to prefer seeing raw attempt counts over gamified metrics (streaks, badges, etc). Less is more for this use case. Built in SwiftUI, local storage only, no subscriptions. Took about 3 months part-time. Curious if others have worked with Family Controls API and what challenges you faced. Also interested in thoughts on digital wellness apps in general - does tracking behavior change it, or just make you more aware without actual change?

The article discusses the author's experience of designing an overly complex Dungeons & Dragons character sheet, highlighting the balance between functionality and simplicity in game design and application development.

The article discusses the process of creating an animated sprite hero using JavaScript and HTML5 canvas. It covers key steps such as loading sprite images, managing animation frames, and implementing user interactions to control the hero's movement and actions.

A fast SOCKS5 proxy that tunnels your traffic through what looks like normal SMTP email, bypassing Deep Packet Inspection firewalls.

How it works: - Client runs a local SOCKS5 proxy (127.0.0.1:1080) - Traffic is sent to server disguised as SMTP (EHLO, STARTTLS, AUTH) - DPI sees legitimate email session, not a VPN/proxy

Features: - One-liner install on any Linux VPS - Multi-user with per-user secrets and IP whitelists - Auto-generated client packages (just double-click to run) - Auto-reconnect on connection loss - Works with any app that supports SOCKS5

Tech: Python/asyncio, TLS 1.2+, HMAC-SHA256 auth

GitHub: https://github.com/x011/smtp-tunnel-proxy

Just build a local tool for designing gears that kinda looks and works nice

Two years ago, someone on HN shared an interesting ADHD hack: a tiny LED that blinks at 120 bpm and gradually slows to 60 bpm, supposedly helping your brain sync and calm down into focus mode.

I found Qiaogun's implementation (ADHD_Blink) for M5StickC Plus, and adapted it for the newer M5StickC Plus2 with some tweaks - simpler 50% duty cycle flash, configurable ramp-down, auto sleep, etc.

Honestly, I'm not sure if it actually works. I'll be trying it out myself to see. But the building process itself was quite fascinating.

I used Claude Code for the entire implementation - from reading the original codebase, to modifying the firmware, to flashing the device. There's something surreal about an AI having full control over a physical piece of hardware.

It made me wonder: in the future, could AI-connected devices dynamically rewrite their own firmware based on user needs? Imagine telling your device "make this button do X instead" and it just... does.

Original HN comment: https://news.ycombinator.com/item?id=38274782 Based on: https://github.com/Qiaogun/ADHD_Blink Hardware: M5StickC Plus2 (~$20)

Happy to hear thoughts, or if anyone has actually tried this LED trick.

Hi HN,

I’ve been working on Flowscape, a 2D canvas engine focused on building interactive editors and visual tools. It provides low-level control over scenes, nodes, and interactions without enforcing a specific UI or workflow.

The goal is to give developers a flexible foundation for custom editors, diagrams, and canvas-based interfaces. I’d love feedback on the API design, architecture, and real-world use cases.

Demo: https://flowscape-ui.github.io/core-sdk/?path=/story/interac... GitHub: https://github.com/Flowscape-UI/core-sdk

I built this because Cursor, Claude Code and other agentic AI tools kept giving me tests that looked fine but failed when I ran them. Or worse - I'd ask the agent to run them and it would start looping: fix tests, those fail, then it starts "fixing" my code so tests pass, or just deletes assertions so they "pass".

Out of that frustration I built KeelTest - a VS Code extension that generates pytest tests and executes them, got hooked and decided to push this project forward... When tests fail, it tries to figure out why:

- Generation error: Attemps to fix it automatically, then tries again

- Bug in your source code: flags it and explains what's wrong

How it works:

- Static analysis to map dependencies, patterns, services to mock.

- Generate a plan for each function and what edge cases to cover

- Generate those tests

- Execute in "sandbox"

- Self-heal failures or flag source bugs

Python + pytest only for now. Alpha stage - not all codebases work reliably. But testing on personal projects and a few production apps at work, it's been consistently decent. Works best on simpler applications, sometimes glitches on monorepos setups. Supports Poetry/UV/plain pip setups.

Install from VS Code marketplace: https://marketplace.visualstudio.com/items?itemName=KeelCode...

More detailed writeup how it works: https://keelcode.dev/blog/introducing-keeltest

Free tier is 7 tests files/month (current limit is <=300 source LOC). To make it easier to try without signing up, giving away a few API keys (they have shared ~30 test files generation quota):

KEY-1: tgai_jHOEgOfpMJ_mrtNgSQ6iKKKXFm1RQ7FJOkI0a7LJiWg

KEY-2: tgai_NlSZN-4yRYZ15g5SAbDb0V0DRMfVw-bcEIOuzbycip0

KEY-3: tgai_kiiSIikrBZothZYqQ76V6zNbb2Qv-o6qiZjYZjeaczc

KEY-4: tgai_JBfSV_4w-87bZHpJYX0zLQ8kJfFrzas4dzj0vu31K5E

Would love your honest feedback where this could go next, and on which setups it failed, how it failed, it has quite verbose debug output at this stage!

I've create a small daily word puzzle based on real UK headlines from the day before. The letters are scrambled and you rebuild the original headline.

I've spent the last few months working on something I wish I'd had years ago. I kept running into the same issue: CI green, production mail broken. TLS handshake failures, DKIM alignment mismatches, SPF soft-fails ... the stuff that only surfaces when real mail servers are involved. Most test tools (Mailpit, MailHog) are catch-alls. They confirm "an email was sent" but don't validate the protocol. They also aren't designed for network-exposed environments: no auth, unprotected Web UI, easy to enumerate messages.

VaultSandbox is my attempt at fixing that. It's a self-hosted SMTP gateway (AGPLv3) that validates SPF, DKIM, DMARC, and rDNS on every incoming message. You keep your production email provider (Postmark, SendGrid, SES) in tests and you just change the recipient domain. No mocking, no config changes. There are client SDKs (Node, Python, Go, Java, .NET), plus a Web UI and a CLI for manual testing.

Some technical details:

Deterministic Tests Instead of polling or sleep loops, the SDKs use Server-Sent Events (SSE) so test assertions trigger the moment the mail hits the gateway.

Minimal infrastructure footprint Built with NestJS and Angular, with no external database dependency to keep the container footprint small and easier to reason about.

Post-Quantum Encryption I use ML-KEM-768 for the encryption layer. Incoming mail is encrypted immediately using a client-generated public key and the plaintext is discarded. The server only ever stores encrypted message data and cannot decrypt it. I chose PQ because I wanted to build something I wouldn't have to revisit in five years. If it handles large PQ keys reliably, everything else is easy.

Quick start: https://vaultsandbox.dev/getting-started/quickstart/

Site: https://vaultsandbox.com

I'd love feedback, especially on whether AGPLv3 would be a blocker for something you'd self-host in dev.

Raymond here from Butter.dev, an LLM response cache built as a chat-completions proxy. Today we're launching a key feature for the platform: the ability to generalize on dynamic, templated inputs.

Caching at the HTTP request level has the obvious problem of generalizability. Nearly no request is identical, due to templated variables (like names) and metadata (like timestamps), so exact-match cache lookups rarely hit. We solve this at Butter by using LLMs to detect dynamic content in requests and derive their inter-relationships, allowing the cache entry to be stored as a template + variables + deterministic code. This allows future requests to contain different variable data, yet still serve from cache.

We've found this approach greatly improves cache hit rate, and believe it could be useful for agents performing repetitive back-office tasks, computer use, or data transformations where input data is frequently of the same shape.

- You can see a demo of learning patterns here: https://www.youtube.com/watch?v=ORDfPnk9rCA

- We wrote more about the technical approach here: https://blog.butter.dev/on-automatic-template-induction-for-...

- It's free to try out here: https://butter.dev/auth

Author here! Some context: I published this 48 hours ago and it was auto-listed on MCPMarket (the MCP tools directory). Got 700+ organic downloads with zero marketing—developers were actively searching for exactly this solution.

The "Git Accelerator" optimization story:

Initially used a file walker that took 6.6s on Chromium. Profiling showed 90% was filesystem I/O. The fix: git ls-files returns 480k paths in ~200ms. Added smart heuristics for untracked files (only scan dirs <50k files), bringing total to 0.46s.

Why this matters: Agents can't wait 10 seconds for search. Sub-500ms makes it feel instant, changing how they explore codebases.

Installation:

  Cursor: npx mantic.sh@latest
  VS Code: npx mantic.sh@latest
  CLI: npm i -g mantic.sh

Happy to answer questions!

Hey HN,

Claude Code is pretty agentic now. It writes scripts, calls APIs, uses CLIs. But when something requires actually clicking through a website, it stops and asks me to do it.

Problem is, I'm often unfamiliar with these platforms myself. "Go to App Store Connect and generate a P8 key" okay but where? I end up spending 10 minutes navigating menus I've never seen before.

I started delegating these tasks to Perplexity's Comet browser. It handles the clicking, returns what I need. But copy-pasting between Claude and Comet got old fast.

So I built this MCP server to connect them directly. Now when Claude needs to interact with a website that has no API, it can just ask Comet to handle it.

  Examples:
  - Grab my app ID from RevenueCat dashboard
  - Generate a P8 key in App Store Connect
  - Navigate admin panels behind login walls

Comet doesn't have an API, so this uses CDP to communicate with it directly.

The article discusses Git Prime, a web-based tool that helps developers manage their Git repositories more effectively. It provides features like project monitoring, code review, and team collaboration to improve the software development workflow.

Long time lurker here. My family had a pen-and-paper game we'd play on long drives to visit my great-grandmother. After she passed, I spent the holidays recreating it: https://a26z.fun

How it works:

Find 15 words from a category (like "Stone Fruits," "US States," or "Dog Breeds") as fast as you can. Once you meet the 15 word minimum, you can play for as long as you want.

Each letter shows how many target words start with it (A¹ = one word starts with A, N² = two words start with N)

That small ² in the bottom-right? Multi-word answers allowed. For "US States" with N², both "NEW YORK" and "NORTH DAKOTA" count

Unlimited guesses, 2 hints, and a shuffle button to reorder by frequency.

Example: Category: US States | Letters: A¹ M¹ N² S² Answers: ALABAMA, MONTANA, NEW MEXICO, SOUTH DAKOTA

If you're into Connections or Strands, this scratches a similar itch but with a deduction twist.

Runs local browser instances of Meta's SAM Audio playground so you can isolate vocals/drums from audio of any length without running SAM locally or hosting inference.

- Audio >29s is chunked with ffmpeg

- Audio chunks and prompts are submitted in parallel to the playground via Playwright

- Web UI for storing tracks and re-editing previous outputs

Demo video: https://github.com/user-attachments/assets/d5d3b53d-6ac9-40f...

Hi HN, author here.

I built Tylax because I wanted to migrate my old LaTeX papers to Typst but found existing regex-based scripts too fragile for nested environments.

Tylax parses LaTeX into an AST (using mitex-parser) and converts it to Typst code. It supports: - Full document structure (not just math snippets) - Complex math (matrices, integrals) - Experimental TikZ -> CeTZ graphics conversion - Runs in browser via WASM

Repo: https://github.com/scipenai/tylax Web Demo: https://convert.silkyai.cn/

Happy to answer any questions!

Hi HN, I'm Barry and I've built Prism.Tools (https://blgardner.github.io/prism.tools/) – a collection of client-side developer utilities that respect your privacy.

Many of these tools were used way back in the days when I ran a BBS and started my communities first ISP, serving three local communities with Dial-Up Internet, Web Hosting etc. The tools have been refined to reflect the changes in tech since then and designed for the Novice and Pro alike. As I locate more tools others may find useful I will refine and add them to the collection. Use them, Share them, or not. They will be here if you need them...

40+ dev tools (JSON formatters, regex tester, base64 encoder, Git command helper, etc.) that run entirely in your browser. Zero tracking, zero analytics, zero data collection – everything processes locally. Self-contained HTML files with no build process or frameworks.

I realized I had a lot of tools/utilities I've built over the years for my own use. I lothe having to 'sign-up' just to access/use simple utilities that I can create myself. I've refined them and put them in one safe place so I could easily access them if/when needed. I decided to make them available via Github Pages for anyone that may find them useful. Prism.Tools is the result.

Each tool is a standalone HTML file with embedded CSS and JavaScript. No frameworks, no npm packages, no build steps – just open the file and it works.

The entire toolset:

- 100% client-side processing – your data never leaves your browser.

- No external dependencies except for specific libraries from cdnjs.cloudflare.com (marked.js for markdown, exifr for image metadata, etc.)

- Consistent dark UI – every tool follows the same design language for familiarity.

- Vanilla JS where possible – only reaching for Public CDN Resources when necessary.

The constraint of "single HTML file" was intentional. It forces simplicity and ensures tools remain maintainable. It also means users can inspect, modify, or self-host any tool trivially.

These tools have helped me with debugging production issues, Quick formatting tasks, learning Git commands (the Git command helper has been particularly helpful)

Just visit https://blgardner.github.io/prism.tools/ and try any tool. No signup, no install.

What tools are missing that you find yourself needing? Any performance issues with specific tools? UI/UX friction points?

All tools follow the same privacy-first philosophy... Your data stays in your browser. No accounts, no tracking, no servers processing your information. The project is also a demonstration that you don't always need React, Vue, or complex build pipelines – sometimes vanilla JavaScript in a single HTML file is exactly the right tool for the job.

Vanilla JavaScript (ES6+) CSS3 with CSS Grid Minimal external libraries: marked.js, exifr, highlight.js, sql-formatter (all from CDN) No frameworks, no bundlers, no npm Hosted on Github Pages

Happy to answer questions about the technical implementation, design decisions, or specific tools!

All tools are inspectable – just view source on any page to see exactly how they work!

Why - I got sick of apps abusing notifications on my Android phone. While the OS does give you the ability to switch off notifications based on channels, most apps either don't use it or abuse it intentionally. In my case, I live in a gated society that uses an app called MyGate to allow visitors, and the app intentionally pushes ads through the same channels since you cannot block them.

What - DoNotNotify is an app that logs all incoming notifications, and displays them grouped by app. It also captures the action behind the notification, which can be triggered from the app itself. From this log, you can create rules to whitelist/blacklist notifications from apps depending on their notification content. These filters can even be regex expressions, which allows for more complicated use-cases. The app ships with some pre-defined rules for popular apps like Facebook, Amazon, Instagram, Netflix, TikTok, Reddit etc.

Where - The website is at https://donotnotify.com/.

Would also like to call out that the app runs purely on your device, never communicates with anything on the Internet, and only requires notifications access to work. It is completely free, and there is no advertising or hidden gotchas.

Stash is a decentralized storage and sharing platform that allows users to securely store, access, and share their digital files across devices and with others, using blockchain technology to ensure data privacy and ownership.

When you think of AI videos, you think of something like Sora or Veo 3 (diffusion). What if the AI could write the code for a video like a website? This thought experiment led me to create Mike. It writes React code which can be rendered into a video. You can ask the AI to use any Node library to render graphs, animations, simulations.

I created a small webapp, to create simple audio loops online. A bit rough around the edges but gets you started in less than 10 seconds on creating loops.

Hi HN! I built titanaiexplore.com — a free, community-curated discovery hub for AI tools, tutorials, projects, and resources.

It categorizes emerging AI platforms and educational content to help both beginners and experienced builders find high-quality tools and learning paths in one place. Features include:

• Curated collection of AI tools across categories • Tutorials, guides, and explainers for practical usage • Featured projects and community contributions • Search and tagging for quick discovery

Would love to hear what the HN community thinks — feedback, ideas, or areas to improve are all welcome!

Hey folks — here’s a small experiment I hacked together over the weekend:

https://cleoselene.com/

In short, it’s a way to build multiplayer games with no client-side game logic. Everything is rendered on the server, and the game itself is written as simple Lua scripts.

I built this to explore a few gamedev ideas I’ve been thinking about while working on Abstra: - Writing multiplayer games as if they were single-player (no client/server complexity) - Streaming game primitives instead of pixels, which should be much lighter - Server-side rendering makes cheating basically impossible - Game secrets never leave the server

This isn’t meant to be a commercial project — it’s just for fun and experimentation for now.

If you want to try it out, grab a few friends and play here: https://cleoselene.com/astro-maze/

I made SludgeReport to update itself daily with AI and Startup news. I hope you like it.