Show stories

Earlier this year, I made a web reader that only showed a list of post titles, author domains, and links. The reader only updated once per day, so I wouldn't feel compelled to keep checking for new posts.

I have been using the tool, which I called Artemis, for several months. Every morning, I looked forward to my "morning paper" of blogs I love reading.

There are no notifications, read vs. unread states, counts of posts, etc. Only the last seven days of posts are available. The colour scheme is changeable. Dark mode is supported. All popular feed formats are supported.

There is no reading interface to read blog posts; rather, the links take you to the authors' websites. Many of my favourite bloggers put a lot of effort into the design of their blogs and like to change things up; I wanted an experience that embraced that.

The reader is now available for anyone to use (with invite code "hn").

The linked article is about the Biblio HTML, a markup language designed to represent bibliographic information. It provides a structured way to encode metadata about books, articles, and other published works. The article discusses the key features of Biblio HTML, including its ability to capture details such as author, title, publication date, and more. It also touches on the potential applications of this markup language in digital libraries, research databases, and other contexts where structured bibliographic data is needed.

Hi HN! This is an SDK for ESP32s (microcontrollers) that runs against OpenAI's new WebRTC service [0] My hope is that people can easily add AI to lots of 'real' devices. Wearable devices, speakers around the house, toys etc... You don't have to write any code, just buy a device and set some env variables.

If you have any feedback/questions I would love to hear! I hope this kicks off a generation of new interesting devices. If you aren't familiar with WebRTC it can do some magical things. Check out WebRTC for the Curious[1] and would love to talk about all the cool things that does also.

[0] https://platform.openai.com/docs/guides/realtime-webrtc

[1] https://webrtcforthecurious.com

Hey HN,

I'd like to share a fun project I've been working on: mizu.js.

It's a js library that add functional attributes support into your html, designed to be a simple and flexible alternative to fully-fledged web frameworks (such as Vue, React, and Angular), while offering more capabilities than other lightweight options (like Alpine.js and htmx).

As it's written using modern ES features and due to its isomorphic nature, it can be run in both browsers and runtimes (Node, Deno, Bun) without any changes. This makes it ideal for client-side and server-side rendering, as well as static site generation, whichever environment you prefer.

Just include the script in any web page (or backend) to get started. You can template content, bind attributes, add interactivity, handle HTTP interactions, create custom components, and much more — all out of the box, without any configuration, transpilation steps, or builds.

I hope you'll find mizu.js as exciting and useful as I do and I'd love to get your feedback! You can learn more about it at https://mizu.sh!

Online playground: https://mizu.sh/playground Custom builder: https://mizu.sh/build Code coverage: https://mizu.sh/coverage GitHub: https://github.com/lowlighter/mizu

## Motivation ##

Nowadays, setting up a complete environment and installing thousands of packages is often required just to create a simple "Hello World" page. Yet, with the current ECMAScript standard, vanilla JS has never been more powerful. It offers built-in custom HTML components, proxies for changes tracking, weak references for better memory management, and many new data structures and methods.

So why is web development still insanely complex?

mizu.js aims to avoid adding bloat on top of native features, and instead focus on providing convenience helpers. It's basically "glue" around all these native features with added sugar, a recipe for a lightweight yet powerful utility.

All evaluated expressions are interpreted as vanilla JavaScript, and you add your instructions directly into your HTML. So if you know already know about JS/HTML, then you're already 80% know of how to use mizu.js (add an extra 10% if you've used Vue, Alpine.js or htmx in the past as some syntax and concepts are inspired by it), the rest is basically just remembering the directive names. The learning curve is that small.

Also, you may have heard of https://matcha.mizu.sh, a CSS stylesheet to instantly make your web page stylized. Well, it's a great companion to mizu.js. With both of them, you can create MVPs for your projects super fast!

Rerun 0.21 comes with a new graph viewer that's written in Rust and runs in the browser via wasm. It's powered by a new force based layout engine that is a port of much of d3-force to Rust. (The release also contains some other cool stuff like undo/redo implemented on top of a timeseries DB.)

We built this with applications in robotics and spatial computing in mind but would love to hear feedback from folks that would see this as useful in other domains as well.

Hello! I'd like share about my sideproject https://gribstream.com

It is an API to extract weather forecasting data from the National Blend of Models (NBM) https://vlab.noaa.gov/web/mdl/nbm and the Global Forecast System (GFS) https://www.ncei.noaa.gov/products/weather-climate-models/gl... . The data is freely available from AWS S3 in grib2 format which can be great but also really hard (and resource intensive) to work with, especially if you want to extract timeseries over long periods of time based on a few coordinates. Being able to query and extract only what you want out of terabytes of data in just an http request is really nice.

What is cool about this dataset is that it has hourly data with full forecast history so you can use the dataset to train and forecast other parameters and have proper backtesting because you can see the weather "as of" points in time in the past. It has a free tier so you can play with it. There is a long list of upcoming features I intend to implement and I would very much appreciate both feedback on what is currently available and on what features you would be most interested in seeing. Like... I'm not sure if it would be better to support a few other datasets or focus on supporting aggregations.

Features include:

- A free tier to help you get started - Full history of weather forecasts - Extract timeseries for thousands of coordinates, for months at a time, at hourly resolution in a single http request taking only seconds. - Supports as-of/time-travel, indispensable for proper backtesting of derivative models - Automatic gap filling of any missing data with the next best (most recent) forecast.

Please try it out and let me know what you think :)

I saw someone post these on reddit 4 years ago, and I really wanted to make them. I was surprised they didn't open source their code, so I rebuilt it.

Lots of things I would do differently now haha, but anyway, figured someone here might find it interesting.

The linked article is about a lab assignment that explores the behavior of reservoirs. It includes instructions for setting up and running a simulation of a reservoir system, with tasks focused on understanding factors like inflow, outflow, storage capacity, and release policies. The goal is to analyze the reservoir's performance under different scenarios and make recommendations for effective management strategies.

WebGPU tech demo running in modern browsers showcasing various rendering techniques like deferred rendering with 400+ dynamic lights, Hi-Z screen space reflections and cascaded shadow mapping.

For the longest time, I've been interested in the idea that the personal data we have logged across platforms can "paint" a pretty clear picture of who we are. And, as individuals, this will reveal fun and maybe sharable stories about us.

So I made this app, Day by Data, to connect with and visualize your personal data like step count, music listening habits, and more into tiny visualizations and data art right on your iPhone.

The launch version has a few year-in-steps breakdowns and a few Spotify data-visualizations.

Over time, the goal is to make more data sources available to connect and empower users to learn from their personal data stored across these platforms. Think data about the food we eat, places we travel, or shows we watch.

Data accessibility and cleanliness is the hardest part, but I'm always open to different sources and visualization types.

Let me know what you think and if there are certain data sets you'd like to see visualized!

Hey HN!

After 6 years of R&D, our small team is excited to share our project TideCloak - an IAM designed to help developers move fast without worrying about catastrophic breaches or overpowered admins with keys to the kingdom.

Traditional IAMs rely on centralized authority - admins, root certificates, and decryption keys - which create glaring vulnerabilities in a breach. To address this, we’ve integrated Keycloak (Red Hat’s IAM) with a decentralized key architecture powered by our (academically validated) Ineffable Cryptography.

Here’s the idea: keys are split across a decentralized network (our Cybersecurity Fabric) so no one ever holds the full key. Even in a breach or F$%k up, there’s no unchecked authority exposed.

Right now, TideCloak uses the Cybersecurity Fabric as an IdP, meaning users authenticate without their credentials being stored or shared. Essentially, users bring their own authority - without needing to trust anyone else to keep it safe.

Coming soon: - Identity Governance Administration to prevent super admin abuse. - User-sovereign digital assets, where assets are secured with unique decentralized keys to protect against mass breaches.

We’ve just launched a free developer sandbox, and we’d love your feedback: https://github.com/tide-foundation/tidecloak-gettingstarted

It’s still early stages, and your input will help us improve.

Thanks for taking a look - ask us anything!

Hello HN!

In a recent "Ask HN: What are you working on?" thread, I mentioned I was working on OCRing a large book:

https://news.ycombinator.com/item?id=41971614

The post generated some interest so I thought I would keep HN posted.

The book is Saint-Simon’s Memoirs -- an invaluable historical account of the French court under Louis XIV, full of wit, sharp observations, and of incredible literary value. I'm OCRing the edition of reference made between 1879-1930, that contains a lot of comments and footnotes: 45 volumes, ~27,000 pages.

Here's a link to a blog post that describes the techniques used so far (the project is still ongoing):

https://blog.medusis.com/38_Adventures+in+OCR.html

But you may also directly access the result here:

https://divers.medusis.net/boislisle/pub

This web app (not optimized for mobile, sorry) solves a tricky problem of preloading images efficiently. In short: preloading the next image isn't enough, since browsers will repaint if an image is moved, or scaled. Or browsers won't paint at all if visibility is hidden or opacity is zero, and will paint only when those values change. On an average, slow machine, this takes visible time. But if an image is simply behind another element, it will be painted, and the removal of the covering element or changing the z-index will not trigger a repaint.

(Preloading is important because it lets one review results fast; if one has to wait 150-200 ms between images it's simply discouraging).

Would love to hear feedback; happy to answer any question!

After being frustrated for years with existing solutions, I'm working on a new domain finder.

The idea is to combine everything I was missing: instant speed, good design, multiple extensions (with customizable search) and hack domains, real-time price comparison, SEO insights, domain name generation, meaning and sentiment analysis, favorites saving, custom alerts, management of all my domains all from one place.

If you try it, I'd love to read about it.

Hey, For those of you who don't know my little tool Musoq, I wanted to introduce it as a small tool that allows you to query with SQL-like syntax without any database.

It allows you to query various things from niche ones like CAN DBC files, weird ones like C# code, interesting ones with Git querying to regular stuff like CSV, TSV and various others.

I am quite a bit experimenting with various things so I'm hybridizing the engine with LLMs or doing other weird stuff that are more or less practical :-)

I wanted also to share some recent developments in this little project as I hope it might be interesting to some of you.

New Experimental Plugins: * Git Plugin (Beta): I've been working on Git repository querying - managed to test it on the EF Core repo (16k commits) and it seems to work okay * Roslyn Plugin (Beta): Added basic C# code analysis capabilities

For the very first time: I've extended CROSS APPLY to use computed results as arguments! Now the operator can use values from the current row as inputs. Here's an example:

  SELECT
    f.DirectoryName,
    f.FileName
  FROM #os.directories('/some/path', false) d
  CROSS APPLY #os.files(d.FullName, true) f
  WHERE d.Name IN ('Folder1', 'Folder2')

  with ProjectsToAnalyze as (
    select
        dir2.FullName as FullName
    from #os.directories('D:\repos', false) dir1
    cross apply #os.directories(dir1.FullName, false) dir2
    where
        dir2.Name = '.git'
  )
  select
    c.Message,
    c.Author,
    c.CommittedWhen
  from ProjectsToAnalyze p cross apply #git.repository(p.FullName) r 
  cross apply r.Commits c
  where c.AuthorEmail = 'my-email@email.ok'
  order by c.CommittedWhen desc

- Moved to .NET 8

- Added CROSS/OUTER APPLY operators

- Made some improvements to error messages and runtime behavior

New piping features: I've been experimenting with piping capabilities: * Image Analysis with LLMs:

  ./Musoq.exe image encode "image.jpg" | ./Musoq.exe run query "select s.Shop, s.ProductName, s.Price from ..."

  Get-Content "ticket.txt" | ./Musoq.exe run query "select t.TicketNumber, t.CustomerName ... from #stdin.text('Ollama', 'llama3.1') t"

  { docker image ls; ./Musoq.exe separator; docker container ls } | ./Musoq.exe run query "..."

Other Changes:

- Made some improvements to OS and Archive data sources (OS can now query metadata like EXIF)

- Added a few fields to CAN DBC plugin

- Command outputs can now be used as inputs for queries

I'm hoping to:

- Improve stability and add more tests

- Flesh out the documentation

- Work on package distribution (Scoop, Ubuntu packages)

- Share some examples of source code querying with Roslyn

Ideas for later:

- WHERE robust analysis and optimizations

- DISTINCT operator implementation

- PROTOBUF schema support

- Performance improvements

- Query parallelization

- Recursive CTEs

- Subqueries

I'd really appreciate any thoughts or feedback!

The documentation section where I write a short analysis of EF Core with git plugin: <https://puchaczov.github.io/Musoq/practical-examples-and-app...>

Hello everyone

Years ago, I built a personal feedback platform called Sarahah that got famous but was eventually removed from stores. One unique aspect of Sarahah was its simple, plain message box.

Now, I'm using this concept to help businesses gather raw feedback (yes, just plain free text) from their customers. This approach contrasts with guided surveys that can often frame and limit responses. On the business side, we use AI to analyze this feedback and provide valuable insights and recommendations.

I would really appreciate hearing your thoughts Additionally, if you're interested in using this in your startup where we hear your feedback and tailor it to your needs, please let me know

Hey everyone! I'm back with an update on this post [0].

Last year, I quit my corporate job and went full-time on ProjectionLab, the long-term financial planning app I've been building for the past 4 years, which some of you may recognize. The decision to go all-in felt like a huge leap. But it was the right call, and it's been a good year.

And without the HN community, it would not have happened. As I mentioned last time [0], the feedback on my original Show HN is THE reason I'm still here working on this. I'm really grateful for that. And I hope the way I’ve grown PL -- staying bootstrapped and focused on users -- resonates with the early supporters who helped to shape it.

For now I'm still the only engineer, burning the candle at both ends, but luckily I'm not feeling burnt out myself!

It's been a fun and memorable year:

- 6,139 commits, 221,484 insertions, 116,255 deletions

- Shared my story on the ChooseFI podcast [1] (one of the original sources of inspiration for this project)

- Started building a team (2 team members for customer success, 1 leading growth & marketing)

- Doubled our customer base

- Took no external funding, keeping our interests as aligned with users as possible

Okay, but what did I actually do since last time? [2]

Here's a quick cross-section:

- Compare mode upgrades to explore what-if scenarios overlaid on the same chart with visual deltas/diffs

- Launched ProjectionLab for Employers [3]: offer PL as a benefit, or get your employer to pick up the tab

- Major tech stack migrations: Vue 2 -> Vue 3, Vue CLI -> Vite, Vuetify 2 -> Vuetify 3, Vuex -> Pinia, Jest -> Vitest, Firebase Namespaced API -> Modular API, Vike + SSG for marketing site

- Advanced visualization features (1-click-plot any metric, interactive event icons in charts, etc)

- Improved tax estimation & tax analytics

- Simultaneous editing on multiple devices

- MFA support

- Rebuilt the help center, added more educational content and YouTube tutorial videos

- Made it possible to book a 1-on-1 session for educational/training purposes

- Converted ~65% of the codebase from JavaScript to TypeScript

- And more! [2]

I never saw myself as an entrepreneur/founder type. But apparently I've now spent 4 years turning a side project into a real business.

I couldn't have done it without the initial support from this community, and I'd love to hear what you think of the updates and where you'd like to see things go from here.

--Kyle

[0] https://news.ycombinator.com/item?id=36849502

[1] https://choosefi.com/podcast-episode/projectionlab-kyle-nola...

[2] https://projectionlab.com/changelog

[3] https://projectionlab.com/employers

Hi HN!

I’m excited to share flybnb.io, a side project I built out of personal frustration while traveling full-time with my wife. We often searched for flights and Airbnb stays separately, only to realize that one was way out of budget after planning the other. I wanted a way to combine both searches and instantly see the total trip cost, so I built it myself.

What flybnb.io can do:

- Gets flights from SkyScanner and Airbnb prices in one go with total costs for each condition (ex: fast flight + cheap stay)

- Smart Filters: Set minimum review counts and scores for stays to filter out unreliable listings that skew pricing.

- Auto-categorize Airbnb listings into three price tiers (Economy, Standard, and Premium) for easy research/planning.

- Generates links to directly search/book exact itinerary or listing on SkyScanner and Airbnb. (Note that sometimes SkyScanner results might differ in price from what is shown, working on a fix to have more accurate prices).

Using this tool ourselves we were able to actual visit new destinations that had a pricier flight, but was much cheaper overall due to great value and low cost Airbnbs. In the past we would search cheap flights first, then find accommodation resulting in a pretty high total cost. But for long stays and vacations, accommodation quickly becomes the largest cost.

For tech stack, I'm still new/beginner so using React with Material-UI, Supabase, and API's for the results.

I’d love feedback from the community—especially on features you’d find helpful or ideas to improve discovery. This is a bootstrapped solo build, so I’m learning a lot as I go. Ask me anything!

The linked article is about a 3D plotting library called implot3d, which is a lightweight and easy-to-use extension of the popular ImGui library. The library provides a simple way to create interactive 3D plots within a user interface, and it supports a variety of plot types, including scatter plots, line plots, and surface plots. The article includes instructions for installing and using the library, as well as examples of how to create different types of 3D plots.

Hello HackerNews!

I’m excited to share what we’ve been working on at nCompass Technologies: an AI inference* platform that gives you a scalable and reliable API to access any open-source AI model — with no rate limits. We don't have rate limits as optimizations we made to our AI model serving software enable us to support a high number of concurrent requests without degrading quality of service for you as a user.

If you’re thinking, well aren’t there a bunch of these already? So were we when we started nCompass. When using other APIs, we found that they weren’t reliable enough to be able to use open source models in production environments. To resolve this, we're building an AI inference engine that enable you, as an end user, to reliably use open source models in production.

Underlying this API, we’re building optimizations at the hosting, scheduling and kernel levels with the single goal of minimizing the number of GPUs required to maximize the number of concurrent requests you can serve, without degrading quality of service.

We’re still building a lot of our optimizations, but we’ve released what we have so far via our API. Compared to vLLM, we currently keep time-to-first-token (TTFT) 2-4x lower than vLLM at the equivalent concurrent request rate. You can check out a demo of our API here:

https://www.loom.com/share/c92f825ac0af4ab18296a16546a75be3

As a result of the optimizations we’ve rolled out so far, we’re releasing a few unique features on our API:

1. Rate-Limits: we don’t have any

Most other API’s out there have strict rate limits and can be rather unreliable. We don’t want API’s for open source models to remain as a solution for prototypes only. We want people to use these APIs like they do OpenAI’s or Anthropic’s and actually make production grade products on top of open source models.

2. Underserved models: we have them

There are a ton of models out there, but not all of them are readily available for people to use if they don’t have access to GPUs. We envision our API becoming a system where anyone can launch any custom model of their choice with minimal cold starts and run the model as a simple API call. Our cold starts for any 8B or 70B model are only 40s and we’ll keep improving this.

Towards this goal, we already have models like `ai4bharat/hercule-hi` hosted on our API to support non-english language use cases and models like `Qwen/QwQ-32B-Preview` to support reasoning based use cases. You can find the other models that we host here: https://console.ncompass.tech/public-models for public ones, and https://console.ncompass.tech/models for private ones that work once you've created an account.

We’d love for you to try out our API by following the steps here: https://www.ncompass.tech/docs/llm_inference/quickstart. We provide $100 of free credit on sign up to run models, and like we said, go crazy with your requests, we’d love to see if you can break our system :)

We’re still actively building out features and optimizations and your input can help shape the future of nCompass. If you have thoughts on our platform or want us to host a specific model, let us know at hello@ncompass.tech.

Happy Hacking!

* it's called inference because the process of taking a query, running it through the model and providing a result is referred to as "inference" in the AI / machine learning world. It's as opposed to "training" or "finetuning" which are processes used to actually develop the AI models that you then run "inference" on.

Every data pipeline job I had to tackle required quite a few components to set up:

- One tool to ingest data

- Another one to transform it

- If you wanted to run Python, set up an orchestrator

- If you need to check the data, a data quality tool

Let alone this being hard to set up and taking time, it is also pretty high-maintenance. I had to do a lot of infra work, and while this being billable hours for me I didn’t enjoy the work at all. For some parts of it, there were nice solutions like dbt, but in the end for an end-to-end workflow, it didn’t work. That’s why I decided to build an end-to-end solution that could take care of data ingestion, transformation, and Python stuff. Initially, it was just for our own usage, but in the end, we thought this could be a useful tool for everyone.

In its core, Bruin is a data framework that consists of a CLI application written in Golang, and a VS Code extension that supports it with a local UI.

Bruin supports quite a few stuff:

- Data ingestion using ingestr (https://github.com/bruin-data/ingestr)

- Data transformation in SQL & Python, similar to dbt

- Python env management using uv

- Built-in data quality checks

- Secrets management

- Query validation & SQL parsing

- Built-in templates for common scenarios, e.g. Shopify, Notion, Gorgias, BigQuery, etc

This means that you can write end-to-end pipelines within the same framework and get it running with a single command. You can run it on your own computer, on GitHub Actions, or in an EC2 instance somewhere. Using the templates, you can also have ready-to-go pipelines with modeled data for your data warehouse in seconds.

It includes an open-source VS Code extension as well, which allows working with the data pipelines locally, in a more visual way. The resulting changes are all in code, which means everything is version-controlled regardless, it just adds a nice layer.

Bruin can run SQL, Python, and data ingestion workflows, as well as quality checks. For Python stuff, we use the awesome (and it really is awesome!) uv under the hood, install dependencies in an isolated environment, and install and manage the Python versions locally, all in a cross-platform way. Then in order to manage data uploads to the data warehouse, it uses dlt under the hood to upload the data to the destination. It also uses Arrow’s memory-mapped files to easily access the data between the processes before uploading them to the destination.

We went with Golang because of its speed and strong concurrency primitives, but more importantly, I knew Go better than the other languages available to me and I enjoy writing Go, so there’s also that.

We had a small pool of beta testers for quite some time and I am really excited to launch Bruin CLI to the rest of the world and get feedback from you all. I know it is not often to build data tooling in Go but I believe we found ourselves in a nice spot in terms of features, speed, and stability.

https://github.com/bruin-data/bruin

I’d love to hear your feedback and learn more about how we can make data pipelines easier and better to work with, looking forward to your thoughts!

Best, Burak

Woke up today with a 100-degree fever & found out Google is now our competitor.

Last week, we started building signwith.co/ - a simple, pay-per-use e-signature tool for people who are struggling with complex e-sign tools.

The plan was to build quietly, run a private beta, get 50 users in 15 days, and then do a launch. Easy peasy.

But since Google dropped into the e-signature space - we needed to talk.

So after 30 minutes of existential dread, a lot of “what are we even doing?” thoughts, and one strong dose of paracetamol

we said, screw it. - let’s change gears.

So now we're opening our beta, and here's the deal:

• All the people who join will get free credits worth 10 signed docs • 12 months credit validity • No complexity • No hidden cost • No subscription commitment

You can join the beta here - http://signwith.co

That said, we see Google's entry in the signature space as validation.

This event expanded the market with such massive awareness.

Let me be clear: We’re not trying to be DocuSign, Google, or any other enterprise beast.

We’re indie makers and building for: • The freelancers • The consultants • The indie and small business owners • and anyone who just needs a contract signed—fast, simple, no headaches.

Here’s how SignWith works: • Upload your doc • Drop signature spots • Send it out and track • Pay per signed document

That’s it. No subscriptions. No feature bloat. No crazy hidden charges and no complex pricing tiers.

If you've read it so far, would love to see you on the other side.

And hey, if you’ve got any feedback, suggestions, or just want to tell us what you need, reply here or drop me a DM. We’re all ears!

Cheers!

Hello, everyone. I built Unicorn: an embeddable MISRA C:2012 implementation of essential Unicode Algorithms.

Unicorn is designed to be fully customizable: you can select which Unicode algorithms and character properties are included or excluded from compilation. You can also exclude Unicode character blocks wholesale for scripts your application does not support. It's perfect for resource constrained devices like microcontrollers and IoT devices.

About me: I quit my Big Corp job a few years back to pursue my passion for software development and this is one of my first commercial releases.

Marko here from Codaxy. For over two years, we have been working on CxReports, a low-code tool for creating user-facing PDF documents and reports.

We first saw the problem in wealth management, where reports are crucial for the user experience. Software vendors have customers who ask for customized reports with unique content, branding, and visuals. The solution was to build a tool that allows customization for each customer, which even customers themselves can use. Over time, this evolved to be a generic solution that works for various other use cases.

CxReports lets you build reports visually. You can connect to a database and get data using SQL queries. It supports scheduled report generation and delivery. The API enables accessing CxReports from other applications or workflows.

https://cx-reports.com/

You can easily try it out with our Docker image - https://docs.cx-reports.com/getting-started/docker/.

We offer a free tier for registered users.

How do you currently handle customized reporting? Are there specific challenges you face with generating user-facing reports? I’d love to hear your thoughts and feedback.

Looking forward to the discussion!

Svader is a library for rendering 2D shaders on Svelte websites, using either WebGL or WebGPU.

It's streamlined for the specific use case of rendering 2D graphics using fragment shaders as an alternative to SVG or the JS canvas API, so it's not meant for doing 3D objects like three.js, for example.

This started as something I needed for my own project, but I eventually decided to split it into a separate library. I've since found that this use case fits really well into the Svelte compiler-based approach and its fine-grained reactivity system.

In general, I think using shaders like these has some really positive upsides compared to traditional ways of doing graphics on the web — not just for games and stuff, but also for something like data visualizations and aesthetic details. My dream is that one day, you'll see web developers using small, isolated shader components ubiquitously across web applications, just as naturally as something like SVGs are used today.

Hi HN!

I wanted to share Yakari, a tool I built to make command-line interfaces more approachable through interactive TUIs. If you've ever forgotten CLI flags or needed to look up command syntax, this might help.

Yakari turns complex commands into interactive menus. Users can navigate through options with simple key presses instead of memorizing complex command structures. If you've used Emacs and Magit (or any other Transient) before, the interface will feel familiar.

Features: - Transform CLIs into guided menus - Create custom menus for any CLI - Support for flags, named parameters, choices, and interactive inputs - Command history and contextual help

You can try it out without installing thanks to uv [1]:

  uvx --from yakari ykr demo # Play with a demo showcasing different argument types
  uvx --from yakari ykr git  # Try the git menu in any git repo

I'd love feedback from both CLI users and developers. What tools would you find most useful to have menus for? How could this make your terminal workflows easier?

[1] https://docs.astral.sh/uv/