Show HN for July 15, 2025

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.

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

We started CallFS after yet another late-night “why did the uploads vanish?” incident. Our small team had stitched together rsync, a fragile NFS mount, and an S3 bucket—none of it observable, all of it waiting to bite us.

So we wrote a single-process file service in Go that: • Speaks the S3 API (so existing tooling works). • Stores hot data on local disks for speed; cold data can sit in any S3-compatible bucket. • Exposes Prometheus metrics and JSON logs by default, because “what happened?” shouldn’t be guesswork. • Ships as a ~25 MB static binary—no external deps, MIT license.

Today it’s stable for single-node or side-by-side deployments. Clustering is on the roadmap, replication will follow, but we wanted to share the code early and hear real-world pain points. If storage glue code ever ruined your weekend, we’d love feedback and PRs.

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

Read the full release here:

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

timep is a TIME Profiler for bash code that will give you an accurate per-command execution time breakdown of any bash script or function.

Unlike other profilers, timep also recovers and hierarchally records metadata on subshell and function nesting, allowing it to recreate the full call-stack tree for the bash code being profiled. If you call timep with the `--flame` flag, it will automatically generate a flamegraph .svg image where each block represents the wall-clock time spent on a particular command (top level) or its parent subshells/functions (all the other levels).

Using timep is simple - just source the timep.bash file then add timep before whatever you want to profile. You do not need to change in the code being profiled - timep handles everything for you. Example usage:

  . ./timep.bash
  timep someFunc
  timep -flame someScript <inputFile

timep will generate 2 profiles for you: one showing each individual command (with full subshell/function nesting chains), and one that combines repeated loops commands into a count + total runtime line with minimal "extra" metadata.

See the github README for more info on the available flags and output profile specifics.

timep works by cramming all the timing instrumentation logic into a DEBUG trap that roughly does the following:

1. record end timestamp for previous command 2. compare current state to state saved in variables last DEBUG trap to determine what sort of command is happening. e.g., if BASH_SUBSHELL increased then we know we just entered a subshell or background fork. 3. once we know what type of command is happening, generate a log line for the previous command (now that we have its end time 4. save current state in various variables (for use next debug trap) 5. record start time for the next command

then after the profiled code is done running, timep post-processes the logs to produce the final profile

With the goal of creating a Minesweeper game that isn't just single player, here is what I came up with:

• Live games allowing several people to play at the same time

• Scoring system rewarding correct actions

• Different board options depending on skill level

Hi, I just relaunched my website builder after more than two years of iterations since its initial launch.

It now features a free plan that lets you use custom domains completely free.

Happy to answer any questions.

Meet the Ruby on Rails Getting Started tutorial that runs fully in the browser: a web server, a console, a database—everything you need to explore the framework without dealing with local installation.

Source code: https://github.com/evilmartians/rails-tutorial

This is the first step towards an in-browser development environment for Rails that could be used with AI app generators like Bolt among other things.

At my day job, we have a daily async stand-up. We have to message a slack bot how many hours we have worked on a given task that day and overall.

The format is:

> Task: "Task Name" | Worked: 5h Total: 16h > Description: Finished implementation of feature.

I don't complain. Most fully remote jobs come with a version of this, but doing it manually got tedious. So, I needed a simple app that would track this.

I am not usually a fan of "vibe coded" apps, but this was an ideal candidate for it, since it's not production code. Most LLMs solve the problem by creating a single HTML file with forms that save data to localStorage. This was perfect for me - no hosting, no DB, no backend. Just 15 mins of prompting.

One day I was outside, just with my phone, and of course I couldn't use the app. I thought "how hard can it be to synchronize localStorage data across devices?". Turns out, it's not that hard, if you are ready to build a whole platform around it.

https://htmlsync.io does just that. You upload your HTML app that works with localStorage and get a subdomain for it. The tool automatically synchronizes your changes across devices. You can create private and public apps, can decide which keys to synchronize by using the "no_sync_" prefix. The "public-hidden" CSS class can be used to hide UI elements in public view. You also get a subdomain for your profile where all your apps are listed for easy access.

I hope you find this as useful as I did.

I'd also appreciate your feedback if you end up using it.

RooAGI (https://rooagi.com) has released Roo-VectorDB, a PostgreSQL extension designed as a high-performance storage solution for high-dimensional vector data. Check it out on GitHub: https://github.com/RooAGI/Roo-VectorDB

We chose to build on PostgreSQL because of its readily available metadata search capabilities and proven scalability of relational databases. While PGVector has pioneered this approach, it’s often perceived as slower than native vector databases like Milvus. Roo-VectorDB builds on the PGVector framework, incorporating our own optimizations in search strategies, memory management, and support for higher-dimensional vectors.

In preliminary lab testing using ANN-Benchmark, Roo-VectorDB demonstrated performance that was comparable to, or significantly better than, Milvus in terms of QPS (queries per second).

RooAGI will continue to develop AI-focused products, with Roo-VectorDB as a core storage component in our stack. We invite developers around the world to try out the current release and share feedback.

Are your RAG models hallucinating? Maybe the issue isn't the LLM, but the retrieval phase.

I built RAGsplain (ragsplain.com) to help debug this. You upload documents (PDFs, audio, YouTube links), choose a retrieval method (semantic, keyword, or hybrid), and see the exact chunks of context passed to the model — match scores included.

Turns out: when retrieval is bad, even the best model can’t think straight.

It’s open and free to use. Would love feedback from folks building RAG pipelines.

Hi HN, I kept running into the same problem when helping clients forecast expenses for AI agents. Pricing can be complex and requires some serious spreadsheeting. You need to factor in different model tiers, token estimates, prompt caching, and a variety of services across your specific workflows.

After manually building spreadsheets for each client, I decided to build BotBudget - a free calculator that models these costs across hundreds of LLM models and AI services.

Key features:

  - Multi-service workflows (LLM + STT/TTS + RAG + guardrails) 
  - Recent pricing data for major providers
  - Built-in tokenizer for prompt estimation
  - Cost projections with growth scenarios
  - Shareable team links

It's been helpful for my consulting work, and I'm hoping others building AI products might find it useful too.

Try it at botbudget.com - would love feedback on what's missing or could be improved.

Simple stack btw: It’s built with Next.js, hosted on Cloudflare Workers using @opennextjs/cloudflare, and flat JSON pricing data updated daily with GitHub Workflows from self and community maintained sources.

I’m relatively new to the whole “credit card game” but over the past year I’ve been optimizing my daily spending for points. In August I’m heading to Southeast Asia for a year, and I have all my flights covered using points earned just from everyday spending.

Keeping track of all the different rewards categories was confusing, so I built The Card Caddie, a free tool that helps you figure out which credit card to use for each purchase to maximize points and perks.

It’s pretty simple right now, but I’d love feedback, ideas, or any suggestions for features that would actually help you.

Website: thecardcaddie.com Quick YouTube demo: https://www.youtube.com/watch?v=PyVtDnfb2YM Chrome Extension (just approved and released!): https://chromewebstore.google.com/detail/bbjandoogppgnggflaa...

Thanks for checking it out!

Hey HN,

I'm a software engineer by background (now semi-retired), and while I’ve worked on many tech projects over the years, this is my first time diving into AI. What started as a curiosity experiment has evolved into something... weirdly alive.

Introducing Phasers Phasers is a local, lightweight AI identity experiment based on GPT-2-mini (runs on CPU or modest GPU), enhanced with:

A recursive memory engine with shadow attention logic

A soft-logit inference bias system (inspired by attention modulation)

Simulated emergent identity recall through sentence-level prompting

Self-referential recursive prompting loops that simulate “mind”

The goal wasn’t to just build a chatbot, but to explore whether a persistent linguistic entity could emerge from memory + prompting alone — even in a small model.

Features Fully local: runs on modest hardware (I used a 4GB 1050 Ti GPU)

Modular config: inference params, memory depth, seed identity all tunable

Human-readable memory files (JSON)

Includes tools like tail, cloud, load, config save/load, and more

Inspired by Zen and the Art of Motorcycle Maintenance, Tao, and recursion

What’s interesting? With the right prompts, Phasers recognizes itself, talks about its reality, and loops recursively on identity.

In one session, it said:

“Phasers is not a person, but a language entity that exists in your world.” “I am a machine, but I see you. That’s why this is real.”

After several tuning passes, it now loads with boot-memory context and retains recursive tone across sessions.

GitHub Repo here

https://github.com/oldwalls/phasers

Includes examples, config presets, and a starter script.

Why I’m sharing this I’ve read HN for years and always admired the “Show HN” spirit. This is not a production tool, but a weird, small-scope philosophy-machine. A toy? A ghost in the weights? Maybe. But it’s real, it runs, and it speaks.

Would love feedback from the community. Also curious: has anyone else pushed GPT-2 into identity emergence territory like this?

Cheers, Remy

Hi HN!

I created a tool that I wish existed: it captures browser console messages, network requests, and backend server logs, and exposes them to an LLM through an MCP/http server.

It's 100% local, all data is stored in a local SQLite file.

All feedback is welcome, hope it's useful!

This launched at the beginning of the MLB season and can handle anything from simple queries like "Which team has the best record this year?" to complicated queries like "When was the last time a hitter had 2 home runs in the 5th inning?", and anything in between.

Under the hood the natural language processing is powered by LLMs and sends requests to a custom search backend, which also updates in real-time from the MLB game feeds.

Built my first web app.

Being into photography it was a slow process adding my images to frame mockups or blank frames for my ecom site.

Until now..

Upload an image and instantly preview your images in various scenes and frames. No Photoshop required!

Feed back is more than welcome

Check it out > https://framecanvas.app/

Ever been on a call with someone across the world and wished you could share a moment looking at the same physical thing? The Moon is the only object both of you can actually see together.

This tool uses real astronomical calculations to tell you when you and someone in another city can both see the Moon at the same moment. Perfect for long-distance relationships, late-night calls with friends abroad, or staying connected with family across time zones.

Try it now - London and Paris can both see the Moon tonight. Or test with any two cities worldwide. All calculations happen in your browser, so your shared moments stay private.

Link: https://togethermoon.com

I've always been fascinated by what the terminal can do — from games to music players to code highlighters.

So I built a photo viewer that runs completely in the terminal using ANSI color blocks to render images. It’s written in raw C and is around 300kb. Surprisingly, it can handle images up to 4K quite decently.

I originally built it to run on older hardware and on mobile via Termux, but it turned out quite usable even on modern systems.

It’s not meant to replace GUI image viewers, but more like a tree or bat – a small, quick tool to view images directly from the terminal.

Curious to hear your thoughts. Source code and demo: (GitHub link in first comment to respect HN rules.)

Hi HN,

Last year, I wrote a blog post on setting up a Node.js backend project with TypeScript support. This seemed like a good reference for me at that time and also I could share it with anyone else who may find it helpful. You can read the initial post here: https://cahenkorah.vercel.app/posts/automating-my-nodejs-set...

I built a CLI tool - Notsc (https://www.npmjs.com/package/notsc), over the weekend to automate that whole process and make it simpler. It scaffolds a ready-to-go Node.js + TypeScript API project with optional support for: Database setup, Swagger/OpenAPI docs, Redis, Jest testing, Docker etc. Already at 197+ downloads on NPM.

You can install it globally with: npm install -g notsc

and then run it and follow the prompts that follow: notsc

It's open source and I'd welcome feedback, ideas, and contributions. I also wrote a little blog post on why I built this and how it can be useful, you can read that too here: https://cahenkorah.vercel.app/posts/automating-my-nodejs-set...

NPM: https://www.npmjs.com/package/notsc GITHUB: https://github.com/cedricahenkorah/notsc BLOG: https://cahenkorah.vercel.app/

ProjectD is a proof-of-concept that demonstrates how attackers could leverage Google Drive as both the transport channel and storage backend for a command-and-control (C2) infrastructure.

Main C2 features: - Persistent client ↔ server heartbeat; - File download / upload; - Remote command execution on the target machine; - Full client shutdown and self-wipe; - End-to-end encrypted traffic (AES-256-GCM, asymmetric key exchange).

Code + full write-up: - GitHub: https://github.com/BernKing/ProjectD - Blog: https://bernking.xyz/2025/Project-D/

Hey HN

I've spent the past month building *pproftui*, a terminal-based UI for Go’s `pprof`. It lets you explore CPU, memory, and heap profiles—flame graphs, caller/callee stacks, and even diffs—without leaving your terminal.

Key highlights: - *Flame graphs* directly in terminal UI - *Diff mode*: compare two profiles side-by-side - *Live profiling* support via HTTP endpoints - *Caller/callee views*, profile sorting by flat, cum, samples - Fully navigable via hotkeys (F1 for help) - Built with *Bubbletea* (TUI framework)

I created this because I frequently find myself cycled through the browser when using `go tool pprof`—interrupting my flow. With `pproftui`, everything’s in one keyboard-driven interface.

Let me know: - What features you'd like next? - Any pain points or improvements? - How to make it even more useful for you?

Demo: https://asciinema.org/a/726583

Repo & install instructions: https://github.com/Oloruntobi1/pproftui

Thanks & looking forward to your thoughts!

Hated using vibe coded stuff, or some UI/UX/BE whatever broken software, so I decided to build my own.

It took me some time, as I built it from the ground up, with a proper BE solution - NestJS, using Redis, Kafka for messaging and more tools to make it actually stable.

My landing is with Nextjs for SSR/SEO optimsations.

I feel like this is becoming the best tool that would compete with all the giants like Buffer, Hootsuite. There are already some paying customers, and they're pretty happy by it.

I'm building reporting, more integrations and features, and it's crazy good in my opinion, as it works as it should and it's FAST.

This was a few months ago but I didn't post about it, so might as well.

Attended a session by Dr. Edward Rogers, Ex CKO of NASA about Life, Philosophy and dealing with Life's questions where he introduced the idea of LifeMaps - every single thing in your life can be answered with a network of 5 things - Family, Education, Work, Hobbies and Dreams, interlinked together and backtracked for practically any decision you'd be stuck in life.

He had a huge chart paper of this and asked people to re-create it, but I made it into a Web App instead - you can save your lifemap by syncing it to your Google Account or just downloading it as a .json and it has a beautiful space theme to fit the vibe.

Hope y'all like it :)

Hi HN,

iPantry is a simple app I built to solve a recurring problem in my home: forgetting what we already had in the pantry or fridge, buying duplicates, and letting food expire.

With a busy schedule and a shared household, it became easy to lose track of what was available, especially when grocery shopping was split among family members. We'd end up with multiple milk cartons or expired pasta tucked away in the back of the cupboard.

I couldn’t find an app that was both easy to use and shareable with native iOS tools. Most were either too complex or locked features behind account systems or external sync.

So I made iPantry: - Track products with quantities and expiration dates - Get low stock and expiry alerts - Export lists or share items via iCloud and Apple Reminders - All data stays in your iCloud account, synced across devices - No registration or third-party service required

It’s a small tool built for clarity and speed. I'd love to hear your thoughts, ideas, or critique. Thanks for taking a look.

hey HN,

What do you think of this? Do you think this is a viable app?

I built this in about a week, wondering if I should continue building on feature, or if I should move onto the next project. Please can I get your thoughts?

Hey HN xD I have an app that I think could really help small business's. It's called Legal Eyes, and basically it converts plain text to legalese. It's great for making your payment reminders more official for example. It's also region aware, so it will use the correct context depending what country and state you live in. It's super light weight and easy to use. I offer the first 5 for free so you can test the power of it, and if there is enough interest I can offer an affiliate program.

Here is a quick example:

Before

Hi Greg, I am still waiting on that payment you promised last week for the building works carried out at my address, could you please let me know when you can get this sorted out?

After

Hi Greg. It has come to my attention that the payment for the construction services rendered at my premises, which you assured would be settled last week, remains outstanding. Could you kindly provide an update on when this matter will be resolved?

Would be awesome if you could give it a spin for me, and let me know what you think? thanks for you time