I'm working on a TUI Hacker News reader made in Rust! No AI, no credentials needed.

An ever-WIP collection of projects and blog posts.

https://www.hncli.newstackwhodis.com

Website for hncli, a TUI Hacker News reader made in Rust.

I've been working on something similar [0] also running in the terminal as a TUI. It's made in Rust with a quite novel architecture described in my blog [1].

There's still a performance issue with posts having a large amount of comments but it's quite there yet.

[0] https://github.com/pierreyoda/hncli [1] https://www.newstackwhodis.com/blog/hncli-2-architecture

I'm very proud of the way the architecture turned out - with most notably a components-driven architecture [1].

There's just a major performance roadblock in posts with many comments that I should be able to clear with some more multithreading. Then I just need to make it available in brew and other distribution solutions.

[0]: https://github.com/pierreyoda/hncli [1]: https://www.newstackwhodis.com/blog/hncli-2-architecture

To add to it, here's a famous and really clear sub-2 minutes representation of the scales involved if it helps make things clearer, for those who've never seen the scales involved: https://www.youtube.com/watch?v=xP5-iIeKXE8 (and that's "just" the Game of Life in the Game of Life).

I think I would enjoy helping push the state of the art in this field, but it's far beyond my abilities for the moment - which may never change without years of research in my free time, which I cannot realistically do before I'm retired basically.

If it wasn't, I would love to work on a new library specifically built for the kind of things like your idea, with the API aimed at working with metapixels-based "hardware", but with the lowest-level constructs (maybe by far) being thinks like RAM or CPU caches as building blocks - while still being able to zoom to the lowest level of cells in the renderer. But it's basically R&D and HPC combined if one wants to offer an interesting alternative to the established libraries.

From what I know of upcoming hardware, such a library may have to wait a couple of years and basically target (as in, full buy-in, maybe at the programming language-level, certainly in tooling) the next Apple Silicon-like (or beyond) breakthough in commonly accessible hardware for a nice, "free" performance boost. Maybe GPUs are next?

If you want to know more about the hardware side of the Game Boy (Color), have a look at the Pan Docs: https://gbdev.io/pandocs/

It's been revamped in the recent years, in terms of presentation. I do kind of miss the old version which had a refreshing "old-school" UI like the RFCs of the IETF, but the newest version is IMHO much more usable when developing an emulator.

"Old" gaming systems are so interesting in their architecture, and consequently tricks that game developers had to do to eke out the necessary performance out of the hardware! I feel like since PS3's Cell processor (regardless of what you think of it), game consoles have been increasingly following more classic (desktop-like) architecture in the entire hardware stack, which has been to be honest great for cross-platform game engines and applications.

That is why I love implementing emulators of older systems for fun. I recommend the classic CHIP-8 for starting, it's well documented and can be written to play practically any game ROM in a couple of days.

I personally then graduated to a Game Boy (Color) emulator, and in particular the PPU (graphics part) was really tricky to get right but I felt like the tile maps, as described in this video, were such a great solution for the time and it was a real joy to implement.

Subscribing to this channel, hope it will one day get into some details about the Audio Processing Unit which has so little resources (even in the reference Pan Docs [0]) that I fear I would need to straight up port code from reference open-source emulators (so probably C) to get it working with no major bugs.

[0] https://gbdev.io/pandocs/

As a shameless plug, I've been for the last few years re-implementing on and off this exact same project (based on the C++ codebase) in Rust, WebAssembly and Svelte! [2] Quite a bunch of buzzwords I know, but it's specifically made for me to have fun.

The map generation is working (or at least it was properly rendered when I was using React) and about ~50% of the codebase has been ported over to Rust, but there's still a lot of work to be done if anyone wants to help!

The end goal is notably to have tons of slick data visualisations with d3.js.

[1] https://github.com/SimHacker/micropolis [2] https://github.com/pierreyoda/micropolis-rs

In my experience, enums are far less type safe and convenient (usage in switch for instance, combined with a linter) than union types.

[1] https://github.com/TypeStrong/fork-ts-checker-webpack-plugin...

Re-using types (structs or union types) is also a huge pain.

I may be biased since I've been using it for almost 6 years, but you mostly don't need to worry about lifetime annotations which IMO is the really foreign part if you are already comfortable with functional languages, especially since the compiler is unbelievably useful.

Many well-known Rust crates also account for the majority of the best all-around libraries I've ever personally used in any language, and you can actually use them without a PHD in build systems thanks to Cargo.

Re-usability is superb thanks to traits (composition over inheritance) and generics, even if still immature domains tend to be overly generic for the end-user (HTTP networking for instance, though it's getting better fast).

Rust would be awesome but I think I'd want it to be as accessible as possible. Tagged unions and proper error handling would make it much saner though that's for sure.