Fabrice Bellard Releases MicroQuickJS

1507 points2 monthsgithub.com

antirez • 2 months ago

If this had been available in 2010, Redis scripting would have been JavaScript and not Lua. Lua was chosen based on the implementation requirements, not on the language ones... (small, fast, ANSI-C). I appreciate certain ideas in Lua, and people love it, but I was never able to like Lua, because it departs from a more Algol-like syntax and semantics without good reasons, for my taste. This creates friction for newcomers. I love friction when it opens new useful ideas and abstractions that are worth it, if you learn SmallTalk or FORTH and for some time you are lost, it's part of how the languages are different. But I think for Lua this is not true enough: it feels like it departs from what people know without good reasons.

norir • 2 months ago

I don't love a good deal of Lua's syntax, but I do think the authors had good reasons for their choices and have generally explained them. Even if you disagree, I think "without good reasons" is overly dismissive.

Personally though, I think the distinctive choices are a boon. You are never confused about what language you are writing because Lua code is so obviously Lua. There is value in this. Once you have written enough Lua, your mind easily switches in and out of Lua mode. Javascript, on the other hand, is filled with poor semantic decisions which for me, cancel out any benefits from syntactic familiarity.

More importantly, Lua has a crucial feature that Javascript lacks: tail call optimization. There are programs that I can easily write in Lua, in spite of its syntactic verbosity, that I cannot write in Javascript because of this limitation. Perhaps this particular JS implementation has tco, but I doubt it reading the release notes.

I have learned as much from Lua as I have Forth (SmallTalk doesn't interest me) and my programming skill has increased significantly since I switched to it as my primary language. Lua is the only lightweight language that I am aware of with TCO. In my programs, I have banned the use of loops. This is a liberation that is not possible in JS or even c, where TCO cannot be relied upon.

In particular, Lua is an exceptional language for writing compilers. Compilers are inherently recursive and thus languages lacking TCO are a poor fit (even if people have been valiantly forcing that square peg through a round hole for all this time).

Having said all that, perhaps as a scripting language for Redis, JS is a better fit. For me though Lua is clearly better than JS on many different dimensions and I don't appreciate the needless denigration of Lua, especially from someone as influential as you.

kbenson • 2 months ago

> For me though Lua is clearly better than JS on many different dimensions and I don't appreciate the needless denigration of Lua, especially from someone as influential as you.

Is it needless? It's useful specifically because he is someone influential, and someone might say "Lua was antirez's choice when making redis, and I trust and respect his engineering, so I'm going to keep Lua as a top contender for use in my project because of that" and him being clear on his choices and reasoning is useful in that respect. In any case where you think he has a responsibility to be careful what he says because of that influence, that can also be used in this case as a reason he should definitely explain his thoughts on it then and now.

bakkoting • 2 months ago

Formally JavaScript is specified as having TCO as of ES6, although for unfortunate and painful reasons this is spec fiction - Safari implements it, but Firefox and Chrome do not. Neither did QuickJS last I checked and I don't think this does either.

tracker1 • 1 month ago

ES is now ES2025, not ES6/2015. There are still platforms that don't even fully implement enough to shim out ES5 completely, let alone ES6+. Portions of ES6 require buy in from the hosting/runtime environment that aren't even practical for some environments... so I feel the statement itself is kind of ignorant.

shawn_w • 2 months ago

>Lua is the only lightweight language that I am aware of with TCO.

Scheme is pretty lightweight.

bch • 2 months ago

Tcl too, fwiw[0].

[0] https://wiki.tcl-lang.org/page/NRE

shawn_w • 1 month ago

Tcl needs a special command for tail calls though, instead of it Just Working (tm). It's kind of awkward.

fnord123 • 2 months ago

Which scheme implementation? Guile?

NuclearPM • 1 month ago

feb • 1 month ago

ksec • 2 months ago

> I think the distinctive choices are a boon. You are never confused about what language you are writing because Lua code is so obviously Lua. There is value in this.

This. And not just Lua , but having different kind of syntax for scripting languages or very high level languages signal it is something entirely different, and not C as in system programming language.

The syntax is also easier for people who dont intend to make programming as their profession, but simply want something done. It used to be the case in the old days people would design simple PL for new beginners, ActionScript / Flash era and even Hypercard before that. Unfortunately the industry is no longer interested in it, and if anything intend to make every as complicated as possible.

teo_zero • 2 months ago

> Lua has a crucial feature that Javascript lacks: tail call optimization.

I'm not familiar with Lua, but I expect tco to be a feature of the compiler, not of the language. Am I wrong?

mananaysiempre • 2 months ago

You’re wrong in the way in which many people are wrong when they hear about a thing called “tail-call optimization”, which is why some people have been trying to get away from the term in favour of “proper tail calls” or something similar, at least as far as R5RS[1]:

> A Scheme implementation is properly tail-recursive if it supports an unbounded number of active tail calls.

The issue here is that, in every language that has a detailed enough specification, there is some provision saying that a program that makes an unbounded number of nested calls at runtime is not legal. Support for proper tail calls means that tail calls (a well-defined subgrammar of the language) do not ever count as nested, which expands the set of legal programs. That’s a language feature, not (merely) a compiler feature.

[1] https://standards.scheme.org/corrected-r5rs/r5rs-Z-H-6.html#...

teo_zero • 2 months ago

IgorPartola • 2 months ago

kerkeslager • 2 months ago

I don't think you're wrong per se. This is a "correct" way of thinking of the situation, but it's not the only correct way and it's arguably not the most useful.

A more useful way to understand the situation is that a language's major implementations are more important than the language itself. If the spec of the language says something, but nobody implements it, you can't write code against the spec. And on the flip side, if the major implementations of a language implement a feature that's not in the spec, you can write code that uses that feature.

A minor historical example of this was Python dictionaries. Maybe a decade ago, the Python spec didn't specify that dictionary keys would be retrieved in insertion order, so in theory, implementations of the Python language could do something like:

  >>> abc = {}
  >>> abc['a'] = 1
  >>> abc['b'] = 2
  >>> abc['c'] = 3
  >>> abc.keys()
  dict_keys(['c', 'a', 'b'])

But the CPython implementation did return all the keys in insertion order, and very few people were using anything other than the CPython implementation, so some codebases started depending on the keys being returned in insertion order without even knowing that they were depending on it. You could say that they weren't writing Python, but that seems a bit pedantic to me.

In any case, Python later standardized that as a feature, so now the ambiguity is solved.

It's all very tricky though, because for example, I wrote some code a decade that used GCC's compare-and-swap extensions, and at least at that time, it didn't compile on Clang. I think you'd have a stronger argument there that I wasn't writing C--not because what I wrote wasn't standard C, but because the code I wrote didn't compile on the most commonly used C compiler. The better approach to communication in this case, I think, is to simply use phrases that communicate what you're doing: instead of saying "C", say "ANSI C", "GCC C", "Portable C", etc.--phrases that communicate what implementations of the language you're supporting. Saying you're writing "C" isn't wrong, it's just not communicating a very important detail: what implementations of the compiler can compile your code. I'm much more interested in effectively communicating what compilers can compile a piece of code than pedantically gatekeeping what's C and what's not.

beagle3 • 2 months ago

Python’s dicts for many years did not return keys in insertion order (since Tim Peters improved the hash in iirc 1.5 until Raymond Hettinger improved it further in iirc 3.6).

After the 3.6 changed, they were returned in order. And people started relying on that - so at a later stage, this became part of the spec.

heavyset_go • 2 months ago

There actually was a time when Python dictionary keys weren't guaranteed to be in the order they were inserted, as implemented in CPython, and the order would not be preserved.

You could not reliably depend on that implementation detail until much later, when optimizations were implemented in CPython that just so happened to preserve dictionary key insertion order. Once that was realized, it was PEP'd and made part of the spec.

kristianp • 2 months ago

naasking • 2 months ago

If the language spec requires TCO, I think you can reasonably call it part of the language.

teo_zero • 2 months ago

tracker1 • 1 month ago

lioeters • 2 months ago

> as my primary language

I'd love to hear more how it is, the state of the library ecosystem, language evolution (wasn't there a new major version recently?), pros/cons, reasons to use it compared to other languages.

About tail-calls, in other languages I've found sometimes a conversion of recursive algorithm to a flat iterative loop with stack/queue to be effective. But it can be a pain, less elegant or intuitive than TCO.

alexdowad • 2 months ago

Lua isn't my primary programming language now, but it was for a while. My personal experience on the library ecosystem was:

It's definitely smaller than many languages, and this is something to consider before selecting Lua for a project. But, on the positive side: With some 'other' languages I might find 5 or 10 libraries all doing more or less the same thing, many of them bloated and over-engineered. But with Lua I would often find just one library available, and it would be small and clean enough that I could easily read through its source code and know exactly how it worked.

Another nice thing about Lua when run on LuaJIT: extremely high CPU performance for a scripting language.

In summary: A better choice than it might appear at first, but with trade-offs which need serious consideration.

tracker1 • 1 month ago

Yeah, you can usually write a TCO based algorithm differently without recursion though it's often more messy of an implementation... In practice, with JS, I find that if I know I'm going to wind up more/less than 3-4 calls deep I'll optimize or not to avoid the stack overflow.

Also worth noting that some features in JS may rely on application/environment support and may raise errors that you cannot catch in JS code. This is often fun to discover and painful to try to work around.

xonix • 2 months ago

Re: TCO

Does the language give any guarantee that TCO was applied? In other words can it give you an error that the recursion is not of tail call form? Because I imagine a probability of writing a recursion and relying on it being TCO-optimized, where it's not. I would prefer if a language had some form of explicit TCO modifier for a function. Is there any language that has this?

ZiiS • 2 months ago

At least in Lua then the rule is simply 'last thing a function dose' this is unambiguous. `return f()` is always a tail call and `return f() + 1` never is.

normie3000 • 1 month ago

alexisread • 2 months ago

Although it’s a bit weird, Able Forth has the explicit word ~

https://github.com/ablevm/able-forth/blob/current/forth.scr

I do prefer this as it keeps the language more regular (fewer surprises)

stellartux • 2 months ago

Sounds a bit like Clojure's "recur". https://clojuredocs.org/clojure.core/recur

draven • 2 months ago

Scala has the @tailrec annotation which will raise a warning if the function can’t be TCO’d

garaetjjte • 2 months ago

C, with [[clang::musttail]]

hajile • 1 month ago

JS has required proper tail calls (PTC) for a decade now. Safari's JavascriptCore and almost every implementation except v8/spidermonkey (and the now defunct chakra) have PTC.

v8 had PTC, but removed it because they insisted it MUST have a new tail call keyword. When they were shot down, they threw a childish fit and removed the PTC from their JIT.

kerkeslager • 2 months ago

> More importantly, Lua has a crucial feature that Javascript lacks: tail call optimization. There are programs that I can easily write in Lua, in spite of its syntactic verbosity, that I cannot write in Javascript because of this limitation. Perhaps this particular JS implementation has tco, but I doubt it reading the release notes.

> [...] In my programs, I have banned the use of loops. This is a liberation that is not possible in JS or even c, where TCO cannot be relied upon.

This is not a great language feature, IMO. There are two ways to go here:

1. You can go the Python way, and have no TCO, not ever. Guido van Rossum's reasoning on this is outlined here[1] and here[2], but the high level summary is that TCO makes it impossible to provide acceptably-clear tracebacks.

2. You can go the Chicken Scheme way, and do TCO, and ALSO do CPS conversion, which makes EVERY call into a tail call, without language user having to restructure their code to make sure their recursion happens at the tail.

Either of these approaches has its upsides and downsides, but TCO WITHOUT CPS conversion gives you the worst of both worlds. The only upside is that you can write most of your loops as recursion, but as van Rossum points out, most cases that can be handled with tail recursion, can AND SHOULD be handled with higher-order functions. This is just a much cleaner way to do it in most cases.

And the downsides to TCO without CPS conversion are:

1. Poor tracebacks.

2. Having to restructure your code awkwardly to make recursive calls into tail calls.

3. Easy to make a tail call into not a tail call, resulting in stack overflows.

I'll also add that the main reason recursion is preferable to looping is that it enables all sorts of formal verification. There's some tooling around formal verification for Scheme, but the benefits to eliminating loops are felt most in static, strongly typed languages like Haskell or OCaml. As far as I know Lua has no mature tooling whatsoever that benefits from preferring recursion over looping. It may be that the author of the post I am responding to finds recursion more intuitive than looping, but my experience contains no evidence that recursion is inherently more intuitive than looping: which is more intuitive appears to me to be entirely a function of the programmer's past experience.

In short, treating TCO without CPS conversion as a killer feature seems to me to be a fetishization of functional programming without understanding why functional programming is effective, embracing the madness with none of the method.

EDIT: To point out a weakness to my own argument: there are a bunch of functional programming language implementations that implement TCO without CPS conversion. I'd counter by saying that this is a function of when they were implemented/standardized. Requiring CPS conversion in the Scheme standard would pretty clearly make Scheme an easier to use language, but it would be unreasonable in 2025 to require CPS conversion because so many Scheme implementations don't have it and don't have the resources to implement it.

EDIT 2: I didn't mean for this post to come across as negative on Lua: I love Lua, and in my hobby language interpreter I've been writing, I have spent countless hours implementing ideas I got from Lua. Lua has many strengths--TCO just isn't one of them. When I'm writing Scheme and can't use a higher-order function, I use TCO. When I'm writing Lua and can't use a higher order function, I use loops. And in both languages I'd prefer to use a higher order function.

[1] https://neopythonic.blogspot.com/2009/04/tail-recursion-elim...

[2] https://neopythonic.blogspot.com/2009/04/final-words-on-tail...

kerkeslager • 2 months ago

EDIT 3: Looking at Lua's overall implementation, it seems to be focused on being fast and lightweight.

I don't know why Lua implemented TCO, but if I had to guess, it's not because it enables you to replace loops with recursion, it's because it... optimizes tail calls. It causes tail calls to use less memory, and this is particularly effective in Lua's implementation because it reuses the stack memory that was just used by the parent call, meaning it uses memory which is already in the processor's cache.

The thing is, a loop is still going to be slightly faster than TCOed recursion, because you don't need to move the arguments to the tail call function into the previous stack frame. In a loop your counters and whatnot are just always using the same memory location, no copying needed.

Where TCO really shines is in all the tail calls that aren't replacements for loops: an optimized tail call is faster than a non-optimized tail call. And in real world applications, a lot of your calls are tail calls!

I don't necessarily love the feature, for the reasons that I detailed in the previous post. But it's not a terrible problem, and I think it at makes sense as an optimization within the context of Lua's design goals of being lightweight and fast.

justin66 • 1 month ago

> In my programs, I have banned the use of loops.

Rather, you no longer see what they're doing clearly.

TimTheTinker • 1 month ago

There's value in both implicit and explicit loops.

Some highly recursive programming styles are really just using the call stack as a data structure... which is valid but can be restrictive.

jimbokun • 1 month ago

How so?

I suppose if you don’t understand recursion.

znpy • 2 months ago

No offence but it seems that all of the people that are replying to this comment are essentially screaming in the void, if anything among each other.

I scrolled most of this sub thread and gp seem to not be replying to any of the replies they got.

jacobs101 • 2 months ago

[dead]

unclad5968 • 2 months ago

> I do think the authors had good reasons for their choices and have generally explained them

I'm fairly certain antirez is the author of redis

pedroza_alex • 2 months ago

The word "authors" in that phrase refers to the authors of Lua, not Redis.

rapind • 2 months ago

Pretty sure he's talking about Lua's authors.

vanviegen • 2 months ago

I do not think your compiler argument in support of TCO is very convincing.

Do you really need to write compilers with limitless nesting? Or is nesting, say, 100.000 deep enough, perhaps?

Also, you'll usually want to allocate some data structure to create an AST for each level. So that means you'll have some finite limit anyway. And that limit is a lot easier to hit in the real world, as it applies not just to nesting depth, but to the entire size of your compilation unit.

lpribis • 2 months ago

TCO is not just for parse trees or AST, but in imperative languages without TCO this is the only place you are "forced" to use recursion. You can transform any loop in you program to recursion if you prefer, which is what the author does.

brabel • 2 months ago

> it feels like it departs from what people know without good reasons.

Lua was first released in 1993. I think that it's pretty conventional for the time, though yeah it did not follow Algol syntax but Pascal's and Ada's (which were more popular in Brazil at the time than C, which is why that is the case)!

Ruby, which appeared just 2 years later, departs a lot more, arguably without good reasons either? Perl, which is 5 years older and was very popular at the time, is much more "different" than Lua from what we now consider mainstream.

rwmj • 2 months ago

We had a lot problems embedding Ruby in a multithreaded C program as the garbage collector tries to scan memory between the threads (more details here: https://gitlab.com/nbdkit/nbdkit/-/commit/7364cbaae809b5ffb6... )

Perl, Python, OCaml, Lua and Rust were all fine (Rust wasn't around in 2010 of course).

rurban • 2 months ago

I'm reving _why's syck right now. Turns out my fork from 2013 was still the most advanced. It doesn't implement the latest YAML specs, and all of it's new insecurities, which is a good thing. And it's much, much faster than the sax-like libyaml.

But since syck uses the ruby hashtable internally, I got stuck in the gem for a while. It fell out of their stdlib, and is not really maintained neither. PHP had the latest updates for it. And perl (me) extended it to be more recursion safe, and added more policies (what to do on duplicate keys: skip or overwrite).

So the ruby bindings are troublesome because of its GC, which with threading requires now7 a global vm instance. And using the ruby alloc/free pairs.

PHP, perl, python, Lua, IO, cocoa, all no problem. Just ruby, because of its too tight coupling. Looks I have to decouple it finally from ruby.

rapind • 2 months ago

> Ruby, which appeared just 2 years later, departs a lot more, arguably without good reasons either?

I doubt we ever would have heard about Ruby without it's syntax decisions. From my understanding it's entire raison d'être was readability.

rwmj • 2 months ago

It's essentially Perl for people who don't like punctuation marks.

vidarh • 2 months ago

More like if Smalltalk and Perl had a prettier baby.

nurettin • 2 months ago

    def ruby(is)
      it = is 
      a = "bad"
      example()
      begin
        it["had"] = pascal(:like)
      rescue
        flow
      end
    end

zeckalpha • 2 months ago

Pascal and Ada are Algol syntaxed relative to most languages.

jhgb • 1 month ago

> yeah it did not follow Algol syntax but Pascal's and Ada's

Now quite sure what you mean by that; all of Lua, Pascal, and Ada follow Algol's syntax much more closely than C does.

a-french-anon • 2 months ago

I don't think you understand his point. Ruby has a different syntax because it presents different/more language features than a very basic C-like language; it's inspired by Lisp/SmallTalk, after all. Lua doesn't but still decided to change its looks a lot, according to him.

rweichler • 2 months ago

I read this comment, about to snap back with an anecdote how I as a 13 year old was able to learn Lua quite easily, and then I stopped myself because that wasn't productive, then pondered what antirez might think of this comment, and then I realized that antirez wrote it.

aidenn0 • 2 months ago

I think the older you are the harder Lua is to learn. GP didn't say it made wrong choices, just choices that are gratuitously different from other languages in the Algol family.

le-mark • 2 months ago

I’m tickled that one of my favorite developers is commenting on another of my favorites work. Would be great if Nicolas Cannasse were also in this thread!

cxr • 2 months ago

It wouldn't fix the issue of semantics, but "language skins"[1][2] are an underexplored area of programming language development.

People go through all this effort to separate parsing and lexing, but never exploit the ability to just plug in a different lexer that allows for e.g. "{" and "}" tokens instead of "then" and "end", or vice versa.

1. <https://hn.algolia.com/?type=comment&prefix=true&query=cxr%2...>

2. <https://old.reddit.com/r/Oberon/comments/1pcmw8n/is_this_sac...>

nine_k • 2 months ago

Not "never exploit"; Reason and BuckleScript are examples of different "language skins" for OCaml.

The problem with "skins" is that they create variety where people strive for uniformity to lower the cognitive load. OTOH transparent switching between skins (about as easy as changing the tab sizes) would alleviate that.

brabel • 2 months ago

> OTOH transparent switching between skins (about as easy as changing the tab sizes) would alleviate that.

That's one of my hopes for the future of the industry: people will be able to just choose the code style and even syntax family (which you're calling skin) they prefer when editing code, and it will be saved in whatever is the "default" for the language (or even something like the Unison Language: store the AST directly which allows cool stuff like de-duplicating definitions and content-addressable code - an idea I first found out on the amazing talk by Joe Armstrong, "The mess we're in" [1]).

Rust, in particular, would perhaps benefit a lot given how a lot of people hate its syntax... but also Lua for people who just can't stand the Pascal-like syntax and really need their C-like braces to be happy.

[1] https://www.youtube.com/watch?v=lKXe3HUG2l4

nine_k • 2 months ago

Also consider translation to non-English languages, including different writing and syntax systems (e.g. Arabic or Japanese).

Some languages have tools for more or less straightforward skinning.

Clojure to Tamil: https://github.com/echeran/clj-thamil/blob/master/src/clj_th...

C++ to distorted Russian: https://sizeof.livejournal.com/23169.html

dualogy • 2 months ago

> transparent switching between skins (about as easy as changing the tab sizes)

One of my pet "not today but some day" project ideas. In my case, I wanted to give Python/Gdscript syntax to any & all the curly languages (a potential boon to all users of non-Anglo keyboard layouts), one by one, via VSCode extension that implements a virtual filesystem over the real one which translates back & forth the syntaxes during the load/edit/save cycle. Then the whole live LSP background running for the underlying real source files and resurfacing that in the same extension with line-number matchings etc.

Anyone, please steal this idea and run with it, I'm too short on time for it for now =)

Orygin • 2 months ago

scns • 1 month ago

I wanted to give Python/Gdscript syntax to any & all the curly languages (a potential boon to all users of non-Anglo keyboard layouts)

Neo makes it really easy to type those

https://neo-layout.org

cibyr • 2 months ago

People fight about tab sizes all the time though.

dbdr • 2 months ago

rao-v • 2 months ago

One day Brython (python with braces allowing copy paste code to autoindent) will be well supported by LSPs and world peace will ensure

twic • 2 months ago

  SyntaxError: not a chance

xigoi • 1 month ago

What editor are you using that does not have a way to paste code with proper indentation?

rao-v • 1 month ago

kevin_thibedeau • 2 months ago

VB.Net is mostly a reskin of C# with a few extras to smooth the transition from VB.

procaryote • 2 months ago

Lowering the barrier to create your own syntax seems like a bad thing though. C.f. perl.

CapsAdmin • 2 months ago

It sounds like you're trying to articulate why you don't like Lua, but it seems to just boil down to syntax and semantics unfamiliarity?

I see this argument a lot with Lua. People simply don't like its syntax because we live in a world where C style syntax is more common, and the departure from that seem unnecessary. So going "well actually, in 1992 when Lua was made, C style syntax was more unfamiliar" won't help, because in the current year, C syntax is more familiar.

The first language I learned was Lua, and because of that it seems to have a special place in my heart or something. The reason for this is because in around 2006, the sandbox game "Garry's Mod" was extended with scripting support and chose Lua for seemingly the same reasons as Redis.

The game's author famously didn't like Lua, its unfamiliarity, its syntax, etc. He even modified it to add C style comments and operators. His new sandbox game "s&box" is based on C#, which is the language closest to his heart I think.

The point I'm trying to make is just that Lua is familiar to me and not to you for seemingly no objective reason. Had Garry chosen a different language, I would likely have a different favorite language, and Lua would feel unfamiliar and strange to me.

junon • 2 months ago

GP is the creator of Redis. I would imagine he knows Lua well given that Redis has embedded it for around a decade.

CapsAdmin • 2 months ago

In that case, my point about Garry not liking Lua despite choosing it for Garrysmod, for seemingly the same reason as antirez is very appropriate.

I haven't read antirez'/redis' opinions about Lua, so I'm just going off of his post.

In contrast I do know more about what Garry's opinion on Lua is as I've read his thoughts on it over many years. It ultimately boils down to what antirez said. He just doesn't like it, it's too unfamiliar for seemingly no intentional reason.

But Lua is very much an intentionally designed language, driven in cathedral-style development by a bunch of professors who seem to obsess about language design. Some people like it, some people don't, but over 15 years of talking about Lua to other developers, "I don't like the syntax" is ultimately the fundamental reason I hear from developers.

So my main point is that it just feels arbitrary. I'm confident the main reason I like Lua is because garry's mod chose to implement it. Had it been "MicroQuickJS", Lua would likely feel unfamiliar to me as well.

n42 • 1 month ago

If I am remembering correctly, there was a moment where Garry was seriously considering using Squirrel instead of Lua. I think he experimented with JavaScript too.

I’m not sure it’s still the case but he modified Lua to be zero indexed and some other tweaks because they annoyed him so much, so it’s possible if you learned GMod Lua you learned Garry’s Lua.

Of course his heart has been with C# for many years now.

c-smile • 1 month ago

Lua syntax is pretty good for DSL (domain specific language) cases / configuration definitions.

For example Premake[1] uses Lua as it is - without custom syntax parser but with set of domain specific functions.

This is pure Lua:

   workspace "MyWorkspace"
      configurations { "Debug", "Release" }
   
   project "MyProject"
      kind "ConsoleApp"
      language "C++"
      files { "**.h", "**.cpp" }
   
   filter { "configurations:Debug" }
      defines { "DEBUG" }
      symbols "On"
   
   filter { "configurations:Release" }
      defines { "NDEBUG" }
      optimize "On"

In that sense Premake looks significantly better than CMake with its esoteric constructs. Having regular and robust PL to implement those 10% of configuration cases that cannot be defined with "standard" declarations is the way to go, IMO.

[1] https://premake.github.io/docs/What-Is-Premake

vegabook • 2 months ago

Lua has been a wild success considering it was born in Brazil, and not some high wealth, network-effected country with all its consequent influential muscle (Ruby? Python? C? Rust? Prolog? Pascal? APL? Ocaml? Show me which one broke out that wasn't "born in the G7"). We should celebrate its plucky success which punches waaay above its adoption weight. It didn't blindly lockstep ALGOL citing "adooooption!!", but didn't indulge in revolution either, and so treads a humble path of cooperative independence of thought.

Come to think of it I don't think I can name a single mainstream language other than Lua that wasn't invented in the G7.

s3graham • 2 months ago

I appreciate your point, but Python was invented in .nl which wouldn't be G7 strictly speaking.

jabl • 2 months ago

In the same vein Pascal was invented by Niklaus Wirth in Switzerland.

garganzol • 2 months ago

JavaScript in 2010 was a totally different beast, standartization-wise. Lots of sharp corners and blank spaces were still there.

So, even if an implementation like MicroQuickJS existed in 2010, it's unlikely that too many people would have chosen JS over Lua, given all the shortcomings that JavaScript had at the time.

kybernetikos • 2 months ago

While you're not wrong that JS has come a long way in that time, it's not the case that it was an extremely unusual choice at the time - Ryan Dahl chose it for node in 2009.

IshKebab • 2 months ago

Not to mention the 1-based indexing sin. JavaScript has a lot of WTFs but they got that right at least.

nine_k • 2 months ago

This indeed is not Algol (or rather C) heritage, but Fortran heritage, not memory offsets but indices in mathematical formulae. This is why R and Julia also have 1-based indexing.

cmrdporcupine • 2 months ago

Pascal. Modula-2. BASIC. Hell, Logo.

Lately, yes, Julia and R.

Lots of systems I grew up with were 1-indexed and there's nothing wrong with it. In the context of history, C is the anomaly.

I learned the Wirth languages first (and then later did a lot of programming in MOO, a prototype OO 1-indexed scripting language). Because of that early experience I still slip up and make off by 1 errors occasionally w/ 0 indexed languages.

(Actually both Modula-2 and Ada aren't strictly 1 indexed since you can redefine the indexing range.)

It's funny how orthodoxies grow.

teo_zero • 2 months ago

bsder • 2 months ago

> Lots of systems I grew up with were 1-indexed and there's nothing wrong with it. In the context of history, C is the anomaly.

The problem is that Lua is effectively an embedded language for C.

If Lua never interacted with C, 1-based indexing would merely be a weird quirk. Because you are constantly shifting across the C/Lua barrier, 1-based indices becomes a disaster.

nine_k • 2 months ago

Pascal, frankly, allowed to index arrays by any enumerable type; you could use Natural (1-based), or could use 0..whatever. Same with Modula-2; writing it, I freely used 0-based indexing when I wanted to interact with hardware where it made sense, and 1-based indexes when I wanted to implement some math formula.

fc417fc802 • 2 months ago

IshKebab • 2 months ago

And MATLAB. Doesn't make it any better that other languages have the same mistake.

idle_zealot • 2 months ago

Does it count as 0-indexing when your 0 is a floating point number?

krackers • 2 months ago

Actually in JS array indexing is same as property indexing right? So it's actually looking up the string '0', as in arr['0']

idle_zealot • 2 months ago

nvlled • 2 months ago

Lua supports even functions and objects as keys:

  function f1() end
  function f2() end
  local m1 = {}
  local m2 = {}
  local obj = {
      [f1] = 1,
      [f2] = 2,
      [m1] = 3,
      [m2] = 4,
  }
  print(obj[f1], obj[f2], obj[m1], obj[m2], obj[{}])

Functions as keys is handy when implementing a quick pub/sub.

aidenn0 • 2 months ago

They do, but strings that are numbers will be reinterpreted as numbers.

[edit]

  let testArray = [];
  testArray[0] = "foo";
  testArray["0"] = "bar";
  testArray["00"] = "baz";
  console.log(testArray[0]);
  console.log(testArray["0"]);
  console.log(testArray["00"]);

bigstrat2003 • 2 months ago

There's nothing wrong with 1-based indexing. The only reason it seems wrong to you is because you're familiar with 0-based, not because it's inherently worse.

sltkr • 1 month ago

I'll refer you to Dijkstra's "Why numbering should start at zero": https://www.cs.utexas.edu/~EWD/transcriptions/EWD08xx/EWD831...

IshKebab • 2 months ago

That's simply untrue. 1-based indexing is inherently worse because it leads to code that is less elegant and harder to understand. And slightly less efficient but that's a minor factor.

klibertp • 1 month ago

If a language has a well-designed collections library (think Smalltalk and derivatives, not C++'s STL), the difference between 1 and 0-based indexing is hard even to notice, much less lead to "less elegant" code. Between Stream and Collection subclasses, the API is rich enough that using indexes is reserved for very low-level operations that you seldom use in non-FFI, non-VM code.

What you say is true for languages that don't have collections, real arrays, or vectors, only memory ranges. This is the case of C, but not Fortran, Pascal, or Ada. So yeah, if all you have is a hammer, you'd better use 0-based nails; hopefully, though, we'll allow for non-hammer tools in popular toolboxes sometime this century.

coliveira • 2 months ago

If you can't deal with off-by-one errors, you're not a programmer.

jancsika • 2 months ago

But with Lua all those errors are now off by two

bch • 1 month ago

Or 0. Lua is in superposition, ready for the quantum computing age.

chrisweekly • 2 months ago

Except for Date.

rwmj • 2 months ago

Out of interest, was Tcl considered? It's the original embeddable language.

rogerbinns • 2 months ago

In 1994 at the second WWW conference we presented "An API to Mosaic". It was TCL embedded inside the (only![1]) browser at the time - Mosaic. The functionality available was substantially similar to what Javascript ended up providing. We used it in our products especially for integrating help and preferences - for example HTML text could be describing color settings, you could click on one, select a colour from the chooser and the page and setting in our products would immediately update. In another demo we were able to print multiple pages of content from the start page, and got a standing ovation! There is an alternate universe where TCL could have become the browser language.

For those not familiar with TCL, the C API is flavoured like main. Callbacks take a list of strings argv style and an argc count. TCL is stringly typed which sounds bad, but the data comes from strings in the HTML and script blocks, and the page HTML is also text, so it fits nicely and the C callbacks are easy to write.

[1] Mosaic Netscape 0.9 was released the week before

andrewshadura • 2 months ago

Wasn't the original Redis prototype written in Tcl?

dontdoxxme • 2 months ago

Yes, previously: https://news.ycombinator.com/item?id=35989909

The Redis test suite is still written in Tcl: https://news.ycombinator.com/item?id=9963162 (although more recently antirez said somewhere he wished he'd written it in C for speed)

MangoToupe • 1 month ago

> If this had been available in 2010, Redis scripting would have been JavaScript and not Lua.

This would have been a catastrophic loss. Lua is better than javascript in every single way except for ordinal indexing

dustbunny • 2 months ago

I also strongly disliked luas syntax at first but now I feel like the meta tables and what not and pcall and all that stuff is kinda worth it. I like everything about Lua except some of the awkward syntax but I find it so much better then JS, but I haven't been a web dev in over a decade

junon • 2 months ago

The only thing I dislike about Lua is the 1-indexing. I know they had reasons for it but it always caused issues.

silisili • 2 months ago

I'm torn on this.

Initially I agreed, just because so many other languages do it that way.

But if you ignore that and clean slate it, IMO, 1 based makes more sense. I feel like 0 based mainly gained foothold because of C's bastardization of arrays vs pointers and associated tricks. But most other languages don't even support that.

You can only see :len(x)-1 so many times before you realize how ridiculous it is.

wzdd • 2 months ago

Python got this right. Zero-based indexing combined with half-open slice notation means as a practical matter you don't see too many -1s in the code. Certainly far fewer than when I wrote a game in Löve for a gamejam, where screen co-ordinates are naturally zero-indexed, which has implications for everything onscreen (tile indices, sprites, ...)

junon • 2 months ago

0 based has a LOT of benefits whereas the reasoning, if I recall, for 1-indexing in Lua was to make the language more approachable to non-devs.

Having written a game in it (via LÖVE), the 1-indexing was a continued source of problems. On the other hand, I rarely need to use len-1, especially since most languages expose more readable methods such as `last()`.

bvrmn • 2 months ago

I could live with 1-indexing but a closed range array unpack (slices) is quite big toll and breaks nice intuitive invariant.

vrighter • 1 month ago

I don't mind the 1-based indexing at all. It's pretty easy to mentally switch into/out of the correct mindset after only a short while.

What does bug me is that Lua, the language, is 1-based, but its C api is not.

Hendrikto • 2 months ago

> If this had been available in 2010, Redis scripting would have been JavaScript and not Lua.

Thank god it wasn’t then.

nxobject • 1 month ago

+1 for the incredibly niche (but otherwise make-it-or-break-it) fact that PUC-Rio is and likely always will be strict C89 (i.e. ANSI C). I think this was (and still is?) most relevant to gamedev on Windows using older versions of MSVC, which has until recently been a few pennies short of a full C99 implementation.

I did once manage to compile Lua 5.4 on a Macintosh SE with 4MB of RAM, and THINK C 5.0 (circa 1991), which was a sick trick. Unfortunately, it took about 30 seconds for the VM to fully initialize, and it couldn't play well with the classic MacOS MMU-less handle-based memory management scheme.

pmarreck • 1 month ago

LuaJIT’s C FFI integration is super useful in a scripting language and I’ve replaced numerous functions previously written in things like Bash with it.

it also helps that it has ridiculously high performance for a scripting language

hnlmorg • 2 months ago

Lua only departs from norms if you’ve had a very narrow experience with other programming languages.

Frankly, I welcome the fact that Redis doesn’t use JavaScript. It’s an abomination of a language. The fewer times I need to use it the better.

DebugDruid • 2 months ago

I think criticizing JavaScript has become a way of signaling "I'm a good programmer." Yes, good programmers ten years ago had valid reasons to criticize it. But today, attacking the efforts of skilled engineers who have improved the language (given the constraints and without breaking half of the web) seems unfair. They’ve achieved a Herculean task compared to the Python dev team, which has broken backward compatibility so many times yet failed to create a consistent language, lacking a single right way to do many things.

hnlmorg • 2 months ago

> But today, attacking the efforts of skilled engineers who have improved the language (given the constraints and without breaking half of the web) seems unfair.

I was criticising a thing not a person.

Also your comment implies it was ok to be critical of a language 10 years ago but not ok today because a few more language designers might get offended. Which is a weird argument to make.

TheTaytay • 2 months ago

dev_l1x_be • 1 month ago

Or good programmers understand why JS is bad?

leptons • 2 months ago

Every programming language is an abomination depending on the perspective.

mbac32768 • 1 month ago

To paraphrase Bjarne Stroustrup, there are two kinds of programming languages. There are abominations and then there are the ones nobody uses.

andrewstuart • 2 months ago

Lua - an entire language off by one.

rurban • 2 months ago

Sure, because the first element is at index 1, not zero. Ha

spacechild1 • 2 months ago

> it feels like it departs from what people know without good reasons.

Lua is a pretty old language. In 1993 the world had not really settled on C style syntax. Compared to Perl or Tcl, Lua's syntax seems rather conventional.

Some design decisions might be a bit unusual, but overall the language feels very consistent and predictable. JS is a mess in comparison.

> because it departs from a more Algol-like syntax

Huh? Lua's syntax is actually very Algol-like since it uses keywords to delimit blocks (e.g. if ... then ... end)

lucketone • 2 months ago

I known for very long time that c (and co) inherited the syntax from algol.

But only after long time I tried to check what Algol actually looked like. To my surprise, Algol does not look anything like C to me.

I would be quite interested in the expanded version of “C has inherited syntax from Algol”

Edit: apparently the inheritance from Algol is a formula: lexical scoping + value returning functions (expression based) - parenthesitis. Only last item is about visual part of the syntax.

Algol alternatives were: cobol, fortan, lisp, apl.

spacechild1 • 2 months ago

The use of curly braces for delimiting blocks of code actually comes from BCPL.

Of course, C also inherited syntax from Algol, but so did most languages.

lioeters • 2 months ago

> consistent and predictable

That's what matters to me, not how similar Lua is to other languages, but that the language is well-designed in its own system of rules and conventions. It makes sense, every part of it contributes to a harmonious whole. JavaScript on the other hand.

When speaking of Algol or C-style syntax, it makes me imagine a "Common C" syntax, like taking the best, or the least common denominator, of all C-like languages. A minimal subset that fits in your head, instead of what modern C is turning out to be, not to mention C++ or Rust.

procaryote • 2 months ago

Is modern C really much more complicated than old C? C++ is a mess of course.

lioeters • 2 months ago

anthk • 2 months ago

atdt • 2 months ago

My hunch is that the same is true of Wikipedia's choice of Lua for template scripting, made back in 2012.

https://lists.wikimedia.org/hyperkitty/list/wikitech-l@lists...

zeckalpha • 2 months ago

Redis' author also made jimtcl, so I don't think the lack of a small engine was the gap

debugnik • 2 months ago

You're replying to Redis' author.

zeckalpha • 1 month ago

Thanks! Good catch...

kiririn • 1 month ago

I’m always surprised people pick Lua when Pawn exists. I think I’d even still choose it over MicroQuickJS

https://www.compuphase.com/pawn/pawn.htm

bnolsen • 1 month ago

I remember seeing this a long time ago and liking it, I just didn't have a use for it at the time. How does it stack up against luahit for perf and memory, and threading? It also looks like it could be worth looking at porting the compiler to zig which excels at both compiler writing and cross platform tooling.

3eb7988a1663 • 1 month ago

LuaJIT is best in class performance for a scripting language -by a huge margin. In very specific problems, it can outperform C. Surely anything else is going to come up lacking if you are only considering raw benchmarks.

lacoolj • 1 month ago

Normally I'd say "it's never too late!" but clearly would diverge and require an entirely new project, maintaining two bases for the same thing, etc.

Good to see you alive and kicking. Happy holidays

petters • 2 months ago

Lua having a JIT compiler seems like a big difference though. It was a while since that got major updates, but probably relevant at the time?

avaer • 2 months ago

What are the chances of switching to MQJS or something like it in the future?

TimTheTinker • 1 month ago

I for one would be would be very interested in a Redbean[0] implementation with MicroQuickJS instead of Lua, though I lack the resources to create it myself.

[0] https://redbean.dev/ - the single-file distributable web server built with Cosmopolitan as an αcτµαlly pδrταblε εxεcµταblε

jacobs101 • 2 months ago

[dead]

simonw • 2 months ago

Clarification added later: One of my key interests at the moment is finding ways to run untrusted code from users (or generated by LLMs) in a robust sandbox from a Python application. MicroQuickJS looked like a very strong contender on that front, so I fired up Claude Code to try that out and build some prototypes.

I had Claude Code for web figure out how to run this in a bunch of different ways this morning - I have working prototypes of calling it as a Python FFI library (via ctypes), as a Python compiled module and compiled to WebAssembly and called from Deno and Node.js and Pyodide and Wasmtime https://github.com/simonw/research/blob/main/mquickjs-sandbo...

PR and prompt I used here: https://github.com/simonw/research/pull/50 - using this pattern: https://simonwillison.net/2025/Nov/6/async-code-research/

simonw • 2 months ago

Down to -4. Is this generic LLM-dislike, or a reaction to perceived over-self-promotion, or something else?

No matter how much you hate LLM stuff I think it's useful to know that there's a working proof of concept of this library compiled to WASM and working as a Python library.

I didn't plan to share this on HN but then MicroQuickJS showed up on the homepage so I figured people might find it useful.

(If I hadn't disclosed I'd used Claude for this I imagine I wouldn't have had any down-votes here.)

claar • 2 months ago

I think many subscribe to this philosophy: https://distantprovince.by/posts/its-rude-to-show-ai-output-...

Your github research/ links are an interesting case of this. On one hand, late AI adopters may appreciate your example prompts and outputs. But it feels like trivially reproducible noise to expert LLM users, especially if they are unaware of your reputation for substantive work.

The HN AI pushback then drowns out your true message in favor of squashing perceived AI fluff.

simonw • 2 months ago

Yeah, I agree that it's rude to show AI output to people... in most cases (and 100% if you don't disclose it.)

My simonw/research GitHub repo is deliberately separate from everything else I do because it's entirely AI-generated. I wrote about that here: https://simonwillison.net/2025/Nov/6/async-code-research/#th...

This particular case is a very solid use-case for that approach though. There are a ton of important questions to answer: can it run in WebAssembly? What's the difference to regular JavaScript? Is it safe to use as a sandbox against attacks like the regex thing?

Those questions can be answered by having Claude Code crunch along, produce and execute a couple of dozen files of code and report back on the results.

I think the knee-jerk reaction pushing back against this is understandable. I'd encourage people not to miss out on the substance.

lossolo • 2 months ago

rpdillon • 2 months ago

Counterpoint to the sibling comment: posting your own site is fine. Your contributions are substantial, and your site is a well-organized repository of your work. Not everything fits (or belongs) in a comment.

I'd chalk up the -4 to generic LLM hate, but I find examples of where LLMs do well to be useful, so I appreciated your post. It displays curiosity, and is especially defensible given your site has no ads, loads blazingly fast, and is filled with HN-relevant content, and doesn't even attempt to sell anything.

gaigalas • 2 months ago

> can it run in WebAssembly?

You can safely assume so. Bellard is the creator of jslinux. The news here would be if it _didn't_.

> What's the difference to regular JavaScript?

It's in the project's README!

> Is it safe to use as a sandbox against attacks like the regex thing?

This is not a sandbox design. It's a resource-constrained design like cesanta/mjs.

---

If you vibe coded a microcontroller emulation demo, perhaps there would be less pushback.

colesantiago • 2 months ago

It is because you keep over promoting AI almost every day of the week in the HN comments.

In this particular case AI has nothing to do with Fabrice Bellard.

We can have something different on HN like what Fabrice Bellard is up to.

You can continue AI posting as normal in the coming days.

simonw • 2 months ago

Forget about the AI bit. Do you think it's interesting that MicroQuickJS can be used from Python via FFI or as a compiled module, and can also be compiled to WebAssembly and called from Node.js and Deno and from Pyodide running in a browser?

... and that it provides a useful sandbox in that you can robustly limit both the memory and time allowed, including limiting expensive regular expression evaluation?

I included the AI bit because it would have been dishonest not to disclose how I used AI to figure this all out.

alabhyajindal • 2 months ago

TheTaytay • 2 months ago

Tangential would be “I wrote a Fibonacci function in this and it worked, just like it said on the tin!”

Compiling this to wasm and calling it from python as a sandboxed runtime isn’t tangential. I wouldn’t have know from reading the project’s readme that this was possible, and it’s a really interesting use case. We might as well get mad at simonw for using an IDE while he explored the limits of a new library.

keeganpoppen • 2 months ago

but there is signal in what people are inspired to do upon seeing a new project-- why not simply evaluate the interestingness level of these sorts of mashups on their own terms? it actually feels very "hacker"-y to go out and show people possibilities like this. i have no particular comment on how "interesting" the derivative projects are in this case, but i have a feeling if his original post had been framed more like "i think it's super interesting how easy it is to use via FFI on various runtimes X & Y (oh btw in the spirit of full transparency: i used ai to help me. and you can see more details at <link>). especially because i think everyone who peruses HN with some regularity is likely to know of simon's work in at least some capacity, and i am-- speaking only for myself-- essentially always interested in any sort of project he embarks on, especially his llm-assisted experiments and stuff. but hey-- at the end of the day, all of this value judgment is realized as plainly as possible with +1 / -1 (up- and down-vote) and i guess it just is what it is. if number bad, HN no like. shrug.

Imustaskforhelp • 2 months ago

Offtopic but I went to your website and saw that you created hackernews-mute and recently I was commenting about how one must have created such an extension and ranted about it. So kudos for you to have created it earlier on.

Maybe we HN users have minds in sync :)

https://news.ycombinator.com/item?id=46359396#46359695

Have a nice day! Awesome stuff, would keep an eye on your blog, Does your blog/website use mataroa by any chance as there are some similarities even if they are both minimalist but overall nice!

rpdillon • 2 months ago

Software system is released, comments talk about how to integrate it with other software systems. Seems on-topic.

eichin • 2 months ago

Imustaskforhelp • 2 months ago

Simon although I find it interesting. And I respect you in this field. I still feel like the reason people call out AI usage or downvote in this case is that in my honest opinion, it would be also more interesting to see people actually write the code and more so (maintain) it as well and create a whole community/github project around microquickjs wasm itself

I read this post of yours https://simonwillison.net/2025/Dec/18/code-proven-to-work/ and although there is a point that can be made that what you are doing isn't a job and I myself create prototypes of code using AI, long term (in my opinion) what really matters are the maintainance and claim (like your article says in a way, that I can pin point a person whose responsible for code to work)

If I find any bug right now, I wouldn't blame it on you but AI and I have varying amount of trust on it

My opinion on the matter is that for prototyping AI can be considered good use but long term it definitely isn't and I am sure that you share a similar viewpoint.

I think that AI is so contrasting that there stops existing any nuance. Read my recent comment (although warning, its long) (https://news.ycombinator.com/item?id=46359684)

Perhaps you can build a blog post about the nuance of AI? I imagine that a lot of people might share a similar aspect of AI policy where its okay to tinker with it. I am part of the new generation and trust be told I don't think that there becomes much incentives long term unless someone realizes things of not using AI because using AI just feels so lucrative for especially the youngsters.

I am 17 years old and I am going to go into a decent college with (might I add immense competition to begin with) when I have passion about such topics but only to get dissuaded because the benchmark of solving assignments etc. are done by AI and the signal ratio of universities themselves are reducing but they haven't reduced to the point that they are irrelevant but rather that you need to have a university to try to get a job but companies have either freezed hiring which some point out with LLM's

If you ask me, Long term to me it feels like more people might associate themselves with hobbyist computing and even using AI (to be honest sort of like pewdiepie) without being in the industry.

I am not sure what the future holds for me (or for any of us as a matter of fact) but I guess the point I am trying to state is that there is nuance to the discussion from both sides

Have a nice day!

jmull • 1 month ago

I don't know why people are downvoting your comment, but it could be considered a low-effort post: here's (a link to) something I prompted AI with, here's (a link to) what it produced (the whole repo).

I would guess people don't know how you expect them to evaluate this, so it comes off as spamming us with a bunch of AI slop.

(That C can be compiled to WASM or wrapped as a python library isn't really something that needs a proof-of-concept, so again it could be understood as an excuse to spam us with AI slop.)

halfmatthalfcat • 2 months ago

I downvoted because I'm tired of people regurgitating how they've done this or that with whatever LLM of the week on seemingly every technical post.

If you care that much, write a blog post and post that, we don't need low effort LLM show and tell all day everyday.

simonw • 2 months ago

Here you go: https://simonwillison.net/2025/Dec/23/microquickjs/

halfmatthalfcat • 2 months ago

lioeters • 2 months ago

I love it, I find the note interesting, educational, and adds to the discussion in context. Guess you're bound to get a few haters when you share your work in public, but I for one appreciate all your posts, comments, articles, open-source projects.

alex_suzuki • 2 months ago

I think the people interacting with this post are just more likely to appreciate the raw craftsmanship and talent of an individual like Bellard, and coincidentally might be more critical of the machinery that in their perception devalues it. I count myself among them, but didn’t downvote, as I generally think your content is of high quality.

garganzol • 2 months ago

Thank you for sharing.

A lot of HN people got cut by AI in one way or another, so they seem to have personal beefs with AI. I am talking about not only job shortages but also general humbling of the bloated egos.

foobarchu • 2 months ago

> I am talking about not only job shortages but also general humbling of the bloated egos.

I'm gonna give you the benefit for the doubt here. Most of us do not dislike genAI because we were fired or "humbled". Most of us dislike it because a) the terrible environmental impacts, b) the terrible economic impacts, and c) the general non-production-readiness of results once you get past common, well-solved problems

Your stated understanding comes off a little bit like "they just don't like it because they're jealous".

wartywhoa23 • 2 months ago

I'm constanly encountering this "bloated ego" argument every time the narrative is being steered away to prevent monetary losses for AI companies.

Especially so when it concerns AI theft of human music and visual art.

"Those pompous artists, who do they think they are? We'll rob them of their egos".

The problem is that these ego-accusations don't quite come from egoless entities.

garganzol • 2 months ago

yeasku • 2 months ago

Because it adds nothing to the conversation. Im

johnfn • 1 month ago

How does executing MicroQuickJS from Python not have anything to do with MicroQuickJS?

johnfn • 1 month ago

I appreciate all your work and I did not downvote you. One suggestion, though, is that the README looks very AI generated, which makes the project feel low effort, like you just said “hey Claude do a security analysis of this package”. I don’t think this is actually what you did, but it’s hard to know. It’s also very difficult to identify the highlights. Just a few handwritten sentences would be better.

simonw • 1 month ago

The README is indeed AI generated, as is everything else in that simonw/research repository - it's my public demo of the asynchronous research process I use.

simonw • 1 month ago

(I'm going to add disclaimers to the top of every one of those posts, currently you have to navigate to the report homepage to find that out.)

Update - added that here: https://github.com/simonw/research/pull/53

petercooper • 2 months ago

Your tireless experimenting (and especially documenting) is valuable and I love to see all of it. The avant garde nature of your recent work will draw the occasional flurry of disdain from more jaded types, but I doubt many HN regulars would think you had anything but good intentions! Guess I am basically just saying.. keep it up.

SeanAnderson • 2 months ago

I didn't downvote you. You're one of "the AI guys" to me on HN. The content of your post is fine, too, but, even if it was sketch, I'd've given you the benefit of the doubt.

dangoodmanUT • 2 months ago

I appreciated it. I have no idea why someone would downvote it other than spite

TheTaytay • 2 months ago

I was hoping you experimented with this! I am right there with you, hoping for an easier wasm sandbox for LLMs.

(Keep posting please. Downvotes due to mentioning LLMs will be perceived as a quaint historic artifact in the not so distant future…)

wartywhoa23 • 2 months ago

On the contrary, it's pretty possible that LLMs themselves will be perceied as a quaint historic artefact and join the ranks of mechanical turks, zeppelins, segways, google glasses and blockchains.

johnfn • 1 month ago

If you can operationalize this I’ll happily take a bet against this, and offer you great odds.

TeodorDyakov • 2 months ago

That is extremely unlikely.

MobiusHorizons • 2 months ago

What is the purpose of compiling this to web assembly? What web assembly runtimes are there where there is not already an easily accessible (substantially faster) js execution environment? I know wasmtime exists and is not tied to a js execution engine like basically every other web assembly implementation, but the uses of wasmtime are not restricted from dependencies like v8 or jsc. Usually web assembly is used for providing sandboxing something a js execution environment is already designed to provide, and is only used when the code that requires sandboxing is native code not javascript. It sounds like a good way to waste a lot of performance for some additional sandboxing, but I can't imagine why you would ever design a system that way if you could choose a different (already available and higher performance) sandbox.

simonw • 2 months ago

I want to build features - both client- and server-side - where users can provide JavaScript code that I then execute safely.

Just having a WebAssembly engine available isn't enough for this - something has to take that user-provided string of JavaScript and execute it within a safe sandbox.

Generally that means you need a JavaScript interpreter that has itself been compiled to WebAssembly. I've experimented with QuickJS itself for that in the past - demo here: https://tools.simonwillison.net/quickjs - but MicroQuickJS may be interesting as a smaller alternative.

If there's a better option than that I'd love to hear about it!

santadays • 2 months ago

GraalVM supports running javascript in a sandbox with a bunch of convenient options for running untrusted code.

https://www.graalvm.org/latest/security-guide/sandboxing/

simonw • 1 month ago

Oh that looks neat! It appears to have the memory limits I want (engine.MaxIsolateMemory) and a robust CPU limit: sandbox.MaxCPUTime

One catch: the sandboxing feature isn't in the "community edition", so only available under the non-open-source (but still sometimes free, I think?) Oracle GraalVM.

MobiusHorizons • 2 months ago

This is generally the purpose of JavaScript execution environments like v8 or jsc (or quickjs although I understand not trusting that as a sandbox to the same degree). They are specifically intended for executing untrusted scripts (eg web browsers). Web assembly’s sandboxing comes from js sandboxing, since it was originally a feature of the same programs for the same reasons. Wrapping one sandbox in another is what I’m surprised by.

simonw • 2 months ago

kettlecorn • 2 months ago

As I noted in another comment Figma has used QuickJS to run JS inside Wasm ever since a security vulnerability was discovered in their previous implementation.

In a browser environment it's much easier to sandbox Wasm successfully than to sandbox JS.

MobiusHorizons • 2 months ago

That’s very interesting! Have they documented the reasoning for that approach? I would have expected iframes to be both simpler and faster sandboxing mechanism especially in compute bound cases. Maybe the communication overhead is too high in their workload?

EDIT: found this from your other comment: https://www.figma.com/blog/an-update-on-plugin-security/ they do not address any alternatives considered.

miki123211 • 1 month ago

Since you're here and this is likely to become professionally relevant for me pretty soon, what is the best way you know of for securely running Python inside Python?

I was looking for something like Pyodide but runnable from Python, but that doesn't seem to exist quite yet. I can get a Python interpreter to run in wasmtime, but that doesn't have the Pyodide goodies like Micropip etc. Sadly, Pyodide itself seems fully married to JS, as it compiles to Emscripten and not WASI.

I'm almost tempted to just go with a small binary embedding V8 and running Pyodide inside V8 isolates or something.

(I know I can do this via Firecracker / GVisor / whatever, that is not the solution I'm looking for.)

zellyn • 1 month ago

I’m horribly biased but I think it’s a combination of: (1) knee-jerk reaction to similar-looking but low-value comments, and (2) most people not having played around with LLM coding agents and messed around with their own agents enough to immediately jump to excitement at simple, safe sandboxing primitives for that purpose.

And +1000 on linking to your own (or any other well-written) blog.

incognito124 • 2 months ago

You should take a look at https://judge0.com/

sublimefire • 2 months ago

Look at how others implement quickjs and restrict its runtime for sensitive workloads [1], should be similar.

But there are other ways, e.g. run the logic isolated within gvisor/firecracker/kata.

[1] github.com/microsoft/CCF under src/js/core

strbean • 1 month ago

Curious if you have a specific use case for sandboxed JS that you would share?

simonw • 1 month ago

I want to build software features where users can configure some additional JavaScript to run in order to customize that software.

One example: given this database table run this JavaScript function against every value in this column to calculate a value to be stored in another column.

Or once a day fetch the JSON from this URL and transform it with this JavaScript and store it here.

steren • 1 month ago

Check out this sample of using gVisor to spin up code sandboxes (potentially running on Cloud Run): https://github.com/GoogleCloudPlatform/cloud-run-sandbox

pizlonator • 2 months ago

This engine restricts JS in all of the ways I wished I could restrict the language back when I was working on JSC.

You can’t restrict JS that way on the web because of compatibility. But I totally buy that restricting it this way for embedded systems will result in something that sparks joy

groundzeros2015 • 2 months ago

He already has a JS engine which doesn’t make these restrictions

pizlonator • 2 months ago

Yeah QuickJS is great.

I bet MQJS will also be very popular. Quite impressive that bro is going to have two JS engines to brag about in addition to a lot of other very useful things!

alexdowad • 2 months ago

> Quite impressive...

Yes, quite! Monsieur Bellard is a legend of computer programming. It would be hard to think of another programmer whose body of public work is more impressive than FB.

Unfortunate that he doesn't seem to write publicly about how he thinks about software. I've never seen him as a guest on any podcast either.

I have long wondered who the "Charlie Gordon" who seems to collaborate with him on everything is. Googling the name brings up a young ballet dancer from England, but I doubt that's the person in question.

rramadass • 2 months ago

Uehreka • 2 months ago

virtualwhys • 2 months ago

It would be odd, but that name does ring a bell, Charlie Gordon is the central character in the ever poignant, Flowers for Algernon.

Maybe Bellard identifies with the genius, but fears the loss of it.

larodi • 2 months ago

He totally deserves this ACM award which still waits to be awarded.

dotandimet • 1 month ago

In the QuickJS github repo there are commits from Charlie Gordon's github profile, https://github.com/chqrlie

andai • 2 months ago

> You can’t restrict JS that way on the web because of compatibility.

Well, now we can run this thing in WASM and get, I imagine, sane runtime errors :)

jacobp100 • 2 months ago

Since you’re on the topic, what ever happened to the multi threading stuff you were doing on JSC? Did it stop when you left Apple? Is the code still in JSC or did it get taken out?

pizlonator • 2 months ago

I never really started on it other than writing up how to do it

achierius • 2 months ago

Which multi-threading are you talking about?

sophiebits • 1 month ago

https://webkit.org/blog/7846/concurrent-javascript-it-can-wo...

simonw • 2 months ago

If anyone wants to try out MicroQuickJS in a browser here's a simple playground interface for executing a WebAssembly compiled version of it: https://tools.simonwillison.net/microquickjs

It's a variant of my QuickJS playground here: https://tools.simonwillison.net/quickjs

The QuickJS page loads 2.28 MB (675 KB transferred). The MicroQuickJS one loads 303 KB (120 KB transferred).

azakai • 2 months ago

Looks like those sizes could be improved significantly, as the builds include names etc. I would suggest linking with

emcc -O3

(and maybe even adding --closure 1 )

edit: actually the QuickJS playground looks already optimized - just the MicroQuickJS one could be improved.

simonw • 2 months ago

Nice. Got it down from 229KB to 148KB! Thanks for the tips.

https://github.com/simonw/research/pull/5

Thats now live on https://tools.simonwillison.net/microquickjs

julenx • 2 months ago

Thanks for sharing! The link to the PR looks like a wrong paste. I found https://github.com/simonw/tools/pull/181 which seems to be what was intended to be shared instead.

kamranjon • 2 months ago

I was interested to try Date.now() since this is mentioned as being the only part of the Date implementation that is supported but was surprised to find it always returns 0 for your microquickjs version - your quickjs variant appears to return the current unix time.

simonw • 2 months ago

Good catch. WebAssembly doesn't have access to the current time unless the JavaScript host provides it through injecting a function, so the WASM build would need to be hooked up specially to support that.

xigoi • 1 month ago

At last, I can run JavaScript in my browser. The world is now complete.

throwaway290 • 2 months ago

The most important thing about any new JS runtime in 2025, how do I use it from JS? /s

ea016 • 2 months ago

Well, as Jeff Atwood famously said [0], "any application that can be written in JavaScript, will eventually be written in JavaScript". I guess that applies to embedded systems too

[0] https://en.wikipedia.org/wiki/Jeff_Atwood

arendtio • 2 months ago

Well, wasn't Fabrice Bellard the guy who built a virtual machine with JS so that you could run Linux within the browser?

https://bellard.org/jslinux/vm.html?cpu=riscv64&url=fedora33...

tombert • 2 months ago

Fabrice is an absolute legend. Most people would be content with just making QEMU, but this guy makes TinyC and FFmpeg and QuickJS and MicroQuickJS and a bunch of other huge projects.

I am envious that I will never anywhere near his level of productivity.

avaer • 2 months ago

Not to detract from his status as a legend, but I think the kind of person that singlehandedly makes one of these projects is exactly the kind of person that would make the others.

I forgot about FFmpeg (thanks for the reminder), but my first thought was "yup that makes perfect sense".

tombert • 2 months ago

Sure, they're not unrelated or anything, but at the same time, they're all really important, huge projects.

umvi • 2 months ago

Not just programming either; he invented a mathematical technique for calculating the nth hex digit of pi

keepamovin • 2 months ago

I know it's not true, but it would be funny if Bellard had access to AI for 15 years (time-traveler, independent invention, classified researcher) and that was the cause of his superhuman producitvity.

AI will let 10,000 Bellards bloom - or more.

kzrdude • 2 months ago

And thanks to that we can run Linux in a PDF as well..

anthk • 2 months ago

And FFMPEG, the standard codec suite for Unix today. And Qemu, the core of KVM. Plus TCC, a great small compiler compared to C/Clang altough cparser has better C99 coverage. Oh, and some DVB transmitter reusing the MHZ radiation from a computer screen by tweaking the Vidtune values from X. It's similar to what Tempest for Eliza does.

underdeserver • 2 months ago

Indeed

https://www.destroyallsoftware.com/talks/the-birth-and-death...

tacone • 2 months ago

Sounds a bit like rule 35 of the Internet.

vitaminCPP • 1 month ago

Please don't use js in medical devices.

achenet • 1 month ago

attempt at humor:Okay so, would you rather your beloved great aunt's pacemaker fail because the software in it was written in C, and there's a use-after-free memory error, or because the software in it was written in JavaScript, and because someone used `==` instead of `===` a boolean that should have been `false` is `true`?

timschumi • 2 months ago

It's unfortunate that he uploaded this without notable commit history, it would be interesting to see how long it takes a programmer of his caliber to bring up a project like this.

That said, judging by the license file this was based on QuickJS anyway, making it a moot comparison.

k4rli • 2 months ago

It does say "public repository of..." implying there's a non-public one with real history. Not sure why not upload the main one though.

zarzavat • 2 months ago

If he's anything like me (doubtful but roll with it), the commit history when prototyping is probably something like "commit", "commit", "fixed a bug", etc.

incognito124 • 2 months ago

Maybe he just oneshotted it

agumonkey • 2 months ago

Maybe claude code uses bellard as agent

MisterTea • 2 months ago

Claude is really Bellard sitting in his kitchen, sipping coffee, casually replying to code requests while getting ready for his day.

christophilus • 2 months ago

This explains a lot. Opus 4.5 gives you access to Bellard after his second cup of coffee.

deafpolygon • 2 months ago

oblio • 2 months ago

A sort of reverse code golf where he doesn't care what he sends as all that code will never touch his prod code bases.

saagarjha • 2 months ago

I’d expect much better results, honestly

khazhoux • 2 months ago

"You're right! I apologize for the confusion. I am, in fact, Fabrice Bellard. Comment allez-vous?"

ale • 2 months ago

It's Fabrice so there's a chance he did

foresto • 2 months ago

I wonder if this could become the most lightweight way for yt-dlp to solve YouTube Javascript challenges.

https://github.com/yt-dlp/yt-dlp/wiki/EJS

(Note that Bellard's QuickJS is already a supported option.)

qbane • 2 months ago

Not likely:

> It only supports a subset of Javascript close to ES5 [...]

I have not read the code of the solver, but solving YouTube's JS challenge is so demanding that the team behind yt-dlp ditched their JS emulator written in Python.

AndyKelley • 2 months ago

That's a great idea, but if they did, then YouTube could retaliate by specifically using features that MicroQuickJS does not support.

foresto • 2 months ago

Of course... The arms race is eternal. :)

leptons • 2 months ago

There's no reason it has to be lightweight, what it has to do is solve Youtube challenges without workarounds due to limited Javascript syntax.

silverwind • 2 months ago

Likely not, given that it only implements ES5.

polyrand • 1 month ago

Not sure about the impact of these, I guess it depends on the context where this engine is used. But there seems to be already exploits for the engine:

https://x.com/itszn13/status/2003707921679679563

https://x.com/itszn13/status/2003808443761938602

MattGrommes • 2 months ago

I'm not an embedded systems guy (besides using esp32 boards) so this might be a dumb question but does something like this open up the possibility of programming an esp32/arduino board with Javascript, like Micro/Circuit Python?

halfmatthalfcat • 2 months ago

There are already libraries/frameworks that have supported this:

* espruino (https://www.espruino.com/)

* elk (https://github.com/cesanta/elk)

* DeviceScript (Microsoft Research's now defunct effort, https://github.com/microsoft/devicescript)

niutech • 1 month ago

And also Duktape (https://duktape.org)

cxr • 2 months ago

That's been possible with Moddable/Kinoma's XS engine, which is standards compliant with ES6 and beyond.

<https://www.moddable.com/faq#comparison>

If you take a look at the MicroQuickJS README, you can see that it's not a full implementation of even ES5, and it's incompatible in several ways.

Just being able to run JS also isn't going to automatically give you any bindings for the environment.

hebejebelus • 2 months ago

Sort of related: About ten years ago there was a device called the Tessel by Technical Machine which you programmed with Javascript, npm, the whole nine yards. It was pretty clever - the javascript got transpiled to Lua VM bytecode and ran in the Lua VM on the device (a Cortex M3 I believe). I recently had Claude rewrite their old Node 0.8 CLI tools in Rust because I wasn't inclined to do the javascript archeology needed to get the old tools up and running. Of course then I put the Tessel back in its drawer, but fun nonetheless.

niutech • 1 month ago

There are still Espruino JS devices.

matt_trentini • 1 month ago

It's a good _start_; much more code needs to be written to allow control of the hardware of those devices (GPIO, I2C etc).

15155 • 2 months ago

Yes. The key enabling feature is a lack of malloc()

keepamovin • 1 month ago

Fabrice, Mr Bellard, O Indefatigable One, if you are reading this, I would love for you to make a JavaScript that compiles to assembly and works across Windows PE, macOS and Linux. Surrendering the various efficiencies of the V8 JIT bytecode in favor of AOT is entirely acceptable for the concision, speed and the chance to "begin again" that this affords. In fact, I believe you may already be working on such an idea! If you are not (highly doubtful) I encourage you to ponder it, and if we are so lucky and the universe wills it, you shall turn the hand of your incomparable craftsmanship upon this worthy goal, and doubtless such a magnificent creation shall be realized by you in a surprisingly short amount of time!

nektro • 1 month ago

you might be interested in the future of https://porffor.dev/

keepamovin • 1 month ago

Oh, this is excellent! I'm so happy with this. This is EXCELLENT! and what a beautiful website. Is this your project?

So cool. Where did the name come from? I am so stoked and glad that we are going to have a JS to native binary compiler. The best thing ever!

I was going to set up an AI automation to run on this against the autotests, but as I got started, I felt - why not just create a new language where I can pick my own concurrency paradigms and syntax? So I went with that instead.

So glad someone is doing this. What more do you know about this proejct, kind person?

aapoalas • 1 month ago

This is Oliver Medhurst' project: https://goose.icu/

It has stable funding and a full-time development team of 1.

bmc7505 • 2 months ago

Interesting. I wonder if mqjs would make it feasible to massively parallelize JavaScript on the GPU. I’m looking for a way to run thousands of simultaneous JS interpreters, each with an isolated heap and some shared memory. There are some research projects [1, 2] in this direction, but they are fairly experimental.

[1]: https://github.com/SamGinzburg/VectorVisor

[2]: https://github.com/beehive-lab/ProtonVM

conoro • 1 month ago

As a long-time Espruino user I was immediately interested.

At first glance Espruino has broader coverage including quite a bit of ES6 and even up to parts of ES2020. (https://www.espruino.com/Features). And obviously has a ton of libraries and support for a wide range of hardware.

For a laugh, and to further annoy the people annoyed by @simonw's experiments, I got Cursor to butcher it and run as a REPL on an ESP32-S3 over USB-Serial using ESP-IDF.

Blink is now running so my work here is done :-)

  led.init(48)
  
  function blink() {
    led.rgb(0, 0, 255)
    setTimeout(function() {
      led.off();
      setTimeout(blink, 500)
    }, 500)
  }
  blink()

chunkles • 2 months ago

Timing really is everything for making the frontpage, I posted this last night and it got no traction.

self_awareness • 2 months ago

Some other guy tried it as well after you, also no luck.

One strategy is to wait for US to wake up, then post, during their morning.

Other strategy is to post the same thing periodically until there is response.

Wowfunhappy • 2 months ago

I suspect it's just random luck, not timing.

Reubend • 2 months ago

When reading through the projects list of JS restrictions for "stricter" mode, I was expecting to see that it would limit many different JS concepts. But in fact none of the things which are impossible in this subset are things I would do in the course of normal programming anyway. I think all of the JS code I've written over the past few years would work out of the box here.

MobiusHorizons • 2 months ago

I was surprised by this one that only showed up lower in the document:

- Date: only Date.now() is supported. [0]

I certainly understand not shipping the js date library especially in an embedded environment both for code-size, and practicality reasons (it's not a great date library), but that would be an issue in many projects (even if you don't use it, libraries yo use almost certainly do.

https://github.com/bellard/mquickjs/blob/main/README.md#:~:t...

Reubend • 2 months ago

Good catch. I didn't realize that there was a longer list of restrictions below the section called "Stricter mode", and it seems like a lot of String functions I use are missing too.

MobiusHorizons • 2 months ago

> String functions: codePointAt, replaceAll, trimStart, trimEnd.

As I read it, these are supported es5 extensions, not missing as part of stricter mode.

ddtaylor • 2 months ago

Fabrice Bellard is widely considered one of the most productive and versatile programmers alive:

- FFmpeg: https://bellard.org

- QEMU: https://bellard.org/qemu/

- JSLinux: https://bellard.org/jslinux/

- TCC: https://bellard.org/tcc/

- QuickJS: https://bellard.org/quickjs/

Legendary.

groundzeros2015 • 2 months ago

For all the praise he gets here, few seem interested in his methods: writing complete programs, based on robust computer science, with minimal dependencies and tooling.

drschwabe • 2 months ago

When I first read the source for his original QuickJS implementation I was amazed to discover he created the entirety of JavaScript in a single xxx thousand line C file (more or less).

That was a sort of defining moment in my personal coding; a lot of my websites and apps are now single file source wherever possible/practical.

kvemkon • 2 months ago

SQLite 3.51.1

  $ wc -l ...
  265908 sqlite-amalgamation-3510100/sqlite3.c

Is there any as large as possible single source (or normal with amalgamation version) more or less meaningful project that could be compiled directly with rustc -o executable src.rs? Just to compare build time / memory consumption.

nine_k • 2 months ago

The sqlite3.c file is generated from more finely-grained real sources, see https://www.sqlite.org/src/doc/trunk/README.md

qznc • 2 months ago

zdragnar • 2 months ago

I honestly think the single file thing is best reserved for C, given how bad the language support for modularity is.

I've had the inverse experience dealing with a many thousand line "core.php" file way back in the day helping debug an expressionengine site (back in the php 5.2ish days) and it was awful.

Unless you have an editor which can create short links in a hierarchical tree from semantic comments to let you organize your thoughts, digging through thousands of lines of code all in the same scope can be exceptionally painful.

antirez • 2 months ago

sfpotter • 2 months ago

C's support for modularity is actually rather strong. This PDF gives a good overview of the basic techniques available: http://www.metamodulaire.org/Computing/modular-c.pdf

It may not be immediately obvious how to approach modularity since it isn't directly accomplished by explicit language features. But, once you know what you're doing, it's possible to write very large programs with good encapsulation, that span many files, and which nevertheless compile quite rapidly (more or less instantaneously for an incremental build).

I'm not saying other languages don't have better modularity, but to say that C's is bad misses the mark.

drschwabe • 2 months ago

Unironically JavaScript is quite good for single file projects (albeit a package.json usually needed)

You can do a huge website entirely in a single file with NodeJS; you can stick re-usable templates in vars and absue multi-line strings (template literals) for all your various content and markup. If you get crafty you can embed clientside code in your 'server.js' too or take it to the next level and use C++ multi-line string literals to wrap all your JS ie- client.js, server.js and package.json in a single .cpp file

lelanthran • 2 months ago

> I honestly think the single file thing is best reserved for C, given how bad the language support for modularity is.

You don't program much in C, do you?

pjc50 • 2 months ago

This is like Feynman's method for solving hard scientific problems: write down the question, think very hard, write down the answer.

It doesn't necessarily translate to people who are less brilliant.

chrisweekly • 2 months ago

Yeah, "Step 1: draw 2 circles. Step 2: draw the rest of the fucking owl"

nxobject • 2 months ago

I agree: he loves to "roll your own" a lot. Re: minimal dependencies - the codebase has a software FP implementation including printing and parsing, and some home-rolled math routines for trigonometric and other transcendental functions.

Honestly, it's a reminder that, for the time it takes, it's incredibly fun to build from scratch and understand through-and-through your own system.

Although you have to take detours from, say, writing a bytecode VM, to writing FP printing and parsing routines...

benterix • 2 months ago

Because he choose the hardest path. Difficult problems, no shortcuts, ambitious, taking time to complete. Our environment in general is the opposite of that.

groundzeros2015 • 2 months ago

We spend a lot of time doing busy work that's part of the process but doesn't actually move the needle. We write a lot of code that manages abstractions, but doesn't do a lot. All of this busy work feels like progress, but it's avoiding the hard work of actually writing working code.

We underestimate how inefficient working in teams is compared with individuals. We don't value skill and experience and how someone who understands a problem well can be orders of magnitude more productive.

rramadass • 2 months ago

> few seem interested in his methods:

You are absolutely wrong here. Most of us wish that somebody would get him to sit for an in-depth interview and/or get him to write a book on his thinking, problem-solving approach, advice etc. i.e. "we want to pick his brain".

But he is not interested and seems to live on a different plane :-(

noufalibrahim • 2 months ago

He's one of my programming heroes but that's based purely on the sheer volume of high quality output he has.

Can you elaborate a little about the methods you mention and how you analysed them?

groundzeros2015 • 1 month ago

Sure. You’ll notice no libraries, no CI, no issue tracker, written in C, no landing page, no dashboard.

So much of the discussion here is about professional practice around software. You can become an expert in this stuff without actually ever learning to write code. We need to remember that most of these tools are a cost that only benefits for managing collaboration between teams. The smaller the team the less stuff you need.

I also have insights from reading his C style but they may be of less interest.

I think it’s also impressive that he identifies a big and interesting problem to go after that’s usually impactful.

noufalibrahim • 1 month ago

Thanks for this. I'd appreciate your insights about his C style as well. I'm a lapsed C programmer myself.

simonw • 2 months ago

He's also built a closed-source LLM inference engine, which he's been maintaining since the GPT-2 days: https://bellard.org/ts_server/ and https://textsynth.com/

ronsor • 2 months ago

I used to play around with Textsynth, but not being OSS killed the appeal for me once llama.cpp came around.

brabel • 2 months ago

I thought Bellard might be behind even llama.cpp (that would be completely expected for Bellard) but it's actually another great who's done that: Georgi Gerganov: https://github.com/ggerganov

rasz • 2 months ago

Funny how people know Fabrice for all the software stuff but none of the hardware antics:

played with implementing analog modem DSP in software in 1999 (linmodem is ~50-80% there, sadly never finished)

probably leading to

played with implementing SDR (again DSP) using VGA output to transmit DVB-T/NTSC/PAL in 2005

probably leading to

Amarisoft SDR 5G base station, commercial product started in 2012 - his current job https://www.amarisoft.com/company/about-us

userbinator • 2 months ago

I was going to mention the last one, and his ASN.1 compiler which is likely related to his telco work:

https://bellard.org/ffasn1/

cryptonector • 2 months ago

As a maintainer of an ASN.1 compiler, I think his ASN.1 compiler must be quite awesome (it's not open source), and it's brilliant of him to make it proprietary. I bet he makes good money from it.

mightybyte • 2 months ago

He's also won the International Obfuscated C Code Contest 3 times.

https://www.ioccc.org/authors.html#Fabrice_Bellard

justmarc • 2 months ago

Don't forget his LZEXE from the good old DOS days which was an excellent piece of work at the time.

lioeters • 2 months ago

I remember LZEXE from those olden days. When I discovered the author of FFmpeg and QEMU also created LZEXE, I was so impressed. I've been using his software for my entire computing career.

It's similar to the respect I have for the work of Anders Hejlsberg, who created Turbo Pascal, with which I learned to program; and also C# and TypeScript.

sedatk • 2 months ago

Self-decompressing executables felt like magic to me at the time. Fantastic work, overall.

phatskat • 1 month ago

Reading about APE similarly sparkled me - the amount of ingenuity and sheer amazingness (if not perhaps a touch of depravity) that goes into these kinds of endeavors is awe inspiring.

PaulDavisThe1st • 2 months ago

Always interesting when people as talented as Bellard manage to (apparently) never write a "full-on" GUI-fronted application, or more specifically, a program that sits between a user with constantly shifting goals and workflows and a "core" that can get the job done.

I would not want to dismiss or diminish by any amount the incredible work he has done. It's just interesting to me that the problems he appears to pick generally take the form of "user sets up the parameters, the program runs to completion".

fullstackchris • 2 months ago

Reading some of these comments, it's clear very few in here have ever written a productive customer facing full stack app "javascript is really good for a single file app!!!" ok, maybe if you're rendering static HTML... -> these are not serious people

tracker1 • 1 month ago

FWIW, most of my shell scripting these days is Deno+TS...

MontyCarloHall • 2 months ago

Whenever someone says there's no such thing as a 10x programmer, I point them to Fabrice and they usually change their mind.

zipy124 • 2 months ago

People only deny the existence of such people based on their own ego, believing that no one could possibly be worth 10x more or produce 10x more than they can. Those who have seen those people know full well these people exist.

It's kind of crazy it ever became some accepted world view, given how every field has a 10xer that is rather famous for it, whether it be someone who dominates in sport, an academic like Paul Erdős or Euler, a programmer like Fabrice or Linus Torvalds, a leader like Napoleon , or any number of famous inventors throughout history.

rossant • 2 months ago

Perhaps closer to 100x actually.

attractivechaos • 2 months ago

You can call 1000 averaged programmers and see if they can write MicroQuickJS using the same amount of time, or call one averaged programmer and see if he/she can write MicroQuickJS to the same quality in his/her life time. 10X, 100X or 1000X measures the productivity of us mortals, not someone like Fabrice Bellard.

thechao • 2 months ago

If you're in a room with 100 physicists and Feynman, the accumulated wisdom of Feynman is your best bet.

vatsachak • 2 months ago

Don't forget his LLM based text compression software that won awards.

Guy is a genius. I hope he tries Rust someday

elevation • 2 months ago

Fabrice, if you're reading this, please consider replacing Rust instead with your own memory safe language.

The design intent of Rust is a powerful idea, and Rust is the best of its class, but the language itself is under-specified[1] which prevents basic, provably-correct optimizations[0]. At a technical level, Rust could be amended to address these problems, but at a social level, there are now too many people who can block the change, and there's a growing body of backwards compatibility to preserve. This leads reasonable people to give up on Rust and use something else[0], which compounds situations like [2] where projects that need it drop it because it's hard to find people to work on it.

Having written low-level high-performance programs, Fabrice Bellard has the experience to write a memory safe language that allows hardware control. And he has the faculties to assess design changes without tying them up in committee. I covet his attentions in this space.

[0]: https://databento.com/blog/why-we-didnt-rewrite-our-feed-han...

[1]: https://blog.polybdenum.com/2024/06/07/the-inconceivable-typ...

[2]: https://daniel.haxx.se/blog/2024/12/21/dropping-hyper/

Lerc • 2 months ago

I think of Rust might trigger a new generation of languages that are developed with the hindsight of rust.

The principle of zero cost abstractions avoids a slow slide of compromising abstraction cost, but I think there could be small cost abstractions that would make for a more pragmatic language. Having Rust to point at to show what performance you could be achieving would aid in avoiding bloating abstractions.

userbinator • 2 months ago

Bellard likely doesn't care one bit about memory safety or whatever other trendy things are popular these days.

saagarjha • 2 months ago

> At a technical level, Rust could be amended to address these problems

I don’t think it can, no.

imiric • 2 months ago

[dead]

d4rkp4ttern • 1 month ago

Link please?

seg_lol • 1 month ago

https://bellard.org/nncp/ https://bellard.org/ts_zip/

See also

FineZip : Pushing the Limits of Large Language Models for Practical Lossless Text Compression https://arxiv.org/abs/2409.17141v1

Using a LLM to compress text (o565.com) https://news.ycombinator.com/item?id=40245261

https://searchthearxiv.com/?q=llm%20text%20compression&tab=p...

d4rkp4ttern • 1 month ago

Thanks!

hsaliak • 2 months ago

peak hacker news comment lol

vatsachak • 2 months ago

I've only been here for a month. I guess I'm learning well

encom • 2 months ago

For all the praise he's receiving, I think his web design skills have gone overlooked. bellard.org is fast, responsive and presents information clearly. Actually I think the fancier the website, the shittier the software. Examples: Tarsnap - minimal website, brilliant software. Discord - Whitespacey, animation-heavy abomination of a website. Software: hundreds of MB of JS slop, government wiretap+botnet for degenerates.

The math checks out.

kallistisoft • 2 months ago

At this point I'm convinced that they're not a 'real person' and the 'Fabrice' is an operational code name for a very mature hacker collective.

Real people have to sleep at some point!

xgkickt • 2 months ago

Wikipedia doesn't list any honours awarded by the French Government. Nor do I see anything from ACM. Definitely overdue some official recognition.

bborud • 2 months ago

And that’s just his open source work.

didip • 2 months ago

For real. The GOAT is at it again!

c0brac0bra • 2 months ago

The first two links are broken.

ddtaylor • 2 months ago

The ffmpeg link was changed apparently, but the QEmu link still works he just redirects to the QEmu homepage.

mobilio • 1 month ago

and LZEXE

aapoalas • 2 months ago

As a fellow (but way junior) JavaScript engine developer I'm really happy to see the stricter mode, and especially Arrays being dense while Objects don't treat indexed properties specially at all: it is my opinion that this is where we should drive JavaScript towards, slow and careful though it may be.

In my engine Arrays are always dense from a memory perspective and Objects don't special case indexes, so we're on the same page in that sense. I haven't gotten around to creating the "no holes" version of Array semantics yet, and now that we have an existing version of it I believe I'll fully copy out Bellard's semantics: I personally mildly disagree with throwing errors on over-indexing since it doesn't align with TypedArrays, but I'd rather copy an existing semantic than make a nearly identical but slightly different semantic of my own.

baudaux • 2 months ago

I easily managed to build quickJS to WebAssembly for running in https://exaequOS.com . So I need to do the same for MicroQuickJS !

MobiusHorizons • 2 months ago

I'm curious what practical purpose you could have for running a js execution engine in an environment that already contains a (substantially faster) js execution engine? Is it just for the joy of doing it (if so good for you, absolutely nothing wrong with that).

kettlecorn • 2 months ago

Sandboxing.

Figma for example used QuickJS, the prior version of the library this post is about, to sandbox user authored Javascript plugins: https://www.figma.com/blog/an-update-on-plugin-security/

It's pretty handy for things like untrusted user authored JS scripts that run on a user's client.

JoshTriplett • 2 months ago

WebAssembly also runs in places other than the web, where there isn't a JavaScript interpreter at hand. It'd be nice to have a fast JavaScript engine that integrates inside the WebAssembly sandbox, and can call and be called by other languages targeting WebAssembly.

That way, programs that embed WebAssembly in order to be scriptable can let people use their choice of languages, including JavaScript.

baudaux • 2 months ago

It allows, for example, to create bindings as I did for raylib graphics library. exaequOS can run any program that can be built to WebAssembly It will soon support WASI p1 and p2. So many programming languages will be possible for creating programs targeting exaequOS

MobiusHorizons • 2 months ago

Is there not a way to use the browser native js execution environment for that? You lose a non-trivial amount of performance running js inside quickjs inside of wasm vs the browser native js engine. I wouldn't be surprised if that's 10 or even 20 times slower, and of course requires loading more code into the browser (slower startup, more ram usage). Maybe you don't care about that, but all of that is pretty orthogonal to the environments I an embedded engine like this is intended for.

baudaux • 2 months ago

theandrewbailey • 2 months ago

> It compiles and runs Javascript programs with as low as 10 kB of RAM.

Just in time for RAM to become super expensive. How easy would it be to shove this into Chromium and Electron?

jraph • 2 months ago

Hard because of web compatibility.

The good news is that it would probably not matter much for chromium's memory footprint anyway...

nmz • 2 months ago

This makes me wonder, is there analysis of the syntax and if so can't it pick the lightest implementation? I see how light dillo is on the same page as chrome and I don't know why a web browser of the caliber of chrome does so much worse than a browser worked by a handful of people.

booi • 2 months ago

If there were a software engineering hall of fame, I nominate Fabrice.

lacedeconstruct • 2 months ago

rare occasion where he gained a legendary status based purely on his work, I dont think I ever saw even a written interview with the guy

throw-qqqqq • 2 months ago

He is a private man that does not like the spotlight IIUC. He refuses most requests for interviews, but they do exist.

https://www.macplus.net/depeche-82364-interview-le-createur-...

https://www.mo4tech.com/fabrice-bellard-one-man-is-worth-a-t... (few quotes, more like a profile piece)

He keeps a low profile and let his work speak for itself.

He really is brilliant.

userbinator • 2 months ago

He has probably has no time for interviews and just focuses on working on his many projects.

appreciatorBus • 2 months ago

I often think the world would be a better place if more people in the tech industry follow this philosophy.

hn_throwaway_99 • 2 months ago

I think this is such an important point. I know all about Bellard's main works. I actually have no idea what he looks like, I've also never seen an interview with him, and I've never read about his specific philosophies when it comes to different software engineering topics. In a world of never-ending bloviations from "influencers" and "thought leaders" it's so awesome to see a real example of true excellence.

IlikeMadison • 2 months ago

Bellard it the most genius programmer to ever exist, and the least known compared to other pseudo stars.

textlapse • 2 months ago

His consistency and craftsmanship is amazing.

Being an engineer and coding at this stage/level is just remarkable- sadly this trade craft is missing in most (big?) companies as you get promoted away into oblivion.

wyldfire • 2 months ago

There is! ACM grants several awards for scientists and more.

One such award is the Turing Award [1], given "for contributions of lasting and major technical importance to computer science."

[1] https://en.wikipedia.org/wiki/Turing_Award

svat • 2 months ago

Possibly more relevant is the "ACM Software System Award": https://en.wikipedia.org/w/index.php?title=ACM_Software_Syst...

AtlasBarfed • 2 months ago

Linux and Torvalds hasn't gotten one?

hn_throwaway_99 • 2 months ago

The Turing Award is given for breakthroughs in computer science, not for "most productive programmer of all time", and it wouldn't be appropriate for Ballard.

senbrow • 2 months ago

Fabrice is certainly very skilled in CS, but his achievements are more in software implementation IMO.

AIUI the Turing award is primarily CS focused.

bArray • 2 months ago

If there were some form of "developed contributions to computing" award, his name is definitely up there. I think there could be a need for such an award - for people who reliably have created the foundations of modern computing. Otherwise it's almost always things from an academic context, which can be a little too abstract.

sxp • 2 months ago

Between ffmpeg and qemu, I always think of https://xkcd.com/2347/ when I see Fabrice's work. Especially since ffmpeg provides the backbone of almost all video streaming systems today.

makapuf • 2 months ago

Except that ffmpeg and qemu are not maintained by Fabrice. He's one of the greatest programmers but he's not maintaining the internet.

treavorpasan • 2 months ago

I suppose that if he were to maintain any of these projects, we would never see the new frontiers he has been conquering.

mtlynch • 2 months ago

People talk about how productive Fabrice Bellard is, but I don't think anyone appreciates just how productive he is.

Here's the commit history for this project

b700a4d (2025-12-22T1420) - Creates an empty project with an MIT license

295a36b (2025-12-22T1432) - Implements the JavaScript engine, the C API, the REPL, and all documentation

He went from zero to a complete JS implementation in just 12 minutes!

I couldn't do that even if you gave me twice as much time.

Okay, but seriously, this is super cool, and I continue to be amazed by Fabrice. I honestly do think it would be interesting to do an analysis of a day or week of Fabrice's commits to see if there's something about his approach that others can apply besides just being a hardworking genius.

ronsor • 2 months ago

It's funny how many people replying here just got whooshed. This comment is satire; they don't actually think Bellard wrote everything in 12 minutes.

andoando • 2 months ago

Doesn't say much. Probably had it largely written down and put it together. I don't think it'd even be humanely possible to do that in 12 minutes.

tremon • 2 months ago

That doesn't mean anything. I quite often start with writing a proof-of-concept, and only initialize the git repository when I'm confident the POC will actually lead to something useful. Common sense says that those files already existed at the time of the first commit.

mordnis • 2 months ago

I wonder how do you not understand this was a joke. Did you not fully read it? Or it's just not obvious enough?

voxelghost • 2 months ago

When you code with butterflies, you code at the speed of flight.

https://www.xkcd.com/378/

Lockal • 2 months ago

Glad to see a project of Fabrice Bellard on github, finally. I know many great opensource projects exist without public development (notably, sqlite), but is always disappointing to have no public bug tracker, no patch submission, no commit history, contact by email, tarballs (even with a signature, tooling for signed downloads never received any development), etc.

eichin • 2 months ago

Anyone know how this compares to Espruino? The target memory footprint is in the same range, at least. (I know very little about the embedded js space, I just use shellyplugs and have them programmed to talk to BLE lightswitches using some really basic Espruino Javascript.)

throwaway81523 • 1 month ago

I haven't used Espruino but I spent a while perusing the source code. At least at the time, the implementation strategy was very slow. I lost interest in it in favor of Lua and Micropython.

yeasku • 2 months ago

I wonder if AI is so good why dont we have this kind of software released by people here who yap about it.

jgrizou • 2 months ago

What is the difference with https://www.espruino.com/ ?

sedatk • 2 months ago

They are very similar in terms of ROM footprint (esp: 128K vs mqjs: 100K) and min RAM (esp: 8K vs mqjs: 10K), but spec coverage need to be examined in detail to see the actual difference.

niutech • 1 month ago

How about comparing with Duktape (https://duktape.org)?

zamadatix • 2 months ago

On a phone at the moment so I can't try it out, but in regards to this "stricter mode" it says global variables must be declared with var. I can't tell if that means that's just the only way to declare a global or if not declaring var makes it scoped in this mode. Based on not finding anything skimming through the examples, I assume the former?

lioeters • 2 months ago

I'm guessing the use of undeclared variables result in an error, instead of implicitly creating a global variable.

MobiusHorizons • 2 months ago

it also talks about the global object not being a place to add properties. So how you might do `window.foo = ...` or `globalThis.foo = ...` to make something from the local context into a global object. in this dialect I guess you would have to reserve any global objects you wanted to set with a `var` and then set them by reference eg

    // global. initialized by SomeConstructor
    var fooInstance

    class SomeConstructor {
       constructor(...) {
          fooInstance = this;
       }
       static getInstance(...) {
          if (fooInstance != null) return fooInstance;
          return new SomeConstructor(...);
       }
    }

frabert • 2 months ago

I think it means you can't assign to unbounded names, you must either declare with var for global, or let/const for local

schappim • 2 months ago

Love it! Needing only 10K of RAM, it looks like a much better solution to CircuitPython (can squeeze into 32K).

noduerme • 2 months ago

>> Arrays cannot have holes. Writing an element after the end is not allowed:

    a = []
    a[0] = 1; // OK to extend the array length
    a[10] = 2; // TypeError

If you need an array like object with holes, use a normal object instead

Guess I'm a bit fuzzy on this, I wouldn't use numeric keys to populate a "sparse array", but why would it be a problem to just treat it as an iterable with missing values undefined? Something to do with how memory is being reserved in C...? If someone jumps from defining arr[0] to arr[3] why not just reserve 1 and 2 and inform that there's a memory penalty (ie that you don't get the benefit of sparseness)?

aapoalas • 2 months ago

Guidance towards correct usage: eg. If you allow `a[10] = 2` and just make the Array dense, the user might not even realise the difference and will assume it's sparse. Next they perform `a[2636173747] = 3` and clog up the entire VM memory or just plain crash it from OOM. Since it's likely that the small indexes appear in testing and the large indexes appear in production, it is better to make the misunderstanding an explicit error and move it "leftwards" in time, so that it doesn't crash production at an inopportune moment.

noduerme • 1 month ago

So it's guidance. Does V8 just treat those as an object?

throwaway81523 • 1 month ago

Old thread but I just saw it. My first question is whether it's sane to want to target Typescript or Purescript to it.

alcover • 2 months ago

I wish for this new year we reboot the Web with a super light standard and accompanying ecosystem with

    - A small and efficient JS subset, HTML, CSS
    - A family of very simple browsers that do just that
    - A new Web that adheres to the above

That would make my year.

qweqwe14 • 2 months ago

This would never happen because there's zero incentive to do this.

Browsers are complex because they solve a complex problem: running arbitrary applications in a secure manner across a wide range of platforms. So any "simple" browser you can come up with just won't work in the real world (yes, that means being compatible with websites that normal people use).

alcover • 2 months ago

> that means being compatible with websites that normal people use

No, new adhering websites would emerge and word of mouth would do the rest : normal people would see this fast nerd-web and want rid of their bloated day-to-day monster of a web life.

One can still hope..

dmd • 2 months ago

Just like all those normal people want rid of their bloated day-to-day monster of a web and therefore go and do something like, say, install an ad blocker?

Oh right. 99% of people don't do even that, much less switch their life over to entirely new websites.

lioeters • 2 months ago

foobarian • 2 months ago

I don't care to run an ad blocker because sites are still bloated and slow.

mxey • 2 months ago

you know you CAN make small websites with the existing standards already

notKilgoreTrout • 2 months ago

I have to disagree, AMP showed that even Google had an internal conflict with the results of WHATWG.. It's naturally quite hard to reach agreements on a subset when many parties will prefer to go backwards to everything but there situations like the first iPhone, ebooks, TV browsing, etc, where normal people buy simpler things and groups that use the simpler subset achieve more in total than those stuck in the complex only format.

(There are even a lot of developers who would inherently drop any feature usage as soon as you can get 10% of users to bring down their stats on caniuse.com to bellow ~90%.)

riedel • 2 months ago

I think both wearables and AI assistant could be an incentive on one hand, also towards a more HATEOAS web. However, I guess we haven't really figured out how to replace ad revenue as the primary incentive to make things as complex as possible.

groundzeros2015 • 2 months ago

Zero incentive seems a little strong,

andrewmcwatters • 2 months ago

[dead]

cosmic_cheese • 2 months ago

Lots of comments talking about how existing browsers can already do this, but the big benefit that current browsers can't give you is the sheer level of speed and efficiency that a highly restricted "lite web" browser could achieve, especially if the restrictions are made with efficiency in mind.

The embedded use case is obvious, but it'd also be excellent for things like documentation — with such a browser you could probably have a dozen+ doc pages open with resource usage below that of a single regular browser tab. Perfect for things that you have sitting open for long periods of time.

morshu9001 • 1 month ago

Is MQJS faster or lighter than other engines though? It says the engine itself takes very little memory, but that doesn't say how it performs running all that bloated JS out there. Well also has "quick" in the name.

cosmic_cheese • 1 month ago

How it performs with existing JS doesn’t really matter in the context of my post, though.

For a “lite web” browser that’s built for a thin, select slice of the web stack (HTML/CSS/JS), dragging around the heft of a full fat JS engine like V8 is extreme overkill, because it’s not going to be running things like React but instead enabling moderate use of light enhancing scripts — something like a circa-2002 website would skew toward the heavy side of what one might expect for a “lite web” site.

The JS engine for such a browser could be trimmed down and aggressively optimized, likely even beyond what has been achieved with MQJS and similar engines, especially if one is willing to toss out legacy compatibility and not keep themselves beholden to every design decision of standard JS.

alcover • 2 months ago

That's it. Plus they would work neatly on old computers/phones.

zem • 2 months ago

someone should embed it into dillo!

anthk • 2 months ago

Better not. It already exists former QuickJS and QuickJS-NG, and parsing JS is a no light task by any means. Even Edbrowse https://github.com/cmb/edbrowse can grind down to a halt an n270 netbook becaus of some sites with JS (both with qjs and qjs-ng). So Dillo would be no better.

Also, legacy machines couldn't run it as fast as they could.

born-jre • 2 months ago

There could be a way: This HTML-lite spec would be subset of current standard so that if you open this HTML lite page in normal browser it would still work. but HTML-lite browser would only open HTML-lite sites, apart from tech itch it could be used in someplace where not full browser is needed, especially if you are control content generation. - TV screens UI - some game engines embed chrome embed thing ( steam store page kind) - some electron apps / lighter cross platform engine - less sucky QML - i think weechat or sth has own xml bashed app froamework thing (so could be useful to people wanting to build everything app app platform - much richer markdown format ?

zero_bias • 2 months ago

It’s called WML/WAP

AtlasBarfed • 2 months ago

I think we can do better than a 15x15 text window

exasperaited • 2 months ago

dtj1123 • 2 months ago

What about https://geminiprotocol.net/

dcminter • 2 months ago

While we're wishing, can we split CSS into two parts - styling and layout? Also, I'd like to fix the spelling on the "referer" header...

pests • 2 months ago

why does it need to be two languages? why not style.css and layout.css and you self-maintain the distinction

duped • 2 months ago

I think there needs to be a split between the web browser as a document renderer and link follower, and the web browser as a portable target for GUI applications. But frankly my biggest gripe is that you need HTML, JS, and CSS. Three distinct languages that are extremely dissimilar in syntax and semantics that you need all three of (or some bastard cross compiler for your JSX to convert from one format to them). Just make a decent scripting language and interface for the browser and you don't need that nonsense.

I understand this has been tried before (flash, silverlight, etc). They weren't bad ideas, they were killed because of companies that were threatened by the browser as a standard target for applications.

foobarchu • 2 months ago

I think this is the ideal direction mainly because a lot of the webs current tech problems stem from websites that don't need app-level features using them. I was in web dev at the advent of SPA-style navigation and understand why everyone switched to it, but at the same time I feel like it's the source of many if not most bugs an performance issues that frustrate the average user.

alcover • 2 months ago

I agree. Something componenty like Flash, yes. But it'd be easier to subset what already exists..

augustk • 2 months ago

And also bring back progressive enhancement.

https://en.wikipedia.org/wiki/Progressive_enhancement

hinkley • 2 months ago

Years ago I wrote a tiny xhtml-basic browser for a job. It was great. Some of my best work. But then the iPhone came out and xhtml-basic died practically overnight.

afavour • 2 months ago

So you want 2026 to be the year of Google AMP?

keepamovin • 2 months ago

Do it, man. Call it "MicroWeb" or whatever. Write an agent, make it "viewable with regular browsers". I think this could be cool.

aziis98 • 2 months ago

I would actually merge html and js in a single language and bring the layout part of css too (something like having grid and flexbox be elements themselves instead of display styles, more typst kind of showed this is possible in a nice way) and keep css only for the styling part.

Or maybe just make it all a single lispy language

1313ed01 • 2 months ago

Not likely to happen. There is geminiprotocol with gemtext though for those of us that are fine with that level of simplicity.

Work towards an eventual feature freeze and final standardisation of the web would be fantastic though, and a huge benefit to pretty much everyone other than maybe the Chrome developers.

GaryBluto • 1 month ago

Be the change you want to see in the world. If you want to use a specific subset of HTML, CSS and JS, go ahead, make a website using it and offer a browser for similar-spec sites.

speed_spread • 2 months ago

You can already create websites to these standards. Then truncate large parts of webkit and create a new browser. Or base it on Servo.

oefrha • 2 months ago

You mean like the piece of crap that was WAP?

mewse-hn • 2 months ago

I can't think of an instance of the web contracting like that. Maybe when Apple decided not to support Adobe Flash.

bdcravens • 2 months ago

In the earlier days of the web, there were a lot more plugins you'd install to get around on most websites: not just Flash, but things like PDF viewers, Real Video, etc. You'd regularly have to install new codecs, etc. To say nothing of the days when there were some sites you'd have to use a different browser for. A movement towards more of a standards-driven web (in the sense of de facto, not academic, standards) is what made most of this possible.

fireflies_ • 2 months ago

Arguably XSLT

mromanuk • 2 months ago

Would be cool to create a MicroBrowser, just to browser stuff that's compatible.

lioeters • 2 months ago

And Microsoftware running on the Micronet.

fud101 • 1 month ago

It needs a good standard library yeah? i don't see that in your list.

stronglikedan • 2 months ago

I mean, you can do all that now, so that's not the problem. The problem would be convincing millions of people to switch, when 99.99999% of them couldn't care less.

vbezhenar • 2 months ago

My idea is to use Markdown over HTTP(S). It's relatively easy to implement Markdown renderer, compared to HTML renderer. It's possible to browse that kind of website with HTML browser with very simple wrapper either on client or server side, so it's backwards compatible. It's rich enough for a lot of websites with actually useful content.

Now I know that Markdown generally can include HTML tags, so probably it should be somewhat restricted.

It could allow to implement second web in a compatible way with simple browsers.

sunshine-o • 2 months ago

I believe this is the way we might get out of this mess.

With a markdown over HTTP browser I could already almost browse Github through the READMEs and probably other websites.

Markdown is really a loved and now quite popular format. It is sad gemini created a separate closed format instead of just adopting it.

coryrc • 2 months ago

You can just use HTML4 if you want, it's already supported and standardized. Markdown is very much not.

vbezhenar • 2 months ago

billforsternz • 2 months ago

A few too many 9s there I think. You're estimating that only 1 person in every 10 million could care less. So less than 50 such people in the USA for example

makapuf • 2 months ago

Maybe you dont need a big enough % to change but a sufficient absolute number, which given internet size might happen with the right 0.00001%

alcover • 2 months ago

Oh they would care if one shows them much snappier versions of services they use. They just don't know better.

bArray • 2 months ago

And if you find you need more features than that - just build an app, don't make the web browser into some overly bloated app!

mikepurvis • 2 months ago

But most "apps" are just webviews running overcomplicated websites in them, many of which are using all the crazy features that the GP post wants to strip out.

bogdan • 2 months ago

Then you have to deal with os compatibility. That's the main selling point of the Web, it works everywhere.

christophilus • 2 months ago

And, I don't have to run a binary to try your product. The web has a lot of flaws, but it's a good way to deliver properly sandboxed applications with low hassle on the part of the user. I've built my fair share of native vs web apps, and I vastly prefer working on web apps. As a user, I vastly prefer web apps for most things. Not all things, but most. No, I don't want to install your crappy app on my computer and risk you doing something irresponsible. I'll keep you sandboxed in a browser tab that I can easily "uninstall" by closing.

zppln • 2 months ago

bigstrat2003 • 2 months ago

Well worth it. Even the very best web apps struggle to be as good as a decent native app, let alone mediocre web apps. The native operating system blows the web out of the water as an app platform.

thwarted • 2 months ago

Except when it doesn't because of browser or platform differences/incompatibilities.

ameliaquining • 2 months ago

The portability of the Web is imperfect, but it's not even in the same galaxy as the portability of native app platforms; there's just no comparison.

notorandit • 2 months ago

This guy is incredible. Lzexe, Qemu, TinyCC to name just a few gems.

itsangaris • 1 month ago

Is there a static analyzer/linter associated with this environment that can flag potential runtime issues upfront?

tracker1 • 1 month ago

Sound like this would have been a good option for PLJS in PostgreSQL (currently using QuickJS), not sure if it'd be appropriate to consider a switch or if that would/could improve availability... IMO interaction with JSON(B) and other json and objects being the biggest usefulness.

t43562 • 2 months ago

Sounds like a competitor for Micropython on all those little RP2350 and ESP boards.

fcoury • 1 month ago

Just published a rust wrapper if anyone plan on embedding it like I do:

https://github.com/fcoury/mquickjs-rs

aiddun • 2 months ago

Very excited about this. I was programming an ESP32 for a project recently and was like, computer chips are fast enough, why can't I just write TypeScript?

rounce • 2 months ago

There is already Espruino[0], it’s more free in terms of syntactic support but it’s also bigger.

0: https://www.espruino.com/ESP32

g947o • 2 months ago

Looks like the real "JavaScript: The Good Parts"

p0w3n3d • 2 months ago

I wonder when does he have time to do those marvellous things

mrmagoo17 • 2 months ago

This is a hell of a Christmas present, Mr. Santa Bellard!

rurban • 1 month ago

And most importantly, it brought him out to interact with the public. He answered PR's!

yoan9224 • 1 month ago

bellard is basically proof that the "10x engineer" exists. ffmpeg, qemu, quickjs, and now this... all from one person. the fact that he can optimize a js engine down to 10kb of ram is wild. would love to see this on esp32 boards

vkdelta • 1 month ago

What use-cases do you think it would help on esp32?

artemonster • 1 month ago

I wonder what "hurr durr gotos are bad" crowd would say. Anyone?

pvtmert • 1 month ago

This is going to be one of the most upvoted submissions on HN

dangoodmanUT • 2 months ago

this would be a killer replacement for micro/circuitpython for embedded devices, assuming there's an elegant TS->MQJS transpile

halfmatthalfcat • 2 months ago

It’s not even the languages or runtimes that inhibit embedded adoption but the software to hardware tooling. Loader scripts, HAL/LL/CMSIS, flashing, etc. They all suck.

curtisblaine • 2 months ago

I don't think you can transpile arbitrary TS in mqjs's JS subset. Maybe you can lint your code in such a way that certain forbidden constructs fail the lint step, but I don't think you can do anything to avoid runtime errors (i.e. writing to an array out of its bonds).

idle_zealot • 2 months ago

It looks like if you write the acceptable MQJS subset of JS+types, then run your code through a checker+stripper that doesn't try to inject implementations of TS's enums and such it should just work?

stackedinserter • 1 month ago

It gives me strong ffserver flashbacks.

noreplydev • 1 month ago

how anyone explore extending the stdlib for hardware specific features?

ProofHouse • 1 month ago

https://textarea.my/#7dsxaiNbEEDRvFcxWzEIb0ArEAgFkjLtHwYzMHm...

rcarmo • 2 months ago

Now all we need is a Fennel-like LISP on top.

anita_ • 2 months ago

[dead]

T3RMINATED • 2 months ago

[dead]

jumbledoor • 2 months ago

[dead]

franze • 1 month ago

Feel free to check out this MicroQickJS WASM port (100% Claude Code generated)

Demo Page https://mquickjs-claude-code.franzai.com/

Show HN https://news.ycombinator.com/item?id=46376296

diimdeep • 2 months ago

I find frustrating that imagination of very smart, talented and capable people is captured by JavaScript language, surely they could have done better.