Show HN за 26 ноября 2025 г.

I built a system that monitors ~200,000 news RSS feeds in near real-time and clusters related articles to show how stories spread across the web.

It uses Snowflake’s Arctic model for embeddings and HNSW for fast similarity search. Each “story cluster” shows who published first, how fast it propagated, and how the narrative evolved as more outlets picked it up.

Would love feedback on the architecture, scaling approach, and any ways to make the clusters more accurate or useful.

Live demo: https://yandori.io/news-flow/

Hi HN,

I built a WordPress plugin called Bandwidth Saver. It takes the images your site already has and serves them through Cloudflare R2 and Workers, which means zero egress fees and extremely low storage cost. The goal is to make image delivery fast and cheap without adding any of the complexity of traditional optimization plugins.

The idea is simple. WordPress keeps generating images normally. The plugin rewrites the URLs on the frontend so images are served from a Cloudflare Worker. On the first request, the Worker fetches the original image and stores it in R2. After that, Cloudflare’s edge serves the image from its global cache with no egress charges. There’s no need to preload or sync anything, and if something fails, the original image loads. That’s the entire system.

I built this because most image CDN plugins try to do everything: compression, resizing, AI transforms, asset management, custom dashboards, and monthly fees. That’s useful for some users, but it’s unnecessary for most sites that just want their existing media to load faster without breaking the bank. Bandwidth Saver focuses only on delivery, not transformations. It’s intentionally minimal.

There are two ways to use it. The plugin is completely free if you want to run your own Cloudflare Worker. I included the Worker code and the steps needed to deploy it. If you don’t want to deal with any Cloudflare setup, there’s a managed option for $2.99 per month that uses my Worker and my R2 bucket. I’m trying to keep it accessible while also covering operational costs.

The plugin works with any theme or builder and doesn’t modify the database. It only rewrites URLs on output. WordPress remains the system of record for all media. R2 simply becomes a cheap, durable cache layer backed by Cloudflare’s edge.

I’m especially interested in feedback about the approach. Does the fetch-on-first-request model make sense? Is the pricing fair for a plugin of this scope? Should I prioritize allowing users to connect their own R2 buckets or the managed service? And for those with experience in edge compute or CDNs, I would love thoughts on how to improve the Worker or the rewrite strategy.

Thanks for reading, happy to answer any questions.

Current AI chat assistants face a fundamental challenge: context management in long conversations. While current LLM apps use multiple separate conversations to bypass context limits, a truly human-like AI assistant should maintain a single, coherent conversation thread, making efficient context management critical. Although modern LLMs have longer contexts, they still suffer from the long-context problem (e.g. context rot problem) - reasoning ability decreases as context grows longer.

Memory-based systems have been invented to alleviate the context rot problem, however, memory-based representations are inherently lossy and inevitably lose information from the original conversation. In principle, no lossy representation is universally perfect for all downstream tasks. This leads to two key requirements for defining a flexible in-context management system:

1. Preserve raw data: An index system that can retrieve the original conversation when necessary.

2. Multi-resolution access: Ability to retrieve information at different levels of detail on-demand.

ChatIndex is a context management system that enables LLMs to efficiently navigate and utilize long conversation histories through hierarchical tree-based indexing and intelligent reasoning-based retrieval.

Open-sourced repo: https://github.com/VectifyAI/ChatIndex

Hi HN,

I’ve been working on Zephyr3D, an open-source 3D rendering engine for the modern web, plus a visual editor that runs entirely in the browser.

- Written in TypeScript - Supports WebGL/WebGL2/WebGPU - Comes with a visual editor that runs in the browser (no installation required)

With the recent updates, a few things might be interesting to people here:

Engine & rendering ------------------

- WebGL/WebGPU abstraction with a TypeScript API - PBR rendering - Cluster lighting & Shadow Maps - Clipmap-based terrain for large landscapes - Sky Atmosphere & Height-based fog - FFT water system - Temporal anti-aliasing (TAA) - Screen-space motion blur

The goal is to make it possible to build reasonably complex 3D experiences that run directly in the browser, without native dependencies.

In-browser editor -----------------

The editor is a web app built on top of the engine and runs completely in the browser. It currently supports:

- Project management - Scene editing - Node-based material blueprints - Animation editing - Script binding and a scheduling system - Prefabs for reusing entities across scenes - Preview and one-click publishing to the web

All project data is handled via a virtual file system (VFS) that can plug into different backends (in-memory, IndexedDB, HTTP, ZIP, DataTransfer, etc.), so saving/loading works entirely on the client side.

Links -----

Homepage: https://zephyr3d.org Editor (runs in the browser): https://zephyr3d.org/editor/ GitHub: https://github.com/gavinyork/zephyr3d

I'd love feedback on:

- How the in-browser editor workflow feels (performance, UX, what’s missing) - Whether the VFS approach for project data makes sense for real projects - Any red flags you see in the engine architecture or WebGPU/WebGL abstraction - What would be deal-breakers or must-have features for using this in games, data viz, or other interactive web experiences

I’ll be around to answer questions and can go into more detail about the rendering pipeline, the editor internals, or anything else you’re curious about.

Hi all, I built a CLI tool that allows you to seamlessly install software from GitHub release assets, similar to how your system's package manager installs software.

It works by exploiting common patterns among GitHub releases across different open-source software such as naming conventions and file layouts to fetch proper release assets for your system and then downloading the proper asset onto your machine via the GitHub API. Parm will then extract the files, find the proper binaries, and then add them to your PATH. Parm can also check for updates and uninstall software, and otherwise manages the entire lifecycle of all software installed by Parm.

Parm is not meant to replace your system's package manager. It is instead meant as an alternative method to install prebuilt software off of GitHub in a more centralized and simpler way.

It's currently in a pre-release stage, and there's a lot of features I want to add. I'm currently working (very slowly) on some new features, so if this sounds interesting to you, check it out! It's completely free and open-source and is currently released for Linux/macOS. I would appreciate any feedback.

Link: https://github.com/yhoundz/parm

It's quite limited but does the job, I invite anybody not aware of what cram tests are to give them a try, being on Unix with the original cram or Windows with this one ;)