threads.js VS zaphod-bot

Threads.js makes it pretty easy to spawn a thread pool and handle multi-threading workloads.

We did this via the npm threads wrapper and esbuild. We first moved all of our compute code into a new file with minimal imports, called imageCompare.worker.js. We then added a pre-compilation step with esbuild to compile this file into a bundle. We then spawn the worker using this generated file as a blob, and interact with it via the threads promise interface.

That latter one is in it's own process, and I also use multiple threads with the threads library.

This app has a memory leak where your worker threads are spawning out of control. You can verify this in Chrome DevTools Source tab: after you click the Generate button, you can see the worker threads spawning out of control until you close the process.

I'd advise that you do a better job at manually spawning and terminating the threads with the TFJS process. I've had success using this library in combination with TFJS: https://threads.js.org/

You can use it for everything. Even the compute tasks you can offload to worker threads using something like https://github.com/andywer/threads.js or you could create intensive modules in Rust and integrate using something like https://github.com/neon-bindings/neon

Web worker meets worker threads – threads.js\ (3 comments)

threads.js

This is a UI for a delta robot project I've been working on for fun. There is an insane amount of complexity here that just isn't a problem with this paradigm. The 3D environment is all declaratively built, the optimisation pipeline is simple and easy to reason about. When data changes, 'everything just works'. On this page are the reconcilers for the 'text elements' like a regular webpage would use, as well as the 3D environment in the background, as well as the chart down the bottom left for the frame timing. This project would be unreasonable to impossible with the vast amount of solutions out there, but using web technologies, it's not only possible, but you can focus on making the user experience excellent. Subtle niceties like the blur behind the settings are trivial to accomplish. It's great to be able to link both a text element and a 3D object to a 'variable' on the hardware side of things, and have it 'just work', all with the same API.

It's free for students. It has the usual components for building user interfaces, a GPU accelerated charting library, an incremental computation engine for data processing and a 3D engine built in. This light painting delta robot is a good example of the kinds of things you can do with it.

We have several examples for the STM32, everywhere from a simple IMU project to a fairly complex delta robot. There are screenshots in those repos if you'd like to take a look.