2025年12月26日 的 Show HN

Hi HN,

I built a small Linux CLI tool called witr (Why Is This Running?).

The idea came from a situation most of us have hit: you log into a machine, see a process or port running, and immediately wonder why it exists, who started it, and what is keeping it alive right now.

witr traces a process, service, or port back to its origin and responsibility chain and explains it in a way that’s quick to read, especially when you’re debugging under pressure.

This is v0.1.0. It’s intentionally small and focused. Feedback, criticism, and edge cases are very welcome.

Repo: https://github.com/pranshuparmar/witr

Repo: https://github.com/valdanylchuk/xcc700

Hi Everyone! I just wrote my first compiler!

- single pass, recursive descent, direct emission

- generates REL ELF binaries, runnable using ESP-IDF elf_loader

- very basic features only, just enough for self-hosting

- treats the Xtensa CPU as a stack machine for simplicity, no register allocation / window usage

- compilable on Mac, probably also Linux, can cross-compile for esp32 there

- wrote for fun / cyberdeck project

Sample output from esp32:

    xcc700.elf xcc700.c -o /d/cc.elf
    
    [ xcc700 ] BUILD COMPLETED > OK
    > IN  : 700 Lines / 7977 Tokens
    > SYM : 69 Funcs / 91 Globals
    > REL : 152 Literals / 1027 Patches
    > MEM : 1041 B .rodata / 17120 B .bss
    > OUT : 27735 B .text / 33300 B ELF
    [ 40 ms ] >> 17500 Lines/sec <<

My best hope is that some fork might grow into a unique nice language tailored to the esp32 platform. I think it is underrated in userland hobby projects.

Hello HN,

I created a simple website which lets children (of all ages) sketch something and then animate it using AI. It's a small hobby project because I wanted to see what all the hype is about.

No account required (but because the sketch app allows image uploads and we all know we can't have nice things on the Internet, I will be moderating the submissions before showing them on the front page).

Stack: Excalidraw, Django, Postgres, Redis for caching, ComfyUI for the image to video workflow (Wan 2.2 14B I2V).

Let me know what you think. Merry Christmas!

Testing my auto-moderation logic. Please be gentle. No login. All messages are global.

MCP (Model Context Protocol) server that lets AI assistants check domain availability in real-time.

Features: - Multi-source: Porkbun, Namecheap, RDAP, WHOIS - Price comparison across registrars - Social handle checking (GitHub, Twitter, npm, etc.) - Premium domain detection with pricing insights

Works with any MCP-compatible client.

Install: npx -y domain-search-mcp

ISON (Interchange Simple Object Notation) - a data format optimized for LLMs and Agentic AI.

The problem: JSON wastes tokens. Curly braces, quotes, colons, commas - all eat into your context window.

ISON uses tabular patterns that LLMs already understand from training data:

JSON (87 tokens): { "users": [ {"id": 1, "name": "Alice", "email": "[email protected]"}, {"id": 2, "name": "Bob", "email": "[email protected]"} ] }

ISON (34 tokens): table.users id:int name:string email 1 Alice [email protected] 2 Bob [email protected]

Features: - 30-70% token reduction - Type annotations - References between tables - Schema validation (ISONantic) - Streaming format (ISONL)

Implementations: Python, JavaScript, TypeScript, Rust, C++ 9 packages, 171+ tests passing

pip install ison-py # Parser pip install isonantic # Validation & schemas

npm install ison-parser # JavaScript npm install ison-ts # TypeScript with full types npm install isonantic-ts # Validation & schemas

[dependencies] ison-rs = "1.0" isonantic-rs = "1.0" # Validation & schemas

Looking for feedback on the format design.

Every place I’ve seen run more than a couple of ML models in production ends up with a mess of bespoke inference services: different APIs, different auth, different logging, half-working dashboards, and tribal knowledge holding it all together.

I’ve been building a small side project that tries to standardize just the serving part — a single gateway in front of heterogeneous models (local, managed cloud, different teams) that handles inference APIs, versioning/rollback, auth, basic metrics, and health checks. No training, no AutoML, no “end-to-end MLOps platform”.

Before I sink more time into it, I’m trying to figure out whether this is:

a real gap people quietly paper over with internal glue, or

something that sounds useful but collapses under real-world constraints.

For people actually running ML in prod:

Do you already have an internal inference layer like this?

Where does inference usually go wrong (deployments, versioning, debugging, compliance)?

At what scale does it stop being worth abstracting at all?

Not announcing anything — genuinely curious whether this resonates or if I’m just rediscovering why everyone rolls their own.

Universal SDK for working with multiple LLM providers (OpenAI, Anthropic, Gemini, etc.). Built-in caching can reduce API costs by 90%+. 15K+ PyPI downloads.

pip install llmswap

Hey HN,

I built Crawlee Cloud, an open-source, self-hosted platform that lets you run Crawlee and Apify Actors on your own infrastructure.

The problem: The Apify ecosystem (Crawlee, SDK, Actors) is fantastic for web scraping, but it's tied to their cloud. If you want to keep your data on-prem, run on your own servers, or save on costs at scale, you're stuck.

The solution: Crawlee Cloud implements Apify's REST API so your existing Actors work without code changes. Just point APIFY_API_BASE_URL to your own server.

What's included:

  SDK compatible: Datasets, Key-Value Stores, Request Queues all work
  Docker-based: Each Actor runs in an isolated container
  Dashboard: Monitor runs, explore datasets, manage Actors
  CLI: Push, run, and manage Actors from your terminal

Stack: Node.js, Fastify, PostgreSQL, Redis, S3/MinIO, Next.js

GitHub: https://github.com/crawlee-cloud/crawlee-cloud

Happy to answer questions!

Hey HN! Web CLI, an open-source web-based command management tool just got an upgrade with Interactive Terminal support

Blazing-Fast Domain Redirects Without the DevOps Tax

Rediredge is a lightweight, self-hostable domain redirector that pairs a Go data plane with a Next.js control plane. It gives you instant 30x responses without cold starts, automatic HTTPS, and a beautiful dashboard that lets non-technical teammates manage redirects on their own.

Website: https://rediredge.app Github: https://github.com/leonardotrapani/rediredge Blog Post: https://leotrapani.com/blog/rediredge

Polibench runs the Political Compass questions across AI models so you can compare responses side by side. No signup.

Built on top of work by @theo (https://twitter.com/theo) and @HolyCoward (https://twitter.com/HolyCoward). Question set is based on the Political Compass: https://www.politicalcompass.org/

Early and rough. Feedback welcome on revealing questions, possible misuse, and ideas for extending it.

Happy to answer questions.

Inspired by the terrible search on the DOJ website, I created this project I've been working on over the last few days to modernize it. Slightly different than sites like JMail (which I highly recommend others play with too, super cool), I primarily focusing on both visual search, text semantic search, and full text search of all documents. Wanted to share the progress so far.

Any and all constructive feedback would be appreciated!

Work in progress: - More mobile friendly search - Better loading states - Better ranking on lean text and lean visual searches - Better thresholding of search results - Gallery view improvements including original document view with a thumbnail timeline. - Anyone can flag a document today, I'm working on taking those flags into the search results to better filter out redacted pages, blank pages, and junk pages while boosting consistently flagged newsworthy. - Open sourcing the processed dataset in a single download / torrent

I built a small web tool that automatically places text behind the main subject of an image.

Upload an image, add text, and the AI handles subject detection and masking. No signup, no watermark.

Built this because doing this effect manually in Photoshop is more annoying than it should be. Feedback welcome.

Arka (arka.so) is a AI analytics tool that lets you get insights + charts from any (structured or unstructured) data source. I built it because I was getting tired of writing SQL queries and creating Metabase charts at my last job.

I would love some feedback on our product:

How is the landing page / website

What use cases could this unlock for you?

We have some awesome tech behind the scenes and have some initial customers, but I am really keen on expanding towards a PLG motion where folks can sign up and get insights about their data fast.

Would love brutally honest feedback!

The `uuid` npm package is 8KB. For generating random IDs.

Here's the same thing in 200 bytes:

```javascript export function uuid() { return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => { const r = Math.random() * 16 | 0; return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16); }); } ```

That's it. RFC 4122 compliant. Version 4 (random). Variant bits correct.

```bash npm install tiny-uuid-gen ```

```javascript import { uuid } from 'tiny-uuid-gen'; const id = uuid(); // "550e8400-e29b-41d4-a716-446655440000" ```

When to use: You just need random IDs and bundle size matters. When NOT to use: Security-critical, need v1/v5, need crypto.getRandomValues().

Sometimes the boring solution is the right one.

GitHub: https://github.com/takawasi/tiny-uuid

---

Vix.cpp is a modern C++ runtime for building backend services. In v1.17.0, the focus is on complete, real-world examples, not toy demos.

What’s included: - HTTP routing & REST APIs - WebSocket runtime with typed messages - Shared HTTP + WebSocket lifecycle in a single process - Middleware pipeline (cache, CORS, rate limiting, auth, body limits) - Static files, compression, headers, security - Clean, production-oriented project layouts

Everything runs as a single binary with explicit control over performance, memory, and concurrency.

Repo & examples: https://github.com/vixcpp/vix

Happy to answer questions about design tradeoffs, performance, or architecture.

I’m currently building with GIA Tenica (an anagram for Agentic AI), an experimental autonomous pipeline designed to handle the "heavy lifting" of academic research while maintaining a strict audit trail.

The core problem I’m trying to solve is the "black box" nature of LLM research. Most agents just give you a final answer; GIA is designed so that every claim must have traceable support.

Some technical choices I made for this project:

Filesystem-first architecture: Instead of keeping state in memory, the pipeline writes durable artifacts (Markdown and JSON) to a project folder at every stage. This makes the entire thought process inspectable and allows you to re-run "gates" deterministically.

Schema-first contracts: I’m using JSON schemas as strict contracts between agents. If an agent’s output doesn’t hit the schema, the "gate" blocks the workflow.

Safety & Sandboxing: Since the pipeline can generate and execute analysis scripts, it runs them in a subprocess with isolated Python mode (-I) and a minimal allowlist. It’s not a full jail, but it’s a step toward safer autonomous code execution.

The "Referee" System: I’ve implemented a series of "Referees" (Agents A12–A15) that act as a quality control layer, checking for contradictions and style enforcement before the final draft is produced.

Current Status: This is very much a work in progress. It’s a prototype pipeline, not a finished product. I’m currently looking for contributors to help refine the "Evidence Layer" and the LaTeX paper structuring.

I’d love to hear your thoughts on the architecture, especially the use of schema-driven gates for grounding LLM outputs.

Repo: https://github.com/giatenica/gia-agentic-short

I built a PyTorch framework that achieves ~40% effective parameter reduction with 1.58x training and 2.05x inference speedups on mid-sized models—while keeping accuracy almost intact.Key ideas: Dynamic tension thresholds aggressively prune low-importance weights (with rollback for stability) Vibration-based deferral skips low-signal computations Entropy scheduling + sparse conversion for hardware gains

It's a drop-in replacement for nn.Linear (CurvatureTuner) and works out-of-the-box on MLPs. Planning Transformer tests next.Benchmark on ~400k param MLP (synthetic data, 5 epochs): Baseline: Train 2.45s / Inf 0.0045s Enhanced: Eff params ~281k (40% reduction) / Train 1.55s (1.58x) / Inf 0.0022s (2.05x)

Repo (MIT): https://github.com/wwes4/AI_Accel_1.5x Feedback, forks, and real-dataset tests very welcome! Inspired by unconventional efficiency ideas.

Hello HN,

I built Mergen to prove that we can have modern, React-based UIs without the heaviness of Electron.

Mergen is a cross-platform SQL client (currently supporting MySQL/Postgres) that uses Wails. This allows it to use the native system webview, resulting in a ~15MB app size and instant startup times compared to DBeaver or TablePlus.

Features for HN crowd:

Local-First: No cloud accounts, fully offline capable.

Secure: Native SSH Tunneling support.

Visuals: Built-in data visualization (charts) from query results.

Code is open source (GPLv3).

Repo: https://github.com/parevo/mergen

Happy to answer technical questions about the Wails implementation!

I have been working on reverse engineering SQLite in Go. Not exactly as I am borrowing some features from other databases so it is not a 1 to 1 exact replica but the main idea is the same and I have been keeping it as close as possible. A simple embedded single file database. It's an ongoing effort but I wanted to share what I have done so far after over a year.

One question. One answer. One email field.