quickjs

It wasn't a QuickJS developer but developer from a fork: https://github.com/bellard/quickjs/issues/445

Not anymore, https://github.com/bellard/quickjs

I see a few mentions of QuickJS, but they all refer to the fork of Bellard's QuickJS https://bellard.org/quickjs/, which I think deserves a mention. It seems to be still active (last release 2025-04-26, GitHub mirror at https://github.com/bellard/quickjs shows some activity).

Considering the extremes of prolific developers gives interesting contrast to dogmas such as "functions/files should never be above x lines", where `quickjs.c` is 50k lines and has functions that are hundreds of lines long: https://github.com/bellard/quickjs/blob/master/quickjs.c (Obviously different approaches suits different circumstances.)

You may be familiar, but I just wanted to show how it is available in many C implementations and is used, for example, in QuickJS: https://github.com/bellard/quickjs/blob/0c8fecab2392387d76a4...

It using JavaScript native BigInt and Chudnovsky Algorithm ([wiki]), the code was taken from one of the examples in the QuickJS project ([quickjs/pi], [pi_bigint.js]). The syntax for cutting: pi#6 // take 6 digits of Pi (314_159) pi#6#3 // take 6 digits of Pi but drop 3 beforehand (159_265) pi#1#40000 // take one digit at 40,000th It uses service workers to cache static files, by the time it opens up you already free to be offline, try toggle network switch to verify. It has download link at bottom of the about page ([accdoo.app/about]) which you could then self host it by dropping into any static hosting services. btw, the Pi feature was by-product from the original App but I won't expand here, if you'd like to learn more, please checkout its Show HN post (39115559, 39138957 and 39238295) previously. [wiki]: https:/

accdoo.app is a Web App / PWA that help you to crunch some numbers: arr.map(BigInt).reduce((a, b) => (a * b) ** 2n) The same operation can be performed on any off-the-shelf calculator (or in mind), but this one comes in handy for large numbers without losing its precisions, up to 100,000 digits on Web, 1,000,000 in CLI, configurable from API (npm:accdoo). Aside from the spirit of xkcd/936, it is widely applicable (does not require a dictionary nor an ANSI keyboard) and can be used for things like door locks, vaults, pins, passcodes, entropy seeding, or even root password for password managers (yes, all numeric is fine), etc. Now back to Pi, it is an infinite data source and constant across the universe (base-10), figured would be great to have it chopped freely and then mixed into the calculations above. The Pi is produced on-the-f

Well... check out QuickJS: the bulk of the code is in a single 55k LOC C file: https://github.com/bellard/quickjs/blob/master/quickjs.c

Not OP but I was considering using it as well. I could see it going either way. If Fabrice stays interested in the project and keeps improving it, it could be a great win. If he moves on to other things, perhaps not. I've been looking at quickjs issues and forks and see a lot of random fixes from various people and most of them don't seem to be accepted or responded to: * https://github.com/bellard/quickjs/issues/131 * https://github.com/bellard/quickjs/issues/130 * https://github.com/bellard/quickjs/issues/129 * https://github.com/bellard/quickjs/issues/123 * https://github.com/bellard/quickjs/issues/111 * https://github.com/bellard/quickjs/issues/103 * https://github.com/bellard/quickjs/issues/96 The mailing list doesn't seem to have a lot of responses either. So, it's actually hard to say. The first instinct is it's great to base a pro

You can also refer to the Unicode routines of other small JS engines[1,2], those don’t use ICU either, although the implementations are mercilessly size-optimized (to put it politely) and restricted to what the target JS version requires (e.g. Duktape does casemapping but no normalization). Still, Bellard’s in particular look like he had a small Unicode processing library lying around and just copied it into the tree, not like he was forced to write the absolute minimum to do a JS inteprerer, so they can even be compared with dedicated libraries like libgrapheme, libutf8proc or libutf. [1] https://github.com/bellard/quickjs/blob/master/libunicode.c [2] https://github.com/svaarala/duktape/blob/master/src-input/du...

A few that come to mind.. Hand-written compiler for WebAssembly Text format to binary - https://raw.githubusercontent.com/stagas/wat-compiler/main/s... Gameboy emulator implemented in C, that also runs in the browser - https://github.com/binji/binjgb QuickJS Javascript Engine - https://github.com/bellard/quickjs The TypeScript language and compiler - https://github.com/microsoft/TypeScript

I haven't looked too closely at LiveView yet. I did flip back and forth between going with the Hotwire approach (I guess inspired by LiveView?). It was a tough call, but I ultimately decided to server-render JS. This thought-experiment helped: • If Ruby could natively render Javascript, would they still choose the Hotwire approach? I concluded no. I don't see the reason to have multiple approaches (HTML over wire, Stimulus), when one solution would suffice. The one solution also happens to be way more familiar to today's frontend developers. I definitely didn't want to make another templating language. Bud will eventually ship with it's own JS evaluator. Either through https://github.com/dop251/goja or through porting https://github.com/bellard/quickjs to Go (~25kloc of C)

Im am always fascinated by how a single person can build a language runtime. That too for language like JavaScript where large number of features are introduces on regular basis. https://github.com/bellard/quickjs/graphs/contributors

> runtime for TypeScript written in Go This makes it sound like the TypeScript runtime (interpreter or JIT) is written in Go, but the project uses the quickjs JavaScript runtime, which is written in C: https://github.com/bellard/quickjs