Show stories

Hey HN, I'm the creator of OrioleDB, an extension for PostgreSQL that serves as a drop-in replacement for the default Heap storage engine. It is designed to address scalability bottlenecks in PostgreSQL's buffer manager and reduce the WAL, enabling better utilization of modern multi-core CPUs and high‑performance storage systems.

We are getting closer to GA. This release includes:

- An index bridge to support all indexes that Heap supports

- Support for rewinding recent changes in the database.

- Tablespaces support

- Fillfactor support

- An orioledb_tree_stat() function for space utilization statistics

- Support for tables with more than 32 columns.

We also show several performance improvements using the TPC-C benchmarks. Overall, OrioleDB is much faster than Heap, also outperforming other Postgres providers.

We would love more people testing OrioleDB. The fastest way to do that is to use the docker image provided:

    docker run -d --name orioledb -p 5432:5432 orioledb/orioledb

https://www.orioledb.com/blog/orioledb-beta12-benchmarks

Hi HN, the last half year I spent some of my spare time on learning Vulkan (mainly the compute part) and applied it directly in developing a gaussian splatting renderer. I am not sure where I will go with this, but I thought some of you might find it interesting and/or have suggestions on how to proceed.

Ultimately, I want to Klartraum to be an extensive neural network and rendering inference engine (no training, backprop, autograd) running on embedded devices and VR headsets with high performance. My major obstacle right now is that writing GLSL compute kernels is tedious compared to CUDA ...

What do you think should be added so the library would be of use for others?

We launched marimo [1], an open-source reactive Python notebook, last year on HackerNews. Today, the most popular recent feature request in Google Colab’s issue tracker asks for marimo support in Colab [2].

Rather than try to convince Google to replace their notebook with marimo, we decided to just build our own cloud-hosted notebook service instead. We're calling this molab (mo for marimo), and we're launching it today.

You can try it at https://molab.marimo.io

Some features:

- Persistent storage

- Link sharing (notebooks are public but undiscoverable, like secret GitHub Gists)

- Download notebooks to your machine, reuse them as Python scripts or apps

- Upload local notebooks to the cloud from our CLI (coming soon)

- Real-time collaboration (coming soon)

- Configure computational resources to obtain more CPU or GPU (coming soon)

marimo is a modern notebook for modern data workflows; we also built molab on a modern tech stack:

- Notebook dependencies are managed by uv, enabling lighting-fast package installation (thanks to uv’s cache and more generally its performant implementation). uv makes it easy to run molab notebooks locally, too: uvx marimo edit <notebook-url> brings the notebook down to your machine.

- Persistent storage is powered by R2, Cloudflare’s zero-egress object store.

- We use Pydantic logfire to monitor our deployment.

- While our implementation is agnostic to the compute backend (stay tuned!), we’re currently running on Modal for fast startups (not to mention a slick developer experience). Modal sandboxes make it easy for us define containers at runtime, containing notebook code and their dependencies. (Shout out to Eric Zhang from Modal for helping us get started.)

molab is free to use, as long as usage is reasonable. Our goal is to make is as easy as possible for our community to use marimo notebooks.

Finally, learn more at our announcement blog: https://marimo.io/blog/announcing-molab

If this interests you, please give molab a shot and please share feedback — here or on Discord (https://marimo.io/discord).

P.S. This is not our commercial product, this is really just for our community.

[1] https://github.com/marimo-team/marimo [2] https://github.com/googlecolab/colabtools/issues?q=is%3Aissu...

Mochi Invaders, a retro-style arcade game, has been released on the App Store. The game features a classic space shooter gameplay with mochi-themed enemies and power-ups, offering a nostalgic and addictive gaming experience on mobile devices.

Ketu is an open-source, self-hosted platform for managing and automating various aspects of a developer's workflow, including project management, code review, and issue tracking. The platform aims to provide a comprehensive solution for teams to streamline their development processes and increase productivity.

I've been working on librari.io for the past several months and just launched the beta version.

The Problem: I have 500+ books across multiple rooms in my house and was desperately looking for an app to manage them properly. Most library management apps are either too basic or designed for institutional libraries with rigid workflows that don't fit personal use.

What I Built:

- Multiple libraries: manage collections in different locations

- Location tracking - remember exactly which shelf each book is on

- Loan management - track books you've lent to friends

- Custom fields & tags - store any additional book info the way YOU think about them

- Reading progress tracking - dates, duration, personal ratings

- Modern UI/UX - clean & actually enjoyable to use

Current Status:

- Beta version live

- Working on improving the responsiveness of the app and addressing initial user feedback

Would love feedback! Especially curious about:

- What features would make YOU actually use a library management app?

- UI/UX feedback always welcome

- Any book collectors here who'd be interested in beta testing?

Looking forward to your thoughts! Thank you in advance.

I wrote a tutorial on how to create Bash scripts, where the command line interface runs entirely in the browser using v86 (https://github.com/copy/v86), and the code editor uses Monaco.

Hey everyone!

I've been a Splitwise user for a long time (sometimes paying, sometimes not), and have been rather frustrated at their new-ish policy of only allowing N (small) expenses to be submitted per day. And I was curious to write some Rust and thought the expense simplification algorithm would be fun to implement, so I built this.

Thought others might find it fun or useful! It's dead simple to self host if you want to try it out :)

Plutofilter is an open-source image filtering library that applies various artistic filters to images, providing a variety of creative effects and stylizations.

Hello HN,

I'm Ghita, co-founder of ZeroEntropy (YC W25). We build high accuracy search infrastructure for RAG and AI Agents.

We just released two new state-of-the-art rerankers zerank-1, and zerank-1-small. One of them is fully open-source under Apache 2.0.

We trained those models using a novel Elo score inspired pipeline which we describe in detail in the blog attached. In a nutshell, here is an outline of the training steps: * Collect soft preferences between pairs of documents using an ensemble of LLMs. * Fit an ELO-style rating system (Bradley-Terry) to turn pairwise comparisons into absolute per-document scores. * Normalize relevance scores across queries using a bias correction step, modeled using cross-query comparisons and solved with MLE.

You can try the models either through our API (https://docs.zeroentropy.dev/models), or via HuggingFace (https://huggingface.co/zeroentropy/zerank-1-small).

We would love this community's feedback on the models, and the training approach. A full technical report is also going to be released soon.

Thank you!

This article explores the creation and design process behind 'Shoggoth Mini', a compact and customizable MIDI controller inspired by the Lovecraftian monster Shoggoth. The author discusses the challenges of miniaturizing the device while maintaining its functionality and unique aesthetics.

What it is Symvol turns any tech doc into AI-narrated video in ~1 min. Every code block stays live-viewers can click-to-copy and run snippets while they watch.

Why we built it We began as a generic “text → video lesson” tool. Early testers asked for coding support, so we added a code-aware pipeline. This is the first public launch of that version.

Try it Drag-drop a PDF at symvol.io (free to try) OR install our Chrome extension to run Symvol on any web page

Looking for feedback on 1) Narration accuracy 2) Clarity of visuals 3) Usefulness of the live copy-code feature

We’ll be around all day - happy to answer questions or dive deeper in the comments!

I had an idea for a game that fused my favorite time-waster games, Wordle and Sudoku, so I had a go at making my own daily number puzzle: Numbl

Basically, you need to fill the rows and columns with a unique set of digits 1-9 where each row or column has a constraint (sum, all odd, all even, range, etc.). It generates a puzzle each day, but you can try a random puzzle by pressing "New Game".

At work I'm easing more into using AI in my workflow so I used this as a testbed for incorporating it more (i.e. rapid prototyping and validation) without outsourcing core design or compromising engineering thinking.

I ended up with a finished product that I actually want to keep maintaining so I thought I'd share and invite any constructive advice or criticism the community would have!

Local LLMs now supported. Works on Windows, macOS, Linux.

BenchStreet is an open-source benchmarking tool that allows users to compare the performance of different hardware configurations across various workloads. The tool provides a standardized testing framework and a database of results to help users make informed decisions when selecting or upgrading hardware.

I'm in my 4th year living in Denmark as an expat, and I finally decided it’s time to properly learn Danish. I do have a Danish girlfriend, after all. One way I’ve been practicing is by trying to text only in Danish, but I often find myself stuck. I start my message in Danish, then hit a wall because I don’t know a word or how to fit something naturally into the sentence.

Especially in those cases, I used to give up and translate the entire message from English, which kind of defeats the purpose and interrupts the learning process.

So I started prompting GPT. I’d write my message with wildcards or notes for the parts I didn’t know, and it would return a corrected version. That worked well, but reusing the prompt each time became tedious.

So I built a wrapper around it.

Now I can type in the target language, mark unclear parts with curly braces {like this}, and get an instant corrected version with explanations. I also added a history feature so I can review what I got wrong, and I plan to build more on that soon (eg. summary of areas or words to review).

This app is for language learners who want to practice writing without feeling insecure about mistakes or breaking their flow by switching to a translator.

I hope you find it useful!

Hey HN! I got nerd-sniped by Bloom Filters this weekend, specifically for searching datasets with high "cardinality" (number of unique items).

They're an _amazing_ data structure that, at a fixed size, tracks potential set membership. That means unlike normal b-tree indexes, they don't grow with the number of unique items in the dataset.

This makes them great for "needle in a haystack" search (logs, document) as implementations like VictoriaMetrics and Bing's BitFunnel show. I've used them in the past, but they've never been center-stage in my projects.

I wanted high cardinality keyword search for ANOTHER project... and, well, down the yak-shaving rabbit hole we go!

BloomSearch brings this into an extensible Go package:

- Very memory efficient via bloom filters and streaming row scans

- DataStore and MetaStore interfaces for any backend (can be same or separate)

- Hierarchical pruning via partitions, minmax indexes, and of course bloom filters

- Search by field, token, or field:token with complex combinators

- Disaggregated storage and compute for unbound ingest and query throughput

And of course, you know I had to make a custom file format ^-^ (FILE_FORMAT.MD)

BloomSearch is optimized for massive concurrency, arbitrary cardinality and dataset size, and super low memory usage. There's still a lot on the table too in terms of size and performance optimizations, but I'm already super pleased with it. With distributed query processing I'm targeting >100B rows/s over large datasets.

I'm also excited to replace our big logging bill ~$0.003/GB for log storage with infinite retention and guilt-free querying :P

MockFedCM is a free FedCM Relying Party (RP) and Identity Provider (IdP) for testing FedCM integrations. Simulate real-world authentication flows, debug your implementation, and validate user experiences—all without needing a production IdP or RP.

We wrote our inference engine on Rust, it is faster than llama cpp in all of the use cases. Your feedback is very welcomed. Written from scratch with idea that you can add support of any kernel and platform.

Couldn't find a reliable, free place to share & rate AI prompts so I thought I'd take a stab at it

Already has 500+ prompts generated by AI using the latest model prompting guidelines

5 different supported prompt types: full prompt, enhancement, template, system, chain

20+ categories: coding, writing, marketing, business, creative, etc.

Every prompt gets evaluated automatically by multiple AI models (Claude 3 + GPT-4 Mini, more to come)

Then humans can rate and there is an overall score that takes both AI & humans into account

AI eval prompt here: https://www.josh.ing/ratemyprompt/evaluation-prompt

I'm still quite the noob when it comes to AI stuff so I'd love feedback about RateMyPrompt and ways that it could be improved

I've always been dissatisfied that simple Mandelbrot explorers proport themselves as a Fractal Graphing Calculator. In summer break between semesters, I started making a real graphing calculator, parsing LaTeX to WebGL to let you graph most any combination of z and c.

Fun ones to try include - sin(z^2+c) - c^z - z^{1.7}+c

Also supports animation, just enter any other letter and turn it into a variable. Supports Mandelbrot or Julia Set style calculation.

Use with a graphics card or integrated graphics

I authored and developed an interactive children's book about entrepreneurship and money management. The journey started with Twinery, the open-source tool for making interactive fiction, discovered right here on HN. The tool kindled memories of reading CYOA style books when I was a kid, and I thought the format would be awesome for writing a story my kids could follow along, incorporating play money to learn about transactions as they occurred in the story.

Twinery is a fantastic tool, and I used it to layout the story map. I really wanted to write the content of the story in Emacs and Org Mode however. Thankfully, Twinery provided the ability to write custom Story Formats that defined how a story was exported. I wrote a Story Format called Twiorg that would export the Twinery file to an Org file and then a Org export backend (ox-twee) to do the reverse. With these tools, I could go back and forth between Emacs and Twinery for authoring the story.

The project snowballed and I ended up with the book in digital and physical book formats. The Web Book is created using another Org export backend.

Ten Dollar Adventure: https://tendollaradventure.com

Sample the Web Book (one complete storyline/adventure): https://tendollaradventure.com/sample/

I couldn't muster the effort to write a special org export backend for the physical books unfortunately and used a commercial editor to format these.

Twiorg: https://github.com/danishec/twiorg

ox-twee: https://github.com/danishec/ox-twee

Previous HN post on writing the transaction logic using an LLM in Emacs: https://blog.tendollaradventure.com/automating-story-logic-w...

Twinery 2: <https://twinery.org/> and discussion on HN: https://news.ycombinator.com/item?id=32788965

Hey HN!

This is Adil, Salman and Jose and and we’re behind archgw [1]. An intelligent proxy server designed as an edge and AI gateway for agents - one that natively know how to handle prompts, not just network traffic. We’ve made several sweeping changes so sharing the project again.

A bit of background on why we’ve built this project. Building AI agent demos is easy, but to create something production-ready there is a lot of repeat low-level plumbing work that everyone is doing. You’re applying guardrails to make sure unsafe or off-topic requests don’t get through. You’re clarifying vague input so agents don’t make mistakes. You’re routing prompts to the right expert agent based on context or task type. You’re writing integration code to quickly and safely add support for new LLMs. And every time a new framework hits the market or is updated, you’re validating or re-implementing that same logic—again and again.

Putting all the low-level plumbing code in a framework gets messy to manage, harder to update and scale. Low-level work isn't business logic. That’s why we built archgw - an intelligent proxy server that handles prompts during ingress and egress and offers several related capabilities from a single software service. It lives outside your app runtime, so you can keep your business logic clean and focus on what matters. Think of it like a service mesh, but for AI agents.

Prior to building archgw, the team spent time building Envoy [2] at Lyft, API Gateway at AWS, specialized NLP models at Microsoft Research and worked on safety at Meta. archgw was born out of the belief that rule-based, single-purpose tools that handle the work around resiliency, processing and routing prompts should move into a dedicated infrastructure layer for agents, but built on the battle-tested foundational of Envoy Proxy.

The intelligence in archgw comes from our fast Task-specific LLMs [3] that can handle things like agent routing and hand off, guardrails and preference-based intelligent LLM calling. Here are some additional details about the open source project. archgw is written in rust, and the request path has three main parts:

* Listener subsystem which handles downstream (ingress) and upstream (egress) request processing. * Prompt handler subsystem. This is where archgw makes decisions on the safety of the incoming request via its prompt_guard hooks and identifies where to forward the conversation to via its prompt_target primitive. * Model serving subsystem is the interface that hosts all the lightweight LLMs engineered in archgw and offers a framework for things like hallucination detection of our these models

We loved building this open source project, and our belief is that this infra primitive would help developers build faster, safer and more personalized agents without all the manual prompt engineering and systems integration work needed to get there. We hope to invite other developers to use and improve Arch. Please give it a shot and leave feedback here, or at our discord channel [4] Also here is a quick demo of the project in action [5]. You can check out our public docs here at [6]. Our models are also available here [7].

[1] https://github.com/katanemo/archgw [2] https://www.envoyproxy.io/ [3] https://huggingface.co/collections/katanemo/arch-function-66... [4] https://discord.com/channels/1292630766827737088/12926307682... [5] https://www.youtube.com/watch?v=I4Lbhr-NNXk [6] https://docs.archgw.com/ [7] https://huggingface.co/katanemo

This is an open‑source Model Context Protocol (MCP) server that gives any LLM a sense of the passage of time.

Most MCP demos wire LLMs to external data stores. That’s useful, but MCP is also a chance to give models perception — extra senses beyond the prompt text.

Six functions (`current_datetime`, `time_difference`, `timestamp_context`, etc.) give Claude/GPT real temporal awareness: It can spot pauses, reason about rhythms, and even label a chat’s “three‑act structure”. Runs locally in <60 s (Python) or via a hosted demo.

If time works, what else could we surface? - Location / movement (GPS, speed, “I’m on a train”) - Weather (rainy evening vs clear morning) - Device state (battery low, poor bandwidth) - Ambient modality (user is dictating on mobile vs typing at desk) - Calendar context (meeting starts in 5 min) - Biometric cues (heart‑rate spikes while coding)

Curious what other signals people think would unlock better collaboration.

Full back story: https://medium.com/@jeremie.lumbroso/teaching-ai-the-signifi...

Happy to discuss MCP patterns, tool discovery, or future “senses”. Feedback and PRs welcome!

Today marks ten years, 3653 consecutive days, of running at least one mile every day under the USRSA rules [1]. To celebrate, I built an interactive dashboard that turns a decade of GPX files into charts you can explore.

Running has truly changed my life: I've made lifelong friends, explored beautiful places, and more importantly invested into my own health and fitness, which I'm starting to see the positive benefits as I get older.

The stack is pretty simple: a NextJS app, with a Postgres database to keep all my running data, and all the stats are pre-computed and cached in Redis, so I effectively only hit the database once a day when a new run is ingested. On the fronted, I toyed with the idea of using D3 or pre-existing data viz libraries, but ended up rolling my own using SVGs directly, it gave me more control on the visualizations.

I used the Strava bulk export to pre-populate the database, and I'm using their webhook API to do incremental updates. I have to tap into OpenWeatherMap and OpenCageDate to enrich the running data a little bit.

Happy to answer anything about the stack, data pipeline, or how I stayed motivated for 10 years!

[1] https://www.runeveryday.com Run Streak Association rules: ≥ 1 mile per day

I built DataRamen, a local-first SQL explorer that helps you get the data you need fast, without writing repetitive queries every time.

You run it locally from the CLI (no cloud version yet), connect your databases, and you're ready to go. The goal is to let you explore and query data like you would in a spreadsheet: intuitive, fast, and without friction.

Key features:

- Automatic joins & related data navigation: Right-click any row to instantly see related records in other tables (based on foreign keys or references).

- Keyboard-driven UI: Hit N to jump to a table, F to filter, and so on, it’s optimized for speed so you can go from question to insight in seconds (this point is still in progress, I find it confortable, but the goal is to make it even better).

- Named tabs with saved queries: Keep multiple tabs open with different queries, useful for comparing or cross-checking data. Tabs are saved, so you can get back to your queries at any time.

- Instant edit & insert: One click to edit or add rows, no need to write full queries.

- Multi-DB support: Connect several databases and search across all of them.

- Search across all columns: Find what you need even if you don't know the exact column.

If you've ever felt slowed down by writing the same SQL over and over just to explore your data, this might save you a ton of time. I’d love feedback or suggestions, especially from folks who wrangle data often.

Find more information on https://dataramen.xyz

PS. don't be harsh on the logo, I did my best :)

For folks working on Graph RAG and trying to get LLMs to generate Cypher queries, I ran some experiments on the LDBC dataset and wrote a blog post about it (code is available in the link shown at the end of the post). I've been trying to answer a burning question of mine that I've had for a while now: when doing Text2Cypher, are LLMs better at interpreting graph schemas in JSON, XML or YAML? (Spoiler alert, the format barely matters, it's all to do with context engineering and retaining only the relevant parts of the graph schema in the prompt). Results on the latest LLMs are really good!

The post also contains some other tips on graph schema design: I think we're in an age now where we need to design graph schema for both LLMs and humans. If you're working on Text2Cypher in any way, hope some of these ideas and experiments are useful!