Show HN for October 19, 2025

I built Duck-UI, a web-based SQL editor that runs DuckDB entirely in your browser via WebAssembly. No backend required.

The Problem: Every time I needed to query csv, parquet, or even to play with SQL, I had to either: (a) spin up a Jupyter notebook (b) use the CLI (c) upload to a hosted service.

Friction at every step (TOO MUCH to load a csv or even to test some sql (study)...

The Solution: DuckDB's WASM runtime lets us run SQL analysis client-side. Load CSV/JSON/Parquet files from disk or URL, write SQL, get results instantly. Data stays on your machine. What It Does:

SQL editor with autocomplete & syntax highlighting Import CSV, JSON, Parquet, Arrow (local or remote URLs) Query history, keyboard shortcuts, theme toggle Persistent storage via OPFS (data survives browser refresh) Optional: Connect to external DuckDB servers One-liner Docker deployment or Node 20+ dev server

Technical Details:

DuckDB compiled to WASM; query execution in-browser OPFS-backed persistence Apache 2.0 licensed Runs on Chrome 88+, Firefox 79+, Safari 14+

Use Cases:

Learning SQL without setting up databases Ad-hoc data exploration (CSV → SQL in seconds) Quick prototyping before shipping to production Privacy-conscious workflows (no data leaves your browser)

GitHub: https://github.com/ibero-data/duck-ui Live Demo: https://demo.duckui.com Quick Start: docker run -p 5522:5522 ghcr.io/ibero-data/duck-ui:latest

Would love feedback on: (1) Use cases I'm missing (2) Performance bottlenecks you hit (3) Features that would make this your default SQL scratchpad.

Hey HN! I’ve recently open-sourced Pyversity, a lightweight library for diversifying retrieval results. Most retrieval systems optimize only for relevance, which can lead to top-k results that look almost identical. Pyversity efficiently re-ranks results to balance relevance and diversity, surfacing items that remain relevant but are less redundant. This helps with improving retrieval, recommendation, and RAG pipelines without adding latency or complexity.

Main features:

- Unified API: one function (diversify) supporting several well-known strategies: MMR, MSD, DPP, and COVER (with more to come)

- Lightweight: the only dependency is NumPy, keeping the package small and easy to install

- Fast: efficient implementations for all supported strategies; diversify results in milliseconds

Re-ranking with cross-encoders is very popular right now, but also very expensive. From my experience, you can usually improve retrieval results with simpler and faster methods, such as the ones implemented in this package. This helps retrieval, recommendation, and RAG systems present richer, more informative results by ensuring each new item adds new information.

Code and docs: github.com/pringled/pyversity

Let me know if you have any feedback, or suggestions for other diversification strategies to support!

hey hn!

I (re)built this TUI tool for browsing BBC News in the terminal, it uses an RSS feed for getting headlines and previews and you can read articles too.

Try it out and let me know what you think! :)

We're excited to share EloqDoc, a new open source document database built on top of <a href="https://www.eloqdata.com/blog/2025/07/14/technology">Data Substrate</a>

EloqDoc is designed around the principle of treating object storage (like S3) as a first-class citizen for durability and cost efficiency. If you love the flexibility of MongoDB's document model but are struggling with scaling, cost, and consistency due to its coupled architecture, EloqDoc is for you. It’s built to solve MongoDB's inherent infrastructure challenges while remaining fully compatible with existing MongoDB clients and drivers.

Key Features:

1. Object Storage as First Citizen: Uses object storage for primary durability, leveraging local NVMe caching to achieve both low cost and high performance than using block-level storage (e.g. EBS).

2. Decoupled Compute & Storage: Scale your compute/QPS independently of your storage capacity, or vice-versa, without data movement.

3. True ACID Transactions: Delivers full ACID compliance with especially fast distributed transactions—consistency without compromise.

4. Native Distribution & Multi-Writer: It's a natively distributed database, eliminating complex manual sharding routers (like mongos) and supporting true Multi-Writer scalability.

Check it out: https://www.github.com/eloqdata/eloqdoc

We welcome any feedback, critique, or questions on the EloqDoc!

I recently released version 1.4 of Notepad.exe, my editor built for macOS. The goal of the app is to let you prototype ideas in Swift or Python with minimal setup - write code, hit Run, skip project scaffolding.

This release adds support for a Linux runtime/subsystem, so you can write on macOS and execute snippets in a Linux environment.

I’d love to hear any feedback or answer any questions: would a tool like this fit your workflow? What friction remains?

I forked pajecawav's better-hn repo, which turned out to be an excellent foundation to build on. While the original implementation was clean and functional, it didn't quite capture the essence of Hackernews. More importantly, it was missing some features I considered essential for a truly viable alternative.

After tinkering with it for a while, I think I've nailed it—at least for my own use case. If it works well for me, chances are others might find it useful too. So I figured, why not share it?

Pretty straightforward: no ads, no tracking, no monetization schemes and no intention to do so. Just a simple deployment on Vercel's free tier, which costs me exactly nothing. I'm not expecting millions of users (let's be realistic), but we'll see how it scales if people actually start using it.

Any feedback is welcome, or just use it.

I built Recode because I realized I was spending 8-10 hours a day on my phone pretty consistently. I tried other screen time apps but I found them too easy to bypass and end my blocks whenever I wanted to use an app.

My solution was to build an app blocker app that makes users have to scan a physical QR/barcode to take a break from their app blocks. This helped me be able to get my screen time down to just a few hours everyday since I didn't want to physically get up and go across the house to get my barcode.

Anyways, since it worked for me I felt like sharing it.

App store link: https://apps.apple.com/us/app/recode-screen-time-control/id6...

Hey HN!

Last week, Joe Barrow released CommonForms [1], a set of open models for automatically detecting form fields in PDFs.

He trained two models, FFDNet-S and FFDNet-L, on a dataset of 55k documents. You can read more about his approach in the arXiv paper [2].

As someone who's been searching for reliable models to auto-detect form fields (one of the last hard problems in PDF form filling), I was seriously impressed by the quality of these models. I wanted to give them the attention and distribution they deserve, so I created a fully browser-based implementation that handles both detection and field addition.

My implementation relies on his models and onnx runtime web + some post-processing. I plan on publishing a small browser library to encapsulate it in the coming days to make it easier to deploy anywhere (currently you'd have to fork / copy my code)

Happy to answer any questions about the browser-based implementation!

Questions about the models themselves should be directed to Joe, who I believe is also on HN [3]

[1] https://github.com/jbarrow/commonforms [2] https://arxiv.org/abs/2509.16506 [3] https://news.ycombinator.com/user?id=jbarrow

I've been working on git-stars.org and created a "Newcomer Ranking" that I think does a better job of discovering new popular projects than GitHub Trending.

While GitHub Trending often shows the same established repositories cycling through, my Newcomer Ranking specifically focuses on repositories that are both new AND gaining significant traction recently.

I'd like to share my open-source project Proxmox-GitOps, a Container Automation platform for provisioning and orchestrating Linux containers (LXC) on Proxmox VE - encapsulated as comprehensive Infrastructure as Code (IaC).

TL;DR: By encapsulating infrastructure within an extensible monorepository - recursively resolved from Git submodules at runtime - Proxmox-GitOps provides a comprehensive Infrastructure-as-Code (IaC) abstraction for an entire, automated, container-based infrastructure.

Originally, it was a personal attempt to bring industrial automation and cloud patterns to my Proxmox home server. It's designed as a platform architecture for a self-contained, bootstrappable system - a generic IaC abstraction (customize, extend, .. open standards, base package only, .. - you name it ;-)) that automates the entire infrastructure. It was initially driven by the question of what a Proxmox-based GitOps automation could look like and how it could be organized.

Core Concepts:

- Recursive Self-management: Control plane seeds itself by pushing its monorepository onto a locally bootstrapped instance, triggering a pipeline that recursively provisions the control plane onto PVE.

- Monorepository: Centralizes infrastructure as comprehensive IaC artifact (for mirroring, like the project itself on Github) using submodules for modular composition.

- Single Source of Truth: Git represents the desired infrastructure state.

- Loose coupling: Containers are decoupled from the control plane, enabling runtime replacement and independent operation.

It's a noncommercial, passion-driven project. I'm looking to collaborate with other engineers who share the excitement of building a self-contained, bootstrappable platform architecture that addresses the question: What should our home automation look like?

I'd love to hear your thoughts!

A library to implement directive pattern for native HTML without any framework, which is inspired by Vue.js.

Hey HN

I built MarkdownConverters.com — a tool that converts any file format (PDF, DOCX, PPTX, HTML, or URL) into clean, structured Markdown.

I often needed to prep documents, reports, or scraped pages for AI pipelines, documentation, or version control, but existing tools either broke formatting, lost code blocks, or produced unreadable Markdown.

So I built something that focuses on: • Accurate structure (headings, lists, tables, code, links) • Consistent Markdown output ready for LLMs or docs • Fast, browser-based conversion with privacy-friendly processing • Support for multi-format and URL inputs

It’s especially useful if you work with RAG, embeddings, or text preprocessing — Markdown becomes a universal “clean” format for structured content.

Would love feedback on: • Conversion quality — what edge cases break for you? • Formats you’d like supported next (CSV, EPUB, JSON, etc.) • API workflows — would you use it for automation?

Try it here: https://markdownconverters.com

Happy to answer any technical questions about the conversion pipeline or file parsing methods.

Hey HN,

A friend at a hardware startup mentioned how their engineering team struggles with CAD file conflicts as PDM solutions are not affordable. Multiple engineers opening the same SolidWorks part = corrupted files and lost work.

I was motivated and started building Nova. Nova is a open source file locking system, designed to support multiple CAD softwares with real time locking and live dashboard to keep design engineers in sync.

Nova is built with python and Next.js.

Get started with -

  git clone https://github.com/agg111/nova
  cd nova
  pip install -r requirements.txt
  nova start
  nova --help (for more commands)

Open http://localhost:3000 in browser

I am looking for early users to get some feedback and learn about more features or bottlenecks that mechanical design teams currently face.

Hello HN,

I built Syna to understand how modern ML frameworks like PyTorch actually work — from the ground up.

It’s a minimal, define-by-run (dynamic graph) framework inspired by DeZero, written entirely with NumPy. Unlike most libraries, Syna includes a basic reinforcement learning module right inside the same framework — no separate packages.

It’s not about speed or GPUs — it’s about clarity, simplicity, and learning the internals of machine learning. Great for students, educators, and anyone curious about what’s really happening under the hood.

GitHub: https://github.com/sql-hkr/syna

I also built a web app that visualizes how neural networks learn in real time — perfect for beginners exploring training dynamics:

GitHub: https://github.com/sql-hkr/xor Demo: https://sql-hkr.github.io/xor/

Happy hacking!

I realized that I'm more interested in the all-time top content on Hacker News than in whatever is popular right now.

To better keep track of which posts I've already read, I built a small web app that displays all posts sorted by popularity and allows me to check them off or save them for later.

Cdefer A Next-Generation Memory-Safe Preprocessor for C & C++

Bringing modern memory safety and zero-configuration builds to classic C & C++.

HN is ugly so I wanted to change that. I am quite aware that this is a common and amateur project but I couldn't find a decent HN theme online. I am not putting this on the Chrome Web Store. Do whatever you want with this.

Hey HN — I'm David, and I built Photerra to solve a problem I kept running into: planning trips meant juggling dozens of browser tabs, Google Sheets, and the same recycled "top 10" lists everyone else sees.

Photerra turns geolocated photos into map spots you can organize into trips, share with friends, and book from — all in one flow.

The core idea: photos with GPS → actual spots on a map → drag into trip days → share → book.

What makes Photerra different: • Real locations, not just POIs — Your photos have EXIF GPS data, so you're adding exact spots (that actual spot on the trail, not just “Yosemite” - no address needed) • End-to-end flow — Discover → plan → coordinate → book, without switching between 5 apps • Photo-grounded data — Community spots come from real photos, not scraped listicles, so you find more off-path places • Works for everyday wandering — Not just big trips. Save local spots and open them in Maps or Uber with one tap

Try it: iOS and Android apps are live (links in comments). I've seeded content in SF, Portland, LA, San Diego, Hawaii, Philly, Yosemite, and Mexico City.

Tech: React Native + RN-Maps on mobile; NestJS + TypeORM/MySQL + AWS on backend.

What I'd love feedback on: • Is the photo→spot→trip flow intuitive on first use? • What's missing to make this truly start-to-finish for your trips? • Any friction in auth, maps, or sharing?

Be blunt — it's helpful. Happy to answer questions!

— David (solo, first-time founder)

I built Moonfish because I have a long commute and kept wanting podcasts on niche topics that don't exist.

It's like a combination of OpenAI's deep research and Google's NotebookLM – it searches the web for sources, synthesizes the information, and creates a conversational podcast with two AI hosts.

It's very steerable. You create a show first, then add episodes to it. Set the tone at the show level ("explain like I'm a beginner or create podcast in xxx language"), then prompt individual episodes.

Episode creation would take around ~3-5m and episode length is about 15 minutes right now (I'm working on extending that hopefully to an hour :) )

Underneath it comprises of three main agents - one agent searches and gathers sources, another structures the narrative, a third writes natural dialogue. The architecture is simple but very effective and scalable with new model release

iOS app: https://apps.apple.com/us/app/moonfish-ai/id6748574770 Would love to hear your feedbacks!

EraseVideo, a macOS application designed for AI video creators who want a simple, privacy-first solution:

Drag in a video → automatically detect & remove the watermark → export a clean version — all processed locally on your Mac, no upload, no signup required.

Background & problem

As AI-video tools (e.g., Sora) became more commonplace, creators found themselves hindered by persistent watermarks: forced to upload to slow, cloud-based removers, worry about privacy, receive degraded output. We asked: “Why can’t this just happen on the Mac, offline, seamlessly?” So we built it.

What sets it apart • Fully local processing: your video never leaves your machine. • No account or login required; drag & drop simplicity. • On Apple M1 machines we measured ~1 minute for a 15-second clip—significantly faster than typical browser tools. • Smart AI model: instead of simple blur/crop, the tool intelligently reconstructs pixels around the removed watermark. • Support for Sora-generated videos today; roadmap includes Veo3, Keling, TikTok and more.

Tech & trial plan • Built on CoreML / Metal GPU acceleration for macOS. • Free tier: 2 videos per day, no login needed. Paid options: annual subscription (early-bird) or one-time lifetime license. • Upcoming roadmap: batch processing, “speed vs quality” mode, iPhone/iPad versions.

Legal & usage note

We provide the tool, but you must ensure you own the rights to any source footage you feed into the app and comply with the terms of platforms you publish to.

What we’d love to learn from YOU • In your AI-video workflow: what watermark or platform is the biggest pain? • How do you weigh local (offline) processing versus cloud solutions? Usability, speed, privacy? • On Mac the bottlenecks: large video resolution, long-form clips, GPU limits—what have you encountered? • Which feature would you want next: batch processing, multi-platform support, mobile version, etc.?

If you’d like to try it, you can download the beta here: https://erasevideo.app/ We’re happy to hear bugs, ideas, workflow feedback and help you integrate it into your toolchain.

Thanks for reading — excited to hear your thoughts and feedback.

The inspiration for this framework came from my brother, an amazing graphic designer who wanted to build WordPress themes using only his FTP-based code editor. He knows HTML and CSS really well, and some jQuery, but not modern JavaScript. In my experience, this is common for people whose jobs are tangential to frontend web development... designers, copywriters, project managers, and backend engineers.

So this is for people who don't want to deal with the mess of modern build tools. It tries to nudge people into a more modern direction: component-based architecture, JS modules, SCSS, and template routing. WP-Easy lets people like my brother build professional, modern themes without the usual barriers, just code with your favorite editor and see the results instantly.

Key features:

1. File-based routing - Define routes in router.php with Express-like syntax (/work/:slug/)

2. Single File Components - PHP templates with <template>, <style>, and <script> blocks in one file

3. Auto-loading - All files in /styles/ and /scripts/ are automatically loaded (no manual enqueueing)

4. Reusable components with use_component() and clean data helpers like use_children() or use_posts()

5. Modern workflow - SCSS support, jQuery included, SVG helpers, and WordPress best practices built-in

6. SCSS support - Variables, mixins, and media query helpers (@media #{$lt-phone})

7. Smart font loading - WebFont loader with fonts-loaded events and FOUT prevention

8 .SVG support - Easy to include and customize SVGs, use_svg('logo').

I have a basic theme example here: https://github.com/drewbaker/wp-easy-theme

Shoutout to Chengmin (https://github.com/rsm0128) for a lot of PHP help.

The big innovation is you can now do this! https://github.com/drewbaker/wp-easy?tab=readme-ov-file#sing...

Hi HN,

Since launching LLMS Central (https://llmscentral.com) a few months ago, we're now tracking hundreds of AI bot visits daily across our network. The data is fascinating.

### What We're Seeing

*Daily Bot Traffic (Across Our Network):* - 300-500+ AI bot visits per day - GPTBot (ChatGPT) dominates at ~60% of traffic - Claude, Perplexity, and Google's AI bots make up most of the rest - Peak crawling hours: 2-4 AM UTC (training runs?)

*Real Patterns Emerging:* - Technical documentation gets 5x more AI bot traffic than average content - Blog posts with code examples are crawled 3x more frequently - Sites with llms.txt files see 40% more organized crawling - Most sites have zero visibility into AI bot activity

*Surprising Findings:* 1. AI bots are WAY more active than most people realize 2. They're not just training - they're actively crawling for real-time answers 3. Different bots have different content preferences (Claude likes long-form, Perplexity loves news) 4. Traditional analytics completely miss this traffic

### Technical Details

*Stack:* - Next.js 15 (App Router) - Firebase Firestore for analytics - 2KB tracking script (async, zero perf impact) - Real-time user-agent detection + IP verification

*Bot Detection:* - User-agent parsing (GPTBot, Claude-Web, etc.) - IP range verification (OpenAI, Anthropic, Google) - Behavioral analysis (crawl patterns) - 99%+ accuracy

*Privacy:* - No PII collected - GDPR compliant - Users control data retention - Open source tracking script (coming soon)

### Why I Built This

I noticed my technical blog posts were getting cited by ChatGPT, but Google Analytics showed nothing. Turns out AI bots don't show up in traditional analytics because they're not "users" - they're crawlers.

After manually parsing server logs for weeks, I realized: 1. This should be automated 2. There should be a standard for AI bot permissions (like robots.txt) 3. Sites need visibility into which AI systems are using their content

So I built LLMS Central - both a tracking platform AND a centralized repository for llms.txt files (the proposed standard for AI bot permissions).

### Features

1. *Real-time bot tracking* - See which AI crawlers visit your site 2. *Page-level analytics* - Know which pages AI bots prefer 3. *AEO scoring* - Measure Answer Engine Optimization (like SEO, but for AI) 4. *Multi-engine preview* - See how ChatGPT vs Claude would cite your content 5. *llms.txt generator* - Like robots.txt, but for AI (proposed standard)

### Try It

*Preview tool (no signup):* https://llmscentral.com/aeo-preview

*Full tracking (free tier):* https://llmscentral.com/dashboard

### The Data Keeps Growing

What started as a personal project is now tracking hundreds of domains. Every day we see: - New AI bots appearing (just detected Meta's AI crawler last week) - Crawling patterns evolving (bots are getting smarter about what they crawl) - Sites realizing they have zero visibility into AI usage of their content

The most common reaction: "I had no idea ChatGPT was crawling my site this much."

### Questions

1. Should there be a standard for AI bot permissions (like robots.txt)? We're pushing llms.txt, but curious about alternatives. 2. How should sites monetize AI training data? Or should they? 3. Is "Answer Engine Optimization" (AEO) the future of SEO? 4. What data would YOU want to see about AI bot traffic?

Would love HN's feedback on the technical approach, privacy considerations, and what data would be most valuable to track.

InDom is a library I’ve had in mind for years. When arrow functions arrived, I imagined writing `$('.example').onClick(n => n.addClass('on'))` with clear APIs like `$1` for querySelector and `$a` for querySelectorAll. Finally, with widespread support for private class methods, I was able to build InDom around two core principles: single instance per DOM element and automatic cleanup of events and data. Core features of InDom:

- Chainable and lightweight (3.8 KB gzipped)

- Stack Agnostic: If you set an event with InDom and then remove the DOM element by any means (an older JS DOM library, a large JS framework, etc.), cleanup still happens automatically. This allows gradual adoption of InDom at any pace.

- ES2022 with Plain JavaScript, ES modules, and TypeScript distribution formats.

A few code examples:

```js // hover highlight on every #menu>div const menuDivs = $a('#menu>div'); menuDivs.onEnter(n => n.addClass('on')); // In the above, n is each InDom object menuDivs.onLeave(n => n.removeClass('on'));

  // prevent the first .example>a from navigating
  $1('.example>a').onClick((n, e) => {
      e.preventDefault();
      console.log(`navigation blocked for URL: ${n.getAttr('href')}`);
  });

  // get the first .sign-up-section
  const section = $1('.sign-up-section');
  // harvest all field values inside it
  const o = $v(section);          
  // { name: 'Alice', interests: ['JavaScript','clean code'], … }
  if (!o.interests.includes('clean code')) {
    $1('.error', section)
      .setHtml(`${o.name}, please select "clean code" to continue`)
      .addClass('on');
  }

```

I hope InDom adds to the JS ecosystem, and I’m looking forward to your feedback.

You can view InDom on GitHub: https://github.com/constcallid/indom