Show stories

There are lots of glassmorphism generators out there, but I wanted to push the effect further! This project is the result of months of experimenting with CSS property layering and battling browser quirks.

Cross-browser compatibility is actually the reason I rely on ::before and ::after pseudo-elements to build up the effect. Move the color/opacity to the main element, and you’ll get weird color bleed on the corners in Chrome. Move the texture, and it muddles the bevel’s specular highlight. Move the bevel, and it gets blurred out by the backdrop-filter. And so on!

Layers include: * Adjustable blur, brightness, and saturation (backdrop-filter) * Subtle translucent texture * Faux 3D bevel (using box-shadows, not an outline)

Glassmorphism is rather heavy on resources, so it’s best used as an accent and avoided on wide desktop elements. Should be compatible with recent versions of Chrome, Safari, and Firefox (desktop and mobile). If you spot bugs or rendering glitches, I’d love to know!

Side note: this is an early preview of a framework-agnostic glass SCSS/component library I’m building.

Recently I'm working on CopyUI which is an extension to copy UI element from websites and export html(or jsx) and css(or tailwind). I'm building this tool in order to create better landing pages because I'm really not good at layout and colors. So I hope to learn from others' design and innovate later, not to simply replicate.

I have some friends who were laid off and are on the job hunt. We were all quite surprised to learn that LinkedIn does not have a "view jobs only at companies where I have connections", so I built https://jobsbyreferral.com/

It's powered by https://rapidapi.com/letscrape-6bRBa3QguO5/api/jsearch, which is a little pricey, so I'm trying to decide whether to put more effort into the project (I'd have to charge _something_ to offset the costs).

This is a fun repl for running arbitrary assembly commands, right now it supports x86, X86_64, arm, aarch64, but there's not a big reason that I can't add support for other qemu/capstone/unicorn/ keystone supported architectures, just have to do it

I’ve built *Issue Duration Labeler*, a GitHub Action that automatically adds *color-coded duration labels* to every issue in a repo:

Default label thresholds: Green – ≤ 7 days (configurable) Orange – ≤ 30 days Red – > 30 days

For open issues we compute “age” (creation → now). You can adjust the day thresholds and label colors in the workflow file, and choose whether labels update daily or only when they cross the next threshold.

*Why?* I often lost track of how long tickets had been lingering, especially in older projects. A quick glance at the issue list or github project now tells us what’s fresh, what’s getting stale, and what’s officially ancient. It’s also handy for post-mortems: sort by red labels to see which bugs took the longest to close.

*Link* https://github.com/marketplace/actions/issue-duration-labele...

the IRS recently open sourced most of Direct File, a tax tool it has been working on for a few years now. unfortunately, due to recent events, the IRS isn't working on it anymore. I decided to pick up where they left off and I'm trying to get it ready for next tax season

the work behind Direct File is really interesting and I made a lot of it available online to read as well - https://docs.openfile.tax/en/latest/

I keep running in the same problem of each AI app “remembers” me in its own silo. ChatGPT knows my project details, Cursor forgets them, Claude starts from zero… so I end up re-explaining myself dozens of times a day across these apps.

The deeper problem

1. Not portable – context is vendor-locked; nothing travels across tools.

2. Not relational – most memory systems store only the latest fact (“sticky notes”) with no history or provenance.

3. Not yours – your AI memory is sensitive first-party data, yet you have no control over where it lives or how it’s queried.

Demo video: https://youtu.be/iANZ32dnK60

Repo: https://github.com/RedPlanetHQ/core

What we built

- CORE (Context Oriented Relational Engine): An open source, shareable knowledge graph (your memory vault) that lets any LLM (ChatGPT, Cursor, Claude, SOL, etc.) share and query the same persistent context.

- Temporal + relational: Every fact gets a full version history (who, when, why), and nothing is wiped out when you change it—just timestamped and retired.

- Local-first or hosted: Run it offline in Docker, or use our hosted instance. You choose which memories sync and which stay private.

Try it

- Hosted free tier (HN launch): https://core.heysol.ai

- Docs: https://docs.heysol.ai/core/overview

In late 2024, I had to set up a new Stripe account because I incorporated my company in a different country. Turns out it's not as simple as just changing the country in a dropdown, you have to start from scratch.

I had hundreds of users and using Stripe's dashboard to add all of the products, prices, coupons and subscriptions manually would take ages. I contacted a couple of services that help with this kind of migration, but their quotes were way over my budget. My next option was to use Stripe's API, which is very powerful but also very complicated. I'm a designer who can code, but I didn't feel confident doing it alone, so I asked a friend, an experienced developer, to help.

It proved to be quite challenging, with many details and caveats we had to learn as we went. What we thought would take a couple of days took us a week.

After this experience, we teamed up and built https://stripemove.com, a tool that guides you through this whole process, explaining and automating that hard week we went through. It handles the technical complexity while keeping your business running. Customers keep paying on your old account while everything transfers in parallel, then you flip the switch when ready.

It's a very niche tool, built for founders who need to change their company location for personal or business reasons. For entrepreneurs buying companies established in other countries. For people in the same situation I was in a few months ago. Basically the tool I wished existed, and for a fair price. Designed to get you through this inconvenient process and back as soon as possible on growing your business.

Would love to hear from anyone who's dealt with similar Stripe migrations. What was your biggest pain point?

Hi all,

I’m hacking on new features for the ClickHouse native client and wanted the same “just call the model” ergonomics JavaScript and Python now enjoy. It didn’t exist for modern C++, so I wrote one.

ai‑sdk‑cpp (Apache‑2.0) gives you:

- Unified calls to OpenAI (GPT‑4o) and Anthropic (Claude 3.5) with a single C++20 API. - Streaming, multi‑turn chat, error handling—all std::optional/std::variant, no macros. - Tool calling (function‑calling) so the model can hit real APIs; sync or async, runs in parallel.

The tricky bit: C++ still lacks real reflection, so mapping plain functions → JSON schemas isn’t as automatic as, say, TypeScript decorators. I’d love fresh eyes on that part. Try the examples and tell me where it feels clunky. This is inspired by Vercel's AI SDK [1], and litellm [2].

Repo live here: https://github.com/ClickHouse/ai-sdk-cpp, feedback welcome!

[1] https://github.com/vercel/ai [2] https://github.com/BerriAI/litellm

Spegel is a new open-source software platform that aims to revolutionize the way organizations manage and secure their data. It offers a decentralized, blockchain-based approach to data storage and access, providing enhanced privacy, transparency, and control for users.

I made a HN client that allows you to explore comments in a breadth-first manner. Compared to the classic depth-first approach, it works much better for the larger threads - you don't lose the context and can easily skip discussions you're not interested in.

Video preview: https://imgur.com/a/tzBdpXw

Hey HN, I’ve been working on developing my ad blocker for the last number of years and am proud to share that I have now released a new feature that blocks ads directly in apps — not just in a web browser.

What makes this app ad blocker feature special?

- All ad blocking is done directly on device,

- Using a fast, efficient Swift-based architecture (based upon Swift-NIO)

- Follows a strict ZERO data collection and logging policy

- Blocks ads in all apps on iPhones, iPads and Macs

It works as a local VPN proxy, so it filters all of your traffic locally without going through any third-party servers. The app ad blocker works across News apps, Social media, Games and even browsers like Chrome and Firefox.

After using ad blocking in Safari for a long time, it is eye-opening how many ads and trackers are also embedded in apps themselves. The app is available via the App Store, with a 30 day free trial, before an annual subscription is required.

I know there are many other ad blockers available, but I hope the combination of performance, efficiency and respect for privacy will mean that this particular feature is a valuable option.

It also took a LOT of work to get this working seamlessly within the App Store and iOS / macOS limitations, so am glad the app has been able to finally be released into the world.

Full details on the feature are in the release post:

https://www.magiclasso.co/insights/app-ad-blocking/

I always forget about one or 2 places when I upgrade my node version so I made a cheatsheet of all the places it can be set and where you can have it fall back to instead of setting it manually.

Hi HN — we're the team behind Arch (https://github.com/katanemo/archgw), an open-source proxy for LLMs written in Rust. Today we're releasing Arch-Router (https://huggingface.co/katanemo/Arch-Router-1.5B), a 1.5B router model for preference-based routing, now integrated into the proxy. As teams integrate multiple LLMs - each with different strengths, styles, or cost/latency profiles — routing the right prompt to the right model becomes a critical part of the application design. But it's still an open problem. Most routing systems fall into two camps:

- Embedding-based routers use intent classifiers — label a prompt as “support,” “SQL,” or “math,” then route to a matching model. This works for simple tasks but breaks down in real conversations. Users shift topics mid-conversation, task boundaries blur, and product changes require retraining classifiers.

- Performance-based routers pick models based on benchmarks like MMLU or MT-Bench, or based on latency or cost curves. But benchmarks often miss what matters in production: domain-specific quality or subjective preferences like “Will legal accept this clause?”

Arch-Router takes a different approach: route by preferences written in plain language. You write rules like “contract clauses → GPT-4o” or “quick travel tips → Gemini Flash.” The router maps the prompt (and conversation context) to those rules using a lightweight 1.5B autoregressive model. No retraining, no fragile if/else chains. We built this with input from teams at Twilio and Atlassian. It handles intent drift, supports multi-turn conversations, and lets you swap in or out models with a one-line change to the routing policy. Full details are in our paper (https://arxiv.org/abs/2506.16655), but here's a snapshot:

Specs:

- 1.5B params — runs on a single GPU (or CPU for testing)

- No retraining needed — point it at any mix of LLMs

- Cost and latency aware — route heavy tasks to expensive models, light tasks to faster/cheaper ones

- Outperforms larger closed models on our conversational routing benchmarks (details in the paper)

Links:

- Arch Proxy (open source): https://github.com/katanemo/archgw

- Model + code: https://huggingface.co/katanemo/Arch-Router-1.5B

- Paper: https://arxiv.org/abs/2506.16655

We scaled Google Ads because CPA looked great.

A month later, we realized those users never paid. No upgrades. Just email signups.

We wanted one place to ask:

“Which campaigns actually make money back?” “When does Meta break even?” “What features reduce churn?”

So we built a tool that connects product insights, ad data, revenue data etc.then turns plain questions into real answers. No dashboards, no BI setup, no SQL.

Click here for access https://kruxel.com/

Would love thoughts on clarity, usefulness, and what to build next.

Hi HN,

I have been working on a project which can automatically convert a recipe to the tree/graph/tabular style notation that pops up on HN every now and then. It's still early days but I am keen to hear about improvements I can make to the recipe presentation.

For reference, the earliest example I have seen of this style of notation is from 'Cooking For Engineers' (https://news.ycombinator.com/item?id=30797907) but I have seen other, similar notations from time to time.

This is my take on the notation, as well as the ability to convert recipes automatically. In the future, I would like to see it become my own personal kitchen/recipe management system but I would first like to improve the recipe display options.

It uses GPT-4o to format the recipe into a JSON tree structure, which is then rendered with CSS grid. So far it works well enough but there is definitely some recipes that are impossible to render, and of course GPT-4o will occasionally spit out less-than-useful trees. I have been using AppWrite for the backend.

Curious to hear everyone's thoughts and what people might like to see!

The article describes a desktop audio proxy that allows users to route audio from any application through a custom virtual audio device, enabling more advanced audio processing and routing capabilities on desktop systems.

I was debating when to post this, but I've been using it locally in a variety of situations for several months and I think it's pretty stable (and usable!). There are more features I'd like to add, but I wanted to see if there was much interest before spending much more time on it right now.

TokenDagger is a drop-in replacement for OpenAI’s Tiktoken (the tokenizer behind Llama 3, Mistral, GPT-3.*, etc.). It’s written in C++ 17 with thin Python bindings, keeps the exact same BPE vocab/special-token rules, and focuses on raw speed.

I’m teaching myself LLM internals by re-implementing the stack from first principles. Profiling TikToken’s Python/Rust implementation showed a lot of time was spent doing regex matching. Most of my perf gains come from a) using a faster jit-compiled regex engine; and b) simplifying the algorithm to forego regex matching special tokens at all.

Benchmarking code is included. Notable results show: - 4x faster code sample tokenization on a single thread. - 2-3x higher throughput when tested on a 1GB natural language text file.

Hello HN,

One week before my YC interview, my doctor told me I needed an open-heart surgery. I found myself explaining my condition again and again to different doctors across multiple hospitals. Filling out forms and getting appointments became a full-time job. I remember thinking: what if I could just take photos of all my reports, email them, and the hospital system could auto-extract everything? That idea led to what we’ve built: Semantic Email.

With Semantic Email, a patient can take a photo of their insurance card or referral letter, send it via email, and AI automatically fills out a Google Form, syncing data to Sheets and Drive — ready for integration into systems like EHR. While healthcare is personal to me, this works for any business on Google Workspace. Would love to hear your feedback and where you think this could apply beyond healthcare.

---

Try it free - https://promptrepo.com/email-to-form/

Demo video - https://www.youtube.com/watch?v=wLj4pXC30wM

Why we built it - https://guesswork.co/support/post/forms-must-die.anc-f4c5374...

HTMLRev is a web-based platform that allows users to test and debug their HTML, CSS, and JavaScript code in real-time, providing instant feedback and suggestions for improvement. It offers a range of tools and features to help developers optimize their web pages for performance and accessibility.

International Space Station Tracker on an ESP32 CYD (Cheap Yellow Display) costing $20. Live update over Wifi, touchscreen, backlight power management. Cheap and interesting classroom STEM project. Fully open source.

Need printable seating cards for your event? Placecard.net lets you: Design seating cards in your browser (no signup) Auto-generate PDFs using Puppeteer (no manual drag-anddrop) 100% free for small events

Tech stack:

Next.js (frontend)

Puppeteer (PDF generation)

Hosted on Vercel (fast renders)

I built this after struggling with manual seating charts for my wedding. Now you can:

Upload guest names

Adjust layout (optional)

Click "Generate PDF" → Done!

No AI, no pricing tiers—just free PDF seating cards.

Try it now | How Puppeteer makes it work

We’ve built SQLRooms, an open-source framework for creating single-node data analytics apps powered by DuckDB.

It lets you build fully client-side, data-centric apps using React and DuckDB running in the browser (via WebAssembly) or in Electron. No server or backend is required — apps can work offline, preserve data privacy, and run queries on large datasets with sub-second performance.

Features:

- Query large datasets in browser with DuckDB (WASM)

- Modular design for building composable data UIs (query editors, dashboards, notebooks, etc.)

- Data privacy-preserving AI assistant that can write and execute SQL queries

- Integrations with various visualization libraries

Check live examples: https://sqlrooms.org/examples

Learn more: https://sqlrooms.org

Code: https://github.com/sqlrooms/sqlrooms

Would love feedback, ideas, or suggestions!

Ensō is a writing tool that helps you enter a state of flow by separating writing from editing and thus making it harder for you to edit yourself - https://enso.sonnet.io/

After 6 years and 2 million words of daily writing I feel like I've learned enough to make Ensō simpler and more accessible.

Related thread: https://news.ycombinator.com/item?id=38025073

The article provides step-by-step instructions for installing the Synia.tech email service, including setting up domain records, configuring email clients, and troubleshooting common issues. It covers the necessary technical details to help users successfully set up their Synia.tech email accounts.

Hey HN!

Pilots everywhere are required to keep a logbook of all their flying hours, aircraft, airports, and so on. Since I track everything digitally (some people still just use paper logbooks!), I put together some data visualizations and a few 3D globes to show my flying history.

This globe is probably my favourite so far: https://jameshard.ing/pilot/globes/all

If you’ve got ideas for other graphs or ways to show this kind of data, I’d love to hear them!

Hi HN,

I wanted to give my family, who are scattered all over the world, a simple and private way to connect. The commercial options didn't quite fit, and the open-source tools I found were a bit too barebones and not friendly enough for non-technical users.

My main goal was to build something completely self-service. I wanted my family to be able to manage their own devices without my help, so I could set it up once and then stay out of it.

This led me to build LeiaGuard, a self-hostable UI for WireGuard built with Next.js. To make it truly easy for everyone, the interface is available in both English and Farsi.

Here's how it helps with that:

- Self-service invites: You can send multi-use invitation codes to onboard new family members.

- Easy device management: Users add their own devices and get set up with a QR code or config file, no admin help needed.

- Simple admin panel: When you do need to step in, there's a clean dashboard to manage users and invites.

- Simple deployment: Comes with a one-command script for Hetzner and a Docker Compose setup for other hosts.

- Secure by default: Uses NextAuth.js for authentication.

The project is MIT licensed. I'd love to get your feedback and hope it might be useful for your family too.

You can check it out on GitHub: https://github.com/arashvakil/LeiaGuard