Show stories

A terminal-based web browser in Nim.[1] Has acceptable (YMMV) CSS rendering, some JS support, and inline images (sixel/kitty). It can also use various protocols other than http(s) such as (s)ftp, gopher, gemini, ...

Chawan started out as a w3m clone, and the UI still resembles it. However, the architecture has turned out quite different, with pages loaded in separate processes, and protocol/file type handling separated out into external binaries. An interesting result is that you can even register decoders for custom inline image formats, although practical use cases of this are rather minimal.

There is a gallery showcasing some websites being rendered here: https://chawan.net/gallery/index.html

[1]: https://nim-lang.org

Hello HN!

I've been working on Canine for about a year now. It started when I was sick of paying the overhead of using stuff like Heroku, Render, Fly, etc to host some web apps that I've built. At one point I was paying over $400 a month for hosting these in the cloud. Last year I moved all my stuff to Hetzner.

For a 4GB machine, the cost of various providers:

Heroku = $260 Fly.io = $65 Render = $85 Hetzner = $4

(This problem gets a lot worse when you need > 4GB)

The only downside of using Hetzner is that there isn’t a super straightforward way to do stuff like:

- DNS management / SSL certificate management - Team management - Github integration

But I figured it should be easy to quickly build something like Heroku for my Hetzner instance. Turns out it was a bit harder than expected, but after a year, I’ve made some good progress

The best part of Canine, is that it also makes it trivial to host any helm chart, which is available for basically any open source project, so everything from databases (e.g. Postgres, Redis), to random stuff like torrent tracking servers, VPN’s endpoints, etc.

Open source: https://github.com/czhu12/canine Cloud hosted version is: https://canine.sh

The article discusses the development of a new model of secure and private Internet communication using decentralized technologies like blockchain and peer-to-peer networking. It explores how these technologies can be leveraged to create a more user-centric, transparent, and censorship-resistant online ecosystem.

I was looking for a tiny library to easily transform both 2D & 3D objects with simple mouse / touch controls and a fixed camera, in the browser.

Like a simple 3D editor but without requiring the user to be a Blender expert.

Couldn't find anything lightweight, so I’m building one. Think Fabric.js but for 3D. Built entirely with Three.js / R3F.

Borrowed some inspiration from VR/AR interaction systems for controls.

Feel free to play with it and let me know what you think!

After 25 years of writing software, I was feeling nostalgic for the kinds of things that got me into programming in the first place: the old DOS demoscene. I spent a weekend seeing if I could recapture some of that INT 13H VGA magic using today's web tech, but with the old-school constraints of doing it from scratch.

The result is this portfolio of ten classic effects running in a single HTML file. It's all vanilla JavaScript writing to a <canvas> element, with no external libraries. It was a fun challenge to implement things like:

* The color palette cycling and smooth fading in the Plasma demo. * The buffer-averaging algorithm for the Fire effect to make the flames feel more natural. * The distance-based texture crossfading in the Tunnel to create the illusion of flying through different sections. * A 2D scalar field for the Metaballs to calculate the surface normals for that classic blended, metallic look (I did the best I could with the given constraints).

It was a great exercise in getting back to first principles and a reminder of how much those early demo programmers could accomplish with so little. I hope it brings back some good memories for others who grew up with this stuff.

I'd love to hear about your favorite classic demos or if there are any other iconic effects you think would be a fun challenge to add.

Cheers!

YouTube learning has no structure—your learnings are scattered across random playlists, you're just passively watching without retention, and there's no one to ask when you don't understand something.

I built Notetube to solves this by combining organizational tools with AI to create an actual learning system:

Organizational layer: Create structured collections by topic/course/skill, track your learning progress with visual dashboards, and set achievable learning goals

AI layer: Auto-generated comprehensive notes (3000+ words for 1 hours video) and summaries from any video, key moment identification, personalized quizzes to test retention, and chat with videos for instant help when you're stuck

…and more features like taking timestamped notes, but I’ll stop here.

Signup is required, but i used Google OAuth for a quick, friction-free experience.

Try it free: https://www.notetubeai.com/

Would love to hear your feedback or questions!

faynoSync is a lightweight, open-source API server that gives you full control over application updates. Whether it’s desktop software, mobile apps, browser extensions, or custom binaries for metrics or monitoring — faynoSync helps you deliver updates easily, securely, and reliably. No external dependencies. Just pure control.

A quick game to test and sharpen your data visualization design skills.

Choose the better chart in 17 head-to-head matchups & learn something new with each one!

I've always found it cool to be in roles where I can help a younger generation learn skills to have a bright future. That role is something I do in a few ways (as a parent, robotics mentor, school board advisor and Sunday school teacher) and I suspect most HN readers share the same role and appreciation. And for developing software skills, it was obvious that both the students and I had to have a productive software environment where we could work together. That theme of experienced/inexperienced engineers working together is the context in which I created `dk` as a scripting tool.

My testing ground has been students with one or two AP CS courses (high school computer science in the US), some of whom interned with me. I had to tackle a few problems:

- The development environment had to be simple to setup and the programming language couldn't be complicated - The recognition that writing small, easily testable units of work (ex. "scripts") has been the only way I've found for very junior programmers to develop a large application - Cheap, locked-down development hardware (ex. school computers with limited RAM and no Administrator privileges) is sometimes used for deployment to cheap hardware targets (ex. hand-me-down Android tablets)

My solution was to write a standalone binary called `dk` that uses scripts as the atom of work, cross-compiles to standalone executables, and downloads the runtimes and sysroots it needs on-demand. It sits roughly in the same space as Python and Go.

`dk` is available for Windows, macOS and Linux/glibc host machines with a growing list of cross-compilation targets. Your `dk` scripts are written in an almost complete subset of OCaml 4: all `dk` scripts are OCaml, but not all OCaml code can run in `dk`. The other differences from conventional OCaml are that `dk` comes with a large library included, and that I treat any feature as buggy if the feature does not work on all supported OS-es.

The above origin of `dk` is admittedly odd (and abbreviated), so I was not expecting that `dk` would now be a general-purpose scripting tool. Yet it is. I can wrap, re-use and organize most of my hand-written software as a set of `dk` scripts.

Fair warning: The cross-compilation support in `dk` has had a recent overhaul and not every bug is closed. The error messages suck (you have to scroll up to see the root cause and resolution) but they will improve. Some progress bars are missing. There are also a few experimental features ... `uv`-style imports and an interactive interpreter are the big ones ... which are purposely under-documented because I am worried about `dk`'s API surface.

But it still works well, and you can see some real applications in the Examples section. I'd love if you could give it a kick in the tires and give `dk` some feedback! The issue list is at <https://github.com/diskuv/dk/issues>.

Hello,

I would like to share a Rust implementation of the Zstandard seekable format I've been working on.

Regular zstd compressed files consist of a single frame, meaning you have to start decompression at the beginning. The seekable format splits compressed data into a series of independent frames, each compressed individually, so that decompression of a section in the middle of an archive only requires zstd to decompress at most a frame's worth of extra data, instead of the entire archive.

I started working with the seekable format because I wanted to resume downloads of big zstd compressed files that are decompressed and written to disk on the fly. At first I created and used bindings to the C functions that are available upstream[1], however, I stumbled over the first segfault rather quickly (it's now fixed) and found out that the functions only allow basic things. After looking closer at the upstream implementation, I noticed that is uses functions of the core API that are now deprecated and it doesn't allow access to low-level (de)compression contexts. To me it looks like a PoC/demo implementation that isn't maintained the same way as the zstd core API, probably that's also the reason it's in the contrib directory.

My use-case seemed to require a complete rewrite of the seekable format, so I decided to implement it from scratch in Rust using bindings to the advanced zstd compression API, available from zstd 1.4.0.

The result is a single dependency library crate[2], and a CLI crate[3] for the seekable format that feels similar to the regular zstd tool.

Any feedback is highly appreciated!

[1]: https://github.com/facebook/zstd/tree/dev/contrib/seekable_f... [2]: https://crates.io/crates/zeekstd [3]: https://github.com/rorosen/zeekstd/tree/main/cli

Hey HN! I’m Elena, one of the co-founders of Taiyaki. My co-founder and I are both ex-Stanford mechanical engineers who worked on consumer electronics (iPads) and materials at Apple.

We built Taiyaki because most “custom” product platforms stall at 2D (like Etsy) or require complex CAD software. So we created a new pipeline: upload a photo, sketch, or idea, and we turn it into a 3D jewelry design in seconds, then make it in sterling silver, gold vermeil, or 14k gold.

We design with manufacturing in mind: things like minimum wall thickness, castability, and engraving depth are all baked into the output so the pieces can actually be made.

Would love feedback. Happy to answer questions!

Hello HN,

I built a Typescript library (named socket-call, for lack of a more sexy name) whose goal is to be able to call socket.io events as regular functions.

So you declare your server-side like so:

  ...
  const listenEvents = (services: UserServices) => ({
    // Add your events here, the name of the event is the name of the function
    login: async (username: string) => {
      services._socket.data.user = { username };
      console.log(`User ${username} logged in`);
      setInterval(() => {
        // Calling an event that's handled client-side
        services.showServerMessage(`You're still logged in ${username}!`)
      }, 1000);
      return `You are now logged in ${username}!`;
    },
  });

  ...
  const user = socket.addNamespace<UserEmitEvents, UserListenEvents>(
    '/user'
  );
  
  // Calling an event that's declared server-side
  user.login(username.value).then((message) => {
    console.log('Server acked with', message);
  });
  
  // Handling an event that is sent by the server
  user.showServerMessage = (message) => {
    console.log('Server sent us the message', message);
  }

Hi HN,

I built a CLI for uploading documents and querying them with an LLM agent that uses search tools rather than stuffing everything into the context window. I recorded a demo using the CrossFit 2025 rulebook that shows how this approach compares to traditional RAG and direct context injection[1].

The core insight is that LLMs running in loops with tool access are unreasonably effective at this kind of knowledge retrieval task[2]. Instead of hoping the right chunks make it into your context, the agent can iteratively search, refine queries, and reason about what it finds.

The CLI handles the full workflow:

```bash trieve upload ./document.pdf trieve ask "What are the key findings?"

```

You can customize the RAG behavior, check upload status, and the responses stream back with expandable source references. I really enjoy having this workflow available in the terminal and I'm curious if others find this paradigm as compelling as I do.

Considering adding more commands and customization options if there's interest. The tool is free for up to 1k document chunks.

Source code is on GitHub[3] and available via npm[4].

Would love any feedback on the approach or CLI design!

[1]: https://www.youtube.com/watch?v=SAV-esDsRUk [2]: https://news.ycombinator.com/item?id=43998472 [3]: https://github.com/devflowinc/trieve/blob/main/clients/cli/i... [4]: https://www.npmjs.com/package/trieve-cli

The article discusses the sexprs-repl crate, a REPL (Read-Eval-Print Loop) for working with S-expressions in Rust. It provides a tool for interactively exploring and manipulating S-expressions, which are a data representation commonly used in Lisp-based programming languages.

I made a typing game kind of like MonkeyType, but instead of just typing words, you write the translation. I built it because I wanted to get faster at writing in Spanish. Planning to add more languages soon. Give it a shot and let me know what you think

I built a Chrome extension that helps users of bolt.new save tokens and stay focused.

It automatically switches to Discussion Mode (which uses ~90% fewer tokens than Build Mode), sends real-time Discord notifications when tasks complete, errors occur, or input is needed, and optionally includes AI-powered summaries via GPT-4o, Claude, or Gemini.

Chrome Web Store: https://chromewebstore.google.com/detail/bolt-automations-by...

The repository contains the source code and documentation for the IPWT (Internet Print Workflow Technology) project, a system designed to enable remote printing and document management capabilities. The project aims to provide a secure and efficient solution for distributed printing and collaborative document workflows.

Hi hackers!

I'm a self-taught solo teenage dev

ever wanted to show what you're doing right now on the internet?

well I've been wanting to for a while, so I built Lynk, a lightweight macOS app that tracks your active apps, window titles, and daily usage in real time, and broadcasts that data over WebSockets. Oh and it also updates whenever you switch apps to connected clients!

No SDKs, no APIs — just local tracking + a websocket endpoint you can ping from any language.

GitHub: https://github.com/shaileshsaravanan/lynk

I've built a small compiler, heavily inspired by Svelte, that leans on modern web standards and proposals, namely Web Components, HTML Modules, and Signals.

Although web components never really took off, I still believe they have strong potential as a foundation for building web applications without relying on a framework.

GitHub: https://github.com/GuillaumeDucret/drop

Blog post: https://guillaumeducret.medium.com/web-components-and-my-que...

I’d appreciate some feedback before committing more time to this project !

I built StellarSnap as a calm, ad-free space to explore NASA’s Astronomy Picture of the Day (APOD) and learn astronomy along the way.

What it includes:

- A clean APOD archive browser with a Random APOD button

- A growing Glossary with term highlighting across the site

- A 2D Orbit Simulator where you can test satellite motion with real physics

- A deeper Encyclopedia, still early, but expanding

- Subtle touches like “see past APODs using this term”

- And more to come

It’s entirely ad-free, cookie-free, and not affiliated with NASA, but I was honored to have StellarSnap mentioned on the official APOD About page by Professor Robert Nemiroff: https://apod.nasa.gov/apod/lib/about_apod.html

Always open to ideas, critiques, or ways to make it better.

The article provides practical tips on how to effectively read and understand code, including breaking down complex code, identifying key components, and using various tools and techniques to aid the learning process.

Rilga is an open-source, lightweight deployment tool that simplifies the process of managing and deploying applications across multiple environments. It provides a user-friendly interface and offers features such as automatic configuration management, version control, and remote deployment capabilities.

I got tired of wrestling with AWS Cost & Usage Reports, so I wrote an open-source script: point it at a folder of Parquet CUR files, run one command, and get fully interactive Rill dashboards that adapt to your tags and cost drivers.

Highlights

Clone to custom dashboards in < 5 min

Ingests many CUR exports at once—even with schema drift.

Unifies schemas. Flattens MAP-type cols like resource tags automatically.

Chooses chart types programmatically based on spend coverage, cardinality, and distibution.

Generates Rill YAML (source, metrics (including measures), canvases) so you can tweak further.

Repo + demo video: https://github.com/Twing-Data/aws-cur-wizard

Credit to Dan Goldin (CEO @ Twing Data) for the idea. Would love feedback or edge-cases I missed!

Problem:

If you have less than $100k to invest, you get a robo-advisor that asks you 5 questions and dumps you into one of three cookie-cutter portfolios.

If you have more than $100k, you get a human advisor who charges 1-1.5% annually to... basically do the same thing with a smile and calming voice attached.

Meanwhile, institutional investors get custom strategies built around specific durations, target dates, tax situations and actual investment goals. Not because the math is harder—but because the economics only work at scale. Here's the thing: Both traditional advisors and robo-advisors maximize profit by minimizing choice and directing capital into the bias strategies that generate them additional margins. Both just tweak a risk slider and call it "personalization." But institutional-grade portfolio construction doesn't have to be exclusive to the wealthy. The road was paved by platforms like Plaid, brining API connectivity—platforms and asset aggregation into the mainstream. Modern AI completes the picture by making true personalization economically viable via "micro-advise".

No asset transfers, no new custodians, just sophisticated strategies based on your financial goals executed where you already invest coupled with personalized financial planning & budgeting.

Technical Solution:

We've built our MVP wealth management platform that creates truly personalized portfolios by combining institutional capital market expectations stemming 30+ global asset classes. All available through low-fee publicly available ETFs. Our approach:

- SEC licensed & compliant Registered Investment Advisor - Generates unlimited unique portfolio combinations optimized for risk, return & goal specifics.

- Personalizes to individual goals, not generic risk buckets.

- Learns and improves from every user interaction - Provides institutional-grade sophistication without human bottlenecks

- Removes manager bias for in-house strategies - Uses a "glidepath" approach similar to the US retirement target-date structure to maximize achievement certainty of important life goals (down-payment, retirement, etc)

- Seeks to bring elements of habit forming platforms (like Duolingo) into retail wealth. Business Model Innovation:

-Non-custodial + AI architecture enables subscription pricing ($10/month) instead of AUM fees. Users keep control of assets while getting personalized institutional strategies.

Research Validation:

- Glidepath strategies delivered higher values in 76% of scenarios (T. Rowe Price)

- Global diversification outperformed domestic-only in 96% of 3-year periods (Hübner) - Chance of success metrics for significant life goals like retirement & major milestones are measurably improved via behavioral advantages & sequence risk protection (T. Rowe Price).

Early Results:

-Alpha users report 90%+ cost reduction vs. traditional platforms with superior personalization. Institutional style portfolios achieving goal-specific optimization that would cost minimum 10x elsewhere.

-Base model portfolios have outperformed comparable portfolios from existing market incumbent robo-platforms on both an absolute & risk adjusted basis in H1 2025.

What's Different:

This isn't another robo-advisor using basic mean reversion. It's personalization that helps you understands and discover your specific goals and adapts continuously. Think "personal wealth manager in your pocket" rather than "generic portfolio assignment." All that, in a consumer product platform designed to empower retail investors and keep them engaged.

Next Steps:

Currently in invite-only alpha at www.fulfilledwealth.co. We focused early on the portfolio construction & delivery process and are now building out the consumer-facing aspects of the web application.

Looking for feedback from the HN community on our approaches to financial personalization.

Realistically speaking it's mostly useful for scraping, since parser works only in immutable state - it creates dom elements referencing original string, so changes to it are not cost effective. This approach has the benefit of increadibly small memory usage.

Here's python api if you want to test it https://github.com/TUVIMEN/reliq-python , pypi packages are compiled for windows, x86 aarch64 armv7 linux, and macos.

Hey HN!

I built Reactnest — an open-source visual feedback tool that helps teams collect rich, contextual feedback, including logs, screenshots, device info, user data, and sessions.

With Roastnest, users can: —Send feedback in 3 steps: click, point, send —Highlight UI elements directly on the page —Get instant confirmation on submission —Earn rewards for giving feedback

Everything’s shared via a simple link — no sign-up required.

Built for:

—Developers who want actionable bug reports —Designers who care about layout and UX details —PMs are tired of playing telephone between users and devs

It Includes:

—Live demo & docs: https://roastnest.com —React SDK (npm): https://github.com/satyamskillz/react-roast —Browser extension: (coming soon)

Would love your thoughts on:

—What’s missing for serious adoption? —Any blockers or red flags in the current flow? —Where do you see this fitting into your workflow?

Thanks for checking it out!

Sup HN, I'd like to show you the latest thing I've cooked up in my ongoing quest to acquire Finnish fluency. I call it `finyap`.

The GIF in the README.md probably does a better job of explaining the core mechanic than words can. But basically: We mask out a sentence, leaving only as much detail as the user needs to actually complete it, and then have them fill it out, word by word.

I'm showing it less because Finnish itself is interesting to most people, but because I think the general mechanism here could be useful for many other foreign language learners out there. I would especially recommend watching the YouTube video linked on the page, as I recently added a real practice session mode as well as a timer I've found to be quite useful in practice.

One of the biggest context AI LLMs can get from images is their metadata, but it's extremely underutilized. and while PNG and JPEG both offer metadata, it gets stripped way too easily when sharing and is extremely limited for AI based workflows and offer minimal metadata entries for things that are actually useful. Plus, these formats are ancient (1995 and 1992) - it's about time we get an upgrade for our AI era. Meet MEOW (Metadata-Encoded Optimized Webfile) - an Open Source Image file format which is basically PNG on steroids and what I also like to call the purr-fect file format.

Instead of storing metadata alongside the image where it can be lost, MEOW ENCODES it directly inside the image pixels using LSB steganography - hiding data in the least significant bits where your eyes can't tell the difference, this also doesn't increase the image size significantly. So if you use any form of lossless compression, it stays.

What I noticed was, Most "innovative" image file formats died because of lack of adoption, but MEOW is completely CROSS COMPATIBLE WITH PNGs You can quite literally rename a .MEOW file to a .PNG and open it in a normal image viewer.

Here's what gets baked right into every pixel:

- Edge Detection Maps - pre-computed boundaries so AI doesn't waste time figuring out where objects start and end.

- Texture Analysis Data - surface patterns, roughness, material properties already mapped out.

- Complexity Scores - tells AI models how much processing power different regions need.

- Attention Weight Maps - highlights where models should focus their compute (like faces, text, important objects)

- Object Relationship Data - spatial connections between detected elements.

- Future Proofing Space - reserved bits for whatever AI wants to add (or comments for training LORAs or labelling)

Of course, all of these are editable and configurable while surviving compression, sharing, even screenshot-and-repost cycles :p

When you convert ANY image format to .meow, it automatically generates most AI-specific features and data from what it sees in the image, which makes it work way better.

Would love thoughts, suggestions or ideas you all have for it :)

SmartScan is an media management app powered by a CLIP model that automatically organises images by content similarity and enables text-based search across both images and videos. Available on F-Droid (link in GitHub README).

I'm Hemang, co-founder of Clidey. While building Docucod – our platform for generating and maintaining technical documentation – we needed a simple, fast, and flexible way to host the docs.

We started with Next.js + Vercel, but it felt like overkill. SSR wasn’t needed, and we ran into vague webhook errors and deployment issues. It felt like too much complexity for a static documentation site.

So we built Dory – a minimal static site generator optimized for technical documentation. It's built with Preact, Vite, Tailwind, FontAwesome, Mermaid, and Typescript.

What makes Dory work for us: • Reads a folder of .mdx files • A single dory.json defines structure/layout • No SSR, no cloud lock-in • Fast builds, minimal config, deploy anywhere

The goal with Dory is to keep things truly simple — easy to set up, easy to use, and effortless to deploy for anyone building static documentation. Its design is inspired by great tools like Gitbook, Docusaurus, Readme, Mintlify, and Read the Docs. While we plan to add more features over time, simplicity will remain the core principle.

Once it becomes a bit more stable, we'll do a proper comparison to see load times, bundle size, all the good stuff.

It’s early (beta!), but it’s working well for us, and we’d love feedback from the community.

Repo: ⁦https://github.com/clidey/dory

Thanks for checking it out!