Show stories

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 folks,

Here's a quick tool for anyone who wants a way to simplify error messages with AI without needing to switch to a fully agentic terminal solution. Simply add hank before compiling/running your program to get a clear, readable explanation of any errors that occur.

You can think of this as just another system utility like grep, ls or echo that is at your fingertips for debugging a program. It uses local models as well so your code outputs don't go into online LLM services.

Excited to see what gets thrown back, hope it helps someone. Feel free to add onto it as its pretty raw at the moment.

I made it by 120% viba coding. enjoy! free and no ads.

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!

hi!

video[0]

The idea is you could carry around this hardware and ask it any questions about the conference. Who is speaking, what are they speaking about etc... it connects via WebRTC to a LLM and you get a bunch of info.

This is a workshop/demo project I did for a conference. When I was talking to the organizers I mentioned that I enjoy doing hardware + WebRTC projects. They thought that was cool and so we ran with it.

I have been doing these ESP32 + voice ai projects for a bit now. Started with an embedded sdk for livekit[1] that jul 2024 and been noodling with it since then. This code then found its way into pipecat/livekit etc...

So I hope it inspires you to go build with hardware and webrtc. It's a REALLY fun space right now. Lots of different cheap microcontrollers and even more cool projects.

[0] https://www.youtube.com/watch?v=gPuNpaL9ig8

[1] https://github.com/Sean-Der/embedded-sdk

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

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

Whassup?,

A couple years ago, I started a project for easily authoring GUIs with Ruby. The project is named Hokusai. It features the ability to compose reactive UI components with events and props, and uses a unique-ish template language.

More information on Hokusai can be found here: https://hokusai.skinnyjames.net/

Since then I've worked on Hokusai Native (https://github.com/skinnyjames/hokusai-native-builder/), which compiles a GraalVM native image / TruffleRuby version of Hokusai that can run / interpret these lil' gui apps. It's quite bloated though, as it has to ship all of truffle ruby + native image and supporting libs.

Recently, I applied for a grant to develop a more portable version of this library using MRuby, and got pretty far while waiting for the results. It is named Hokusai Pocket and I consider it to be the final form/approach of this project.

I wrote a builder in crystal-lang that embeds the entire Hokusai ruby code as MRuby bytecode, as well as the supporting C code. It can scaffold new projects by building tree-sitter/mruby/raylib, and outputs a binary from a source ruby file.

It produce pretty small binaries (~3mb for MacOS) and uses raylib as the rendering engine.

For an gif and example of a Hokusai Pocket demo please direct your mouse clicks to this gist: https://gist.github.com/skinnyjames/b510185c6bd83fd4e1a41324...

I'd love to hear how this project plays for people. Still working on building for different targets, but android and web should be possible. The project is still undergoing active development, but any help is appreciated. The license is MIT.

There also is a discord channel if you want to get help / chat / collaborate: https://discord.gg/SexXSEw8Hh

       _    (^)
      (_\   |_|
       \_\  |_|
       _\_\,/_|
      (`\(_|`\|
     (`\,)  \ \
      \,)   | | 
        \__(__|

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.

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.

Jotite is a lightweight and user-friendly note-taking application that allows users to quickly create and organize notes, with built-in support for Markdown formatting and basic text editing features.

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!

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)

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

A project inspired by https://www.theshapeofmovies.com/ Submit a YouTube video and get a nice color analysis! 60 seconds maximum because I have a small server, but I hope you'll like it. I use a Python backend with yt-dlp, and ffmpeg + scipy for the frame processing.

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!

ServiceRadar is an open-source platform for distributed, secure network management and observability, scaling to 100k+ devices. Born from frustration with complex traditional NMS tools like Zabbix, it bridges legacy (SNMP/syslog) and modern (gNMI, OTLP) protocols for cloud-native environments.

We built ServiceRadar to simplify monitoring hybrid telecom networks, evolving it into a Kubernetes-native solution with Helm and Docker support. It uses mTLS with SPIFFE/SPIRE, NATS JetStream for event streaming (90M+ EPS), and SRQL for intuitive queries. Integrated with OpenTelemetry, Prometheus, and CloudEvents, it fills the network visibility gap in CNCF’s application-focused observability stack.

We’re seeking early adopters to try our demo or deploy locally—no sign-up needed. Feedback on usability or contributions for new protocols would be awesome.

Quick Start: helm install serviceradar carverauto/serviceradar or docker compose up -d

GitHub: https://github.com/carverauto/serviceradar (please star!)

Docs: https://docs.serviceradar.cloud

Join our Discord or use GitHub Issues to share thoughts.

Hi HN! I'm Nick from Inkeep. We built an agent builder with true 2-way sync between code and a drag-and-drop visual editor, so devs and non-devs can collaborate on the same agents. Here’s a demo video: https://go.inkeep.com/video.

As a developer, the flow is: 1) Build AI Chat Assistants or AI Workflows with the TypeScript SDK 2) Run `inkeep push` from your CLI to publish 3)Edit agents in the visual builder (or hand off to non-technical teams) 4) Run `inkeep pull to edit in code again.

We built this because we wanted the accessibility of no-code workflow builders (n8n, Zapier), but the flexibility and devex of code-based agent frameworks (LangGraph, Mastra). We also wanted first-class support for chat assistants with interactive UIs, not just workflows. OpenAI got close, but you can only do a one-time export from visual builder to code and there’s vendor lock-in.

How I've used it: I bootstrapped a few agents for our marketing and sales teams, then was able to hand off so they can maintain and create their own agents. This has enabled us to adopt agents across technical and non-technical roles in our company on a single platform.

To try it, here’s the quickstart: https://go.inkeep.com/quickstart.

We leaned on open protocols to make it easy to use agents anywhere: An MCP endpoint, so agents can be used from Cursor/Claude/ChatGPT A Chat UI library with interactive elements you can customize in React An API endpoint compatible with the Vercel AI SDK `useChat` hook Support for Agent2Agent (A2A) so they work with other agent ecosystems

We made some practical templates like a customer_support, deep_research, and docs_assistant. Deployment is easy with Vercel/Docker with a fair-code license and there's a traces UI and OTEL logs for observability.

Under the hood, we went all-in on a multi-agent architecture. Agents are made up of LLMs, MCPs, and agent-to-agent relationships. We’ve found this approach to be easier to maintain and more flexible than traditional “if/else” approaches for complex workflows.

The interoperability works because the SDK and visual builder share a common underlying representation, and the Inkeep CLI bridges it with a mix of LLMs and TypeScript syntactic sugar. Details in our docs: https://docs.inkeep.com.

We’re open to ideas and contributions! And would love to hear about your experience building agents - what works, hasn’t worked, what’s promising?

Hey HN, we just shipped a browser with an inbuilt MCP server!

We're a YC startup (S24) building BrowserOS — an open‑source Chromium fork. We're a privacy‑first alternative to the new wave of AI browsers like Dia, Perplexity Comet. Since launching ~3 months ago, the #1 request has been to expose our browser as an MCP server.

-- Google beat us to launch with chrome-devtools-mcp (solid product btw), which lets you build/debug web apps by connecting Chrome to coding assistants. But we wanted to take this a step further: we packaged the MCP server directly into our browser binary. That gives three advantages:

1. MCP server setup is super simple — no npx install, no starting Chrome with CDP flags, you just download the BrowserOS binary.

2. with our browser's inbuilt MCP server, AI agents can interact using your logged‑in sessions (unlike chrome-devtools-mcp which starts a fresh headless instance each time)

3. our MCP server also exposes new APIs from Chromium's C++ core to click, type, and draw bounding boxes on a webpage. Our APIs are also not CDP-based (Chrome Debug Protocol) and have robust anti-bot detection.

-- Few example use cases for BrowserOS-mcp are:

a) *Frontend development with Claude Code*: instead of screenshot‑pasting, claude-code gets WYSIWYG access. It can write code, take a screenshot, check console logs, and fix issues in one agentic sweep. Since it has your sessions, it can do QA stuff like "test the auth flow with my Google Sign‑In." Here's a video of claude-code using browserOS to improve the css styling with back-and-forth checking: https://youtu.be/vcSxzIIkg_0

b) *Use as an agentic browser:* You can install BrowserOS-mcp in claude-code or Claude Desktop and do things like form-filling, extraction, multi-step agentic tasks, etc. It honestly works better than Perplexity Comet! Here's a video of claude-code opening top 5 hacker news posts and summarizing: https://youtu.be/rPFx_Btajj0

-- *How we packaged MCP server inside Chromium binary*: We package the server as a Bun binary and expose MCP tools over HTTP instead of stdio (to support multiple sessions). And we have a BrowserOS controller installed as an extension at the application layer which the MCP server connects to over WebSocket to control the browser. Here's a rough architecture diagram: https://dub.sh/browseros-mcp-diag

-- *How to install and use it:* We put together a short guide here: https://git.new/browseros-mcp

Our vision is to reimagine the browser as an operating system for AI agents, and packaging an MCP server directly into it is a big unlock for that!

I'll be hanging around all day, would love to get your feedback and answer any questions!

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!

The article discusses the 42Futures firm, a technology company that provides AI-driven solutions for businesses. It highlights the firm's focus on developing innovative products and services to help clients optimize their operations and decision-making processes.

The article describes the Waverider project, an open-source hardware and software platform for capturing and analyzing water wave data. It provides a tool for researchers and enthusiasts to study wave dynamics and patterns in a cost-effective and accessible manner.

We're excited to share EloqDoc, a new open source document database built on top of Data Substrate. 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 lower cost and higher 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!

This article provides a boilerplate for setting up a Jekyll-based website for publishing a book, including features such as table of contents, chapter navigation, and responsive design.

The AI File Sorter is a tool that uses machine learning to automatically organize files into folders based on their content. It supports various file types and can be customized to fit different use cases.

I started working on Halloy back in 2022, with the goal of giving something back to the community I’ve been a part of for the past two decades. I wanted to create a modern, multi-platform IRC client written in Rust.

Three years later, I’ve made new friends who have become core contributors, and there are now over 200 people idling in our #halloy channel on Libera.

My hope is that this client will outlive me and that IRC will live on.

We have another election coming up at the end of this month here in the Netherlands, and how we use our limited land is a hotly debated topic.

Last year also I shared this animated hexagonal map of Dutch land use. I've now expanded this to include several more European countries, so you can see what makes Dutch land use so special - or not.

If you want to help add more countries, I'd appreciate PRs on GitHub. The map rendering is already there, it only requires land use data which can be found in the SQLite database (at least for EU countries).

Github: https://github.com/vnglst/onsland Previous HN: https://news.ycombinator.com/item?id=40599763