Show HN for January 7, 2026

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

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

OP here.

I took the unofficial IKEA US dataset (originally scraped by jeffreyszhou) and converted all 30,511 products into a flat, markdown-like protocol called CommerceTXT.

The goal: See if a flatter structure is more efficient for LLM context windows.

The results: - Size: 30k products across 632 categories. - Efficiency: The text version uses ~24% fewer tokens (3.6M saved total) compared to the equivalent minified JSON. - Structure: Files are organized in folders (e.g. /products/category/), which helps with testing hierarchical retrieval routers.

The link goes to the dataset on Hugging Face which has the full benchmarks.

Parser code is here: https://github.com/commercetxt/commercetxt

Happy to answer questions about the conversion logic!

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

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!

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!

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

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.

Each moving arrow represents a real bike ride. There are 291 million rides in total, covering 12 years of history from June 2013 to December 2025, based on public data published by Lyft.

If you've ever taken a Citi Bike ride 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.

Some technical details:

- No backend! Processed data is stored in parquet files on a 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

Legend:

- Blue = E-Bike

- Purple = Classic Bike

- Red = Bike docked

- Green = Bike unlocked

Hey HN!

I’m Collin, a 20 year old law student from Amsterdam. I built Cited AI, an AI that gives accurate and verifiable answers from your documents/context.

As a law student who uses AI a lot, I know how important it is that answers are actually accurate and verifiable. I remember many instances where I'd ask a chatbot like ChatGPT or Claude about case law or long documents, and it would either hallucinate facts that didn't exist, or fail to give me the exact passages from my source documents so I could verify its answers. Even when specifically asking for exact quotes, finding that passage in the original document is still a hassle. That's why last November I started building Cited.

It should work with all types of content, complex PDFs (including math heavy ones) and long documents up to 75k words. No RAG or chunking is used, to make sure the full document is in the LLM's context.

I would love to hear your feedback!

OP here. I built RepoReaper to solve code context fragmentation in RAG.

Unlike standard chat-with-repo tools, it simulates a senior engineer's workflow: it parses Python AST for logic-aware chunking, uses a ReAct loop to JIT-fetch missing file dependencies from GitHub, and employs hybrid search (BM25+Vector). It also generates Mermaid diagrams for architecture visualization. The backend is fully async and persists state via ChromaDB.

Link: https://github.com/tzzp1224/RepoReaper

So I made a thing Got tired of that Gemini watermark in the corner of Nano Banana images, so I built a little Chrome extension to remove it.

It's called "Peel Banana" and I just put it up on the Chrome Web Store. Completely free.

- The whole thing runs locally in your browser using a reverse-blending algorithm(based on allenk's GeminiWatermarkTool). - No uploads, no servers, no external API. - Just drag in your images and it spits out clean versions in about a second. Keeps the original quality too. - You can do a whole batch at once if you've got a bunch of images to process.

Anyway, figured I'd share in case anyone else finds it useful. Let me know what you think!

If this helped you out, would love it if you dropped a rating. Five stars would make my day

Big thanks to anyone who leaves a review

I spent way too long making a visual list of all Game Boy releases to help with my writing. The whole thing is all HTML and CSS, no scripting anywhere.

Just built a small tool and created some comparsion of country size vs. planets. Greenland seems larger than i thought.

The tool allows you to drag a counry to other planet to see the size there.

Most research tools help you collect links. Kerns is built for ongoing research.

You define topics and sources once. Kerns continuously tracks them over time, surfaces what changes, and structures the material so understanding compounds instead of resetting each session.

The key difference is the interface layer. Beyond feeds and summaries, Kerns organizes research into reasoning-ready views—maps, structured summaries, and synthesized perspectives—so you can actually think through complex areas rather than just store information.

We built this for people doing deep, long-running research (researchers, analysts, investors, founders, autodidacts) where the hard part isn’t finding sources, but keeping a coherent mental model as the space evolves.

Would love feedback, especially from people who’ve tried to maintain research across weeks or months.

Hi HN,

This is cmd-chat, a Python terminal chat app designed around a few constraints:

- No central servers - No message or key persistence - No plaintext credentials ever sent over the network

Authentication uses *SRP*, and messages are encrypted after key exchange. All data lives in memory only and disappears when the process exits.

This was partly a learning project and partly an experiment in building a “minimum-trust” chat system using standard cryptographic primitives.

Curious to hear thoughts on the threat model, crypto choices, and overall design.

I built a CLI tool that scans your Metabase instance to find which SQL questions reference a column or table you're about to drop/rename.

metabase-impact --metabase-url http://localhost:3000 --api-key "mb_xxx" --drop-column orders.user_id

It outputs affected questions with direct links so you can fix or archive them before deploying.

Built this after breaking dashboards one too many times. Uses sqlglot for SQL parsing (handles aliases and complex queries). Only works on native SQL questions, not MBQL/GUI queries.

I got tired of doom-scrolling and skimming headlines that all blur together, so I built a small site that turns today’s tech and startup news into a calm, continuous radio-style stream.

No playlists. No jumping tabs. You just press play and listen.

It updates throughout the day and feels more like tuning into a station than consuming feeds.

Curious if this kind of “news radio for the internet” makes sense or if it’s just me

America's TFR is 1.67. I wanted to understand what it would actually take to get back to replacement (2.1), so I built a simulator where you can stack policies and see the projected effects. Every policy has cited effect sizes (Cohen, Milligan, Raute, etc.) with confidence levels. You can click any policy title to see the methodology and sources. The model includes:

Fiscal tracking (policy costs, deficit impact, GDP effects) Diminishing returns when stacking similar interventions Immigration with selection mechanisms and generational convergence Tax increases and entitlement reform as funding options (with growth drag) A few "illiberal" policies for analytical completeness

The honest answer seems to be: it's really hard. Most realistic packages get you to ~1.9-2.0 at enormous cost, and that's assuming the effect estimates transfer to the US context (they might not). Built with vanilla JS. Feedback welcome - especially on the methodology or effect estimates I got wrong.

Abstract Port Graphs is a framework for building Domain Specific Languages (DSLs), where programs are represented as graphs. This project was created in pursuit of the ARC AGI challenge (more details on that at https://arcprize.org). By building a DSL on top of it for ARC puzzles, I was able to create compact solutions to the puzzles, which can be generated automatically via program synthesis techniques. The goal here was to explore program synthesis and symbolic AI approaches. The rationale for using graphs was the ability to detect isomorphisms between equivalent programs, leading to reusable components. The page includes additional links to the GitHub repo and a brief paper on the project. Would love feedback on the work, and to connect with anyone interested in ARC!

Finding open source issues is easy. Deciding which ones are worth your time is not.

I built Contrib.FYI as a simple web app to reduce that decision cost.

Instead of relying on static, curated lists, it uses live GitHub API data and shows issues in chronological order, so discovery stays fresh.

On top of that, it surfaces a few early signals (language, stars, no comments, no linked PRs) to help you avoid opening issues that are already being worked on.

The goal is not to find more issues, but to find better candidates to spend your time on.

Source code is available here: https://github.com/K-dash/contrib-fyi

Feedback is welcome.

I built a small web tool that lets people create Arabic calligraphy without needing design software. Most existing tools are either too complex or very limited, so I wanted something simple and accessible.

Features: • Write Arabic directly or translate from English • 11 classic calligraphy styles (Thuluth, Naskh, Kufi, Diwani, etc.) • Adjust layout, colors, line height, stroke, and rotation • Export as PNG, JPG, or SVG • No signup required

I’d appreciate any feedback on performance, UI, or calligraphy accuracy. This is a solo side project and still evolving.

Site: https://arabiccalligraphygenerator.online

It also features "Country Quest," a websocket-based multiplayer game where players race to identify a country from clues. The backend uses Node.js/Socket.io and the frontend is React.

It's free and open to play.

This is a declarative orchestration framework for stateless short-lived LLM agents.

Agents are orchestrated by hierarchical state machines (HSMs).

The HSMs and agents are defined in YAML, with hooks and webhooks for additional functionality.

* FlatAgent: A single LLM call: model + prompts + output schema.

* FlatMachine: A state machine that orchestrates multiple agents, actions, and state machines.

Examples: - https://github.com/memgrafter/flatagents/tree/main/sdk/pytho... - https://github.com/memgrafter/research-crawler-flatagents - https://github.com/memgrafter/claude-skills-flatagents

A hobby project designed to create a competition platform for the traveling salesman problem.

I spend some days to develop a content-aware AI named AiRenamify app to name your files.

It's smartest way to organize files. AiRenamify uses content-aware AI to give every file its true name. Drag, drop, and let AI name your files instantly.

Features: 1) Intelligent Recognition Uses advanced AI (LLMs and Vision) to "read" and "see"your files. It understands the content of images and documents to generate descriptive, human-readable names automatically.

2) Privacy & Security We prioritize your privacy. Your files are transmitted securely via encrypted connections solely for analysis and are immediately discarded. We never store your personal files.

3) Smart Customization Full control over your filenames. Configure case styles, set target languages, or add custom instructions like "Always include the primary color" to guide the AI.

4) Bulk Processing Rename thousands of files in seconds. AiRenamify handles large queues efficiently, saving you hours of manual work while maintaining high accuracy.

You can access to the app by: https://airenamify.com.

didn't pivot this time but changed the homepage for a more minimalistic look.

What is currently in the top content of /about used to be the homepage

Wdyt? Does the giant coin make you want to click?