quickjs VS TypeScript

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).

This is a fantastic approach.

BTW, it looks like the js engine is "QuickJS" [0]. (I'm not familiar with it myself.)

I like it because sqlite by itself lacks a host language. (e.g., Oracle's plsql, Postgreses pgplsql, Sqlserver's t-sql, etc). That is: code that runs on compute that is local to your storage.

That's a nice flexible design -- you can choose whatever language you want. But quite typically you have to bring one, and there are various complications to that.

It's quite powerful, BTW, to have the app-level code that acts on the app data live with the data. You can present cohesive app-level abstraction to the client (some examples people will hopefully recognize: applyResetCode(theCode) or authenticateSessionToken(), or whatever), which can be refined/changed without affecting clients. (Of course you still have to full power and flexibility of SQL and relational data for the parts of your app that need it.)

[0] https://bellard.org/quickjs/

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 suites different circumstances.)

And some lightweight alternatives like Bellard's QuickJS (https://bellard.org/quickjs/) in C and Kiesel (https://kiesel.dev/) in Zig.

Built on a highly optimized JavaScript runtime powered by QuickJS, Query offers fast startup times and efficient execution. Its built-in caching mechanism further enhances performance by storing function responses, reducing database load and latency. This focus on speed makes Query a standout choice for server-side rendering, especially in applications with many components.

Where the previous SDK was built on top of the QuickJS JavaScript engine and the Javy runtime, the new SDK is built on top of the Firefox browser’s SpiderMonkey engine, and the Bytecode Alliance’s StarlingMonkey runtime and ComponentizeJS WIT bindings generator.

I'm currently using Bellard's QuickJS engine on a new TypeScript project.

I can't give advice about the trademark, other than that I've been through this kind of thing before and it sucks.

What I can say... is that I love what you've been doing on your Deepkit, and I was horrified to hear that this was happening to you.

Seriously, I've only lurked in the community so far, but it's possibly the most forward-thinking foundational library in the web space that I've seen.

Strong typing with annotations that can simultaneously influence runtime ORM and frontend generation, while being fully compliant Typescript? A hand-rolled lightning-fast Typescript compiler that emits the runtime reflection capabilities? Full-fledged DI as an inherent part of the design, not an afterthought?

It's such an incredible blend of beautiful tooling with pragmatic applications.

For anyone curious about this, https://web.archive.org/web/20230916074647/https://deepkit.i... is a fascinating read.

https://github.com/microsoft/TypeScript/issues/47658#issueco... provides context on why some of TypeScript's design goals around erasure hold it back from these features. My vision of the web is that it would be an even more vibrant and innovative place if TypeScript were to cast off those restrictions.

DeepKit actually solving this by implementing its own compiler, bytecode, and interpreter... it's truly incredible.

Marc, know that there are people out there who love your work, and who will continue to follow it avidly regardless of the name. You're doing amazing things.

This parser is not written in TS types, and this kind of pedantry (when claiming "no js here") is important. In fact, the parser includes both the use of ternary operators as well as the rest operator, both of which are absolutely not part of the type system and are most certainly part of JS.

While this tries to reach the levels of "TypeScript is Turing complete[1]" (which happens to be super cool), it is, in my humble opinion, not even remotely interesting.

[1] https://github.com/Microsoft/TypeScript/issues/14833

TypeScript- a strongly typed programming language that builds on JavaScript, giving you better tooling at any scale.

Type Safety TypeScript support is as good as Comlink, with all the type inference you expect.