Now Reading
Construct your personal WebAssembly Compiler

Construct your personal WebAssembly Compiler

2023-12-03 09:11:29

Have you ever ever needed to write down your personal compiler? … sure? … in fact you’ve! I’ve all the time needed to have a go at writing a compiler, and with the latest launch of WebAssembly, I had the proper excuse to have a go.

My unique plan was to invent my very own programming language, create a compiler that targets WebAssembly, and share my experiences at FullStackNYC. The primary half went to plan, I spent many-an-evening constructing, tinkering and refining my compiler. Sadly the final a part of my plan didn’t go fairly so effectively. Lengthy delays, and an eventual cancellation, meant that I wasn’t going to make it to New York in any case. 😔😢😭

So, somewhat than waste all that work – I believed I’d write up my speak as a weblog publish as a substitute – therefore the ‘19 min’ studying time for this text. So sit again, make your self snug, and we’ll start …

What’s WebAssembly? (and why does it exist?)

For those who haven’t heard of WebAssembly earlier than, and need a actually detailed introduction, I’d completely advocate Lin Clark’s Cartoon Guide.

You’ll be taught the ‘what’ of WebAssembly all through this weblog publish, however I do wish to briefly contact on the ‘why’.

From my perspective, this diagram sums it up fairly succinctly:

The highest diagram reveals a simplified timeline for the execution of some JavaScript code inside the browser. From left-to-right, the code (sometimes delivered as a minified mess!) is parsed into an AST, initially executed in an interpreter, then progressively optimised / re-optimised till it will definitely runs actually fairly shortly. Nowadays JavaScript is quick – it simply takes some time to stand up to hurry.

The underside diagram is the WebAssembly equal. Code written in all kinds of languages (Rust, C, C#, and so forth …) is compiled to WebAssembly that’s delivered in a binary format. That is very simply decoded, compiled and executed – giving quick and predictable efficiency.

So why write your personal compiler?

WebAssembly has been inflicting fairly a stir during the last 12 months. A lot so, that it was voted the fifth ‘most liked’ language in Stack Overflow’s developer insights survey.

An fascinating end result, contemplating that for most individuals WebAssembly is a compilation goal, somewhat than a language they may use straight.

This was a part of my motivation for proposing the FullStackNYC speak within the first place. The technical elements of WebAssembly are actually fascinating (and remind me of 8-bit computer systems from just a few a long time again), but most individuals won’t ever get the possibility to dabble with WebAssembly itself – it should simply be a black field that they compile to.

Writing a compiler is a very good alternative to delve into the main points of WebAssembly to search out it what it’s and the way it works. And it’s enjoyable too!

One remaining level, it was by no means my goal to create a fully-featured programming language, or one that’s really any good. My aim was to create ‘sufficient’ of a language to permit me to write down a program that renders a mandelbrot set. This language is compiled to WebAssembly utilizing my compiler, which is written in TypeScript and runs within the browser.

Right here it’s in it’s full glory:

I ended up calling the language chasm and you’ll play with it online if you like.

Sufficient rambling – time for some code!

A minimal wasm module

Earlier than tackling the compiler, we’ll begin with one thing less complicated, making a minimal WebAssembly module.

Right here is an emitter (the time period used for the a part of a compiler that outputs directions for the goal system), that creates the smallest legitimate WebAssembly module:

const magicModuleHeader = [0x00, 0x61, 0x73, 0x6d];
const moduleVersion = [0x01, 0x00, 0x00, 0x00];

export const emitter: Emitter = () =>

It’s comprised of two components, the ‘magic’ header, which is the ASCII string asm, and a model quantity. These eight bytes kind legitimate WebAssembly (or wasm) module. Extra sometimes these can be delivered to the browser as a .wasm file.

So as to execute the WebAssembly module it must be instantiated as follows:

const wasm = emitter();
const occasion = await WebAssembly.instantiate(wasm);

For those who run the above you’ll discover that occasion doesn’t really do something as a result of our wasm module doesn’t comprise any directions!

For those who’re fascinated with making an attempt out this code for your self, it’s all on GitHub – with a commit for each step.

An add operate

Let’s make the wasm module do one thing extra helpful, by implementing a operate that provides a few floating level numbers collectively.

WebAssembly is a binary format, which isn’t terribly readable (to people not less than), which is why you’ll extra sometimes see it written in WebAssembly Textual content Format (WAT). Right here’s a module, introduced in WAT format, that defines an exported operate named $add that takes two floating level parameters, provides them collectively and returns them:

 (func $add (param f32) (param f32) (end result f32)
   get_local 0
   get_local 1
 (export "add" (func 0))

For those who simply wish to experiment with WAT you should utilize the wat2wasm device from the WebAssembly Binary Toolkit to compile WAT information into wasm modules.

The above code reveals some fascinating particulars round WebAssembly –

  • WebAssembly is a low-level language, with a small (approx 60) instruction set, the place lots of the directions map fairly intently to CPU directions. This makes it straightforward to compile wasm modules to CPU-specific machine code.
  • It has no inbuilt I/O. There aren’t any directions for writing to the terminal, display screen or community. So as to wasm modules to work together with the surface world they want to take action through their host atmosphere, which within the case of the browser is JavaScript.
  • WebAssembly is a stack machine, within the above instance get_local 0 will get the native variable (on this case the operate param) on the zeroth index and pushes it onto the stack, as does the following instruction. The f3.add instruction pops two values kind the stack, provides them collectively than pushes the worth again on the stack.
  • WebAssembly has simply 4 numeric varieties, two integer, two floats. Extra on this later …

Let’s replace the emitter to output this ‘laborious coded’ WebAssembly module.

WebAssembly modules are composed of a pre-defined set of non-compulsory sections, every prefixed with a numeric identifier. These embody a kind part, which encode sort signatures, and performance part, which signifies the kind of every operate. I’ll not cowl how these are constructed right here – they’re fairly uninteresting. For those who’re , look at the next commit in the project.

The fascinating half is the code part. Right here is how the above add operate is created in binary:

const code = [
 Opcodes.get_local /** 0x20 */,
 Opcodes.get_local /** 0x20 */,
 Opcodes.f32_add   /** 0x92 */

const functionBody = encodeVector([
 ...encodeVector([]) /** locals */,
 Opcodes.finish /** 0x0b */

const codeSection = createSection(Part.code /** 0x0a */,

I’ve outlined an Opcodes enum (I’m utilizing TypeScript), which accommodates the entire wasm directions. The unsignedLEB128 operate is a typical variable length encoding which is used for encoding instruction parameters.

The directions for a operate are mixed with the operate’s native variables (of which there are none on this case), and an finish opcode that indicators the tip of a operate. Lastly all of the features are encoded into a piece. The encodeVector operate merely prefixes a set of byte arrays with the entire size.

And there you’ve it, the entire module, which is about 30 bytes in complete.

The JavaScript internet hosting code can now be up to date to contain this exported operate:

const { occasion } = await WebAssembly.instantiate(wasm);
console.log(occasion.exports.add(5, 6));

Apparently when you examine the exported add operate with the Chrome Dev Instruments it identifier it as a ‘native operate’.

You’ll be able to see the entire code for this step (with unit tests – go me!) on GitHub.

Constructing a compiler

Now that you just’ve seen methods to dynamically create wasm modules, it’s time to show our consideration to the duty of making a compiler. We’ll begin with a little bit of terminology.

Right here’s some chasm code annotated to indicate the important thing parts of a language:

Quite than give a ‘textbook definition’ of every, you’ll develop into aware of them because the compiler evolves.

The compiler itself might be shaped of three components, the tokenizer which breaks up the enter program (which is a string), into discrete tokens, the parser that takes these tokens and converts them into an Summary Syntax Tree (AST), and at last the emitter which converts the AST into wasm binary module.

It is a fairly normal compiler structure:

Quite than dive into an entire implementation, we’ll deal with a small subset of the issue. The aim is to create a compiler for a language that simply helps print statements which print easy numeric literals …

The Tokenizer

The tokenizer works by advancing by way of the enter string, one character at a time, matching patterns that characterize particular token varieties. The next code creates three matches (quantity, key phrase, and whitespace), utilizing easy common expressions:

const key phrases = ["print"];

 // returns a token if the given regex matches on the present index
const regexMatcher = (regex: string, sort: TokenType): Matcher =>
  (enter: string, index: quantity) => {
    const match = enter.substring(index).match(regex);
    return (
      match && {
        worth: match[0]

const matchers = [
  regexMatcher("^[.0-9]+", "quantity"),
  regexMatcher(`^($"))`, "key phrase"),
  regexMatcher("^s+", "whitespace")

(Notice, these common expressions are usually not terribly sturdy!)

The Matcher interface defines a operate that given an enter string and an index returns a token if a match happens.

The primary physique of the parser iterates over the characters of the string, discovering the primary match, including the supplied token to the output array:

export const tokenize: Tokenizer = enter => {
  const tokens: Token[] = [];
  let index = 0;
  whereas (index < enter.size) {
    const matches = => m(enter, index)).filter(f => f)
    const match = matches[0];
    if (match.sort !== "whitespace") {
    index += match.worth.size;
  return tokens;

Right here is the tokenised output of this system "print 23.1":

   "type": "keyword",
   "value": "print",
   "index": 1
   "type": "number",
   "value": "23.1",
   "index": 7

As you possibly can see from the above enter, the tokeniser removes whitespace because it has no that means (for this particular language), it additionally ensures that all the things within the enter string is a legitimate token. Nevertheless, it doesn’t make any ensures in regards to the enter being well-formed, for instance the tokeniser will fortunately deal with "print print", which is clearly incorrect.

The array of tokens is subsequent fed into the parser.

The Parser

The aim of the parser is the creation of an Summary Syntax Tree (AST), a tree construction that encodes the connection between these tokens, leading to a kind that would probably be despatched to an interpreter for direct execution.

The parser iterates by way of the provided tokens, consuming them through an eatToken operate.

export const parse: Parser = tokens => {
  const iterator = tokens[Symbol.iterator]();
  let currentToken = iterator.subsequent().worth;
  const eatToken = () =>
    (currentToken = iterator.subsequent().worth);


  const nodes: StatementNode[] = [];
  whereas (index < tokens.size) {

  return nodes;

(I’ve no thought the place the idea of consuming tokens comes from, it seems to be normal parser terminology, they’re clearly hungry beasts!)

The aim of the above parser is to show the token array into an array of statements, that are the core constructing blocks of this language. It expects the given tokens to evolve to this sample, and can throw an error (not proven above) if it doesn’t.

The parseStatement operate expects every assertion to start out with a key phrase – switching on its worth:

const parseStatement = () => {
  if (currentToken.sort === "key phrase") {
  swap (currentToken.worth) {
    case "print":
      return {
        sort: "printStatement",
        expression: parseExpression()

Presently the one supported key phrase is print, on this case it returns an AST node of sort printStatement parsing the related expression.

And right here is the expression parser:

const parseExpression = () => {
  let node: ExpressionNode;
  swap (currentToken.sort) {
    case "quantity":
      node = {
        sort: "numberLiteral",
        worth: Quantity(currentToken.worth)
      return node;

In its current kind the language solely accepts expressions that are composed of a single quantity – i.e. a numeric literal. Subsequently the above expression parser expects the following token to be a quantity, and when this matches, it returns a node of sort numberLiteral.

Persevering with the straightforward instance of this system "print 23.1", the parser outputs the next AST:

    "type": "printStatement",
    "expression": {
      "type": "numberLiteral",
      "value": 23.1

As you possibly can see the AST for this language is an array of assertion nodes. Parsing ensures that the enter program is syntactically appropriate, i.e. it’s correctly constructed, but it surely doesn’t in fact assure that it’ll execute efficiently, runtime errors would possibly nonetheless be current (though for this easy language they don’t seem to be doable!).

We’re onto the ultimate step now …

The Emitter

Presently the emitter outputs a hard-coded add operate. It now must take this AST and emit the suitable directions, as follows:

const codeFromAst = ast => {
  const code = [];

  const emitExpression = node => {
    swap (node.sort) {
      case "numberLiteral":

  ast.forEach(assertion => {
    swap (assertion.sort) {
      case "printStatement":

  return code;

The emitter iterates over the statements that kind the ‘root’ of the AST, matching our solely assertion sort – print. Discover that the very first thing it does is emit the directions for the assertion expressions, recall that WebAssembly is a stack machine, therefore the expression directions should be processed first leaving the end result on the stack.

The print operate is carried out through a name operation, which invokes the operate at index zero.

Beforehand we’ve seen how wasm modules can export features (as per the add instance above), they will additionally import features, that are provided while you instantiate the module. Right here we offer an env.print operate that logs to the console:

const occasion = await WebAssembly.instantiate(wasm, {
  env: {
    print: console.log

This operate is addressable by index, i.e. name 0.

You’ll be able to see the entire code for the compiler at this point on GitHub – you can even have a play with this instance through the online chasm compiler playground.

Additionally, for completeness that is how this system progresses by way of the varied compiler levels:

To this point we’ve put various construction in place, however not likely felt the profit. A separate tokenizer, parser and emitter is overkill for a language that solely prints easy numerics. Nevertheless, because the language complexity grows, this construction actually begins to pay dividends.

Implementing expressions

Subsequent up, we’ll have a look at implementing binary expressions, permitting the language to carry out easy arithmetic, for instance print ((42 + 10) / 2).

For the tokeniser the adjustments are fairly trivial, involving including a few extra regex matchers for parentheses and operators. I’ll not reproduce them right here – as a substitute, simply present the resultant output:

  { "type": "keyword", "value": "print" },
  { "type": "parens", "value": "(" },
  { "type": "parens", "value": "(" },
  { "type": "number", "value": "42" },
  { "type": "operator", "value": "+" },
  { "type": "number", "value": "10" },
  { "type": "parens", "value": ")" },
  { "type": "operator", "value": "/" },
  { "type": "number", "value": "2" },
  { "type": "parens", "value": ")" }

Subsequent up, we’ll have a look at the adjustments to the parser – the place the expression parser can encounter both quantity of parens tokens:

const parseExpression = () => {
  let node: ExpressionNode;
  swap (currentToken.sort) {
    case "quantity":
    case "parens":
      const left = parseExpression();
      const operator = currentToken.worth;
      const proper = parseExpression();
      return {
        sort: "binaryExpression",
        left, proper, operator

Discover that parsing of parens expressions is recursive, with the nodes for the left and proper invoking the parseExpression operate as soon as once more.

See Also

The AST for this system print ((42 + 10) / 2) is given beneath:

 type: "printStatement",
 expression: {
   type: "binaryExpression",
   left: {
     type: "binaryExpression",
     left: {
       type: "numberLiteral",
       value: 42
     right: {
       type: "numberLiteral",
       value: 10
     operator: "+"
   right: {
     type: "numberLiteral",
     value: 2
   operator: "/"

The tree construction is turning into extra apparent on this instance.

Lastly, the emitter must be up to date so as to deal with the binaryExpression node sort, as follows:

const emitExpression = (node) =>
  traverse(node, (node) => {
    swap (node.sort) {
      case "numberLiteral":
      case "binaryExpression":

The traverse operate within the above code traverses tree buildings invoking the given customer for every node. Whereas linear buildings solely have one logical option to traverse them (i.e. so as), bushes will be traversed in a number of different ways. The traversal methodology utilized by the emitter is a depth-first post-order traversal, in different phrases because it encounters every node it visits left, proper, then root – this order ensures that the wasm directions are output within the appropriate order for the stack machine, operands then operator.

And that’s it, all of the adjustments which are required to assist expressions. Give it a go online.

The compiler structure is beginning to show its worth!


Subsequent up, we’ll add variables, permitting for extra fascinating chasm packages …

Variables are declared utilizing the var key phrase, and can be utilized in expressions as identifiers.

We’ll not have a look at the adjustments to the tokeniser, it’s simply but extra regex! The primary loop of the parser, which reads successive statements from the token array, determines the assertion sort primarily based on the key phrase it encounters:

const parseVariableDeclarationStatement = () => {
  eatToken(); // var
  const identify = currentToken.worth;
  eatToken(); // =
  return {
    sort: "variableDeclaration",
    initializer: parseExpression()

const parseStatement: ParserStep<StatementNode> = () => {
  if (currentToken.sort === "key phrase") {
    swap (currentToken.worth) {
      case "print":
        return parsePrintStatement();
      case "var":
        return parseVariableDeclarationStatement();

Variable declaration parsing is kind of straight-forwards – discover that the parseVariableDeclarationStatement operate additionally makes use of the expression parser, which ensures that variables will be declared and assigned an preliminary worth from an expression, e.g. var f = (1 + 4).

Subsequent up, the emitter. WebAssembly features can have native variables, these are declared firstly of the operate definition, and are accessed through the get_local and set_local features that additionally retrieve operate parameters.

The variables in our AST are referenced through their identifier identify, whereas wasm identifies locals by their index. The emitter wants to keep up this info in an emblem desk, which is an easy map from the image identify to index:

const symbols = new Map<string, quantity>();

const localIndexForSymbol = (identify: string) => {
  if (!symbols.has(identify)) {
    symbols.set(identify, symbols.dimension);
  return symbols.get(identify);

Inside the node traversal, when a variable declaration is encountered, the expression is emitted, them set_local used to assign the worth to the respective native variable.

  case "variableDeclaration":

Inside expressions, when identifiers are discovered, the get_local operation is used to retrieve the worth:

  case "identifier":

Additionally, the operate encoding we noticed proper again firstly is up to date so as to add the locals for the operate that the emitter builds. The chasm language has a single variable sort, all the things is a float.

Have a go at defining variables and utilizing them inside print statements online

whereas loops

One of many remaining language constructs we’d like so as to obtain the aim of rendering a mandelbrot set is a few form of loop. For chasm I opted for some time loop, as present on this easy program that prints the numbers 0 to 9:

var f = 0
whereas (f < 10)
  print f
  f = (f + 1)

WebAssembly has varied management circulation directions (department, if, else, loop, block). The next WAT present how some time loop will be constructed:

   [loop condition]
   [nested statements]
   br_if 1
   br 0)

Branching inside WebAssembly relies on stack depth. The outer block and loop directions push entries onto the control-flow stack. The br_if 1 instruction performs a conditional department to a stack depth of 1, and br 0 an unconditional department to a depth of zero, repeating the loop.

Right here’s how the emitter produces the identical in binary format:

  case "whileStatement":
    // outer block
    // internal loop
    // compute the whereas expression
    // br_if $label0
    // the nested logic
    // br $label1
    // finish loop
    // finish block

And right here it’s running in the online playground.


We’re practically there – as much as the final step now! Presently the one manner we’ve been in a position to see output from our chasm packages is through the print assertion, which is wired to the console through a operate imported by the WebAssembly module. For the mandelbrot set we by some means must render graphics to the display screen.

To attain this we’ll make use of one other essential part of WebAssembly modules, linear reminiscence:

As I discussed beforehand, WebAssembly solely has 4 numeric knowledge varieties. You is perhaps questioning how languages with richer sort methods (string, structs, arrays) can compile to WebAssembly?

WebAssembly modules can optionally outline (or import) a block of linear reminiscence, it is a contiguous block of reminiscence that’s shared by the wasm module and its host – in different phrases each can learn and write to this reminiscence. Subsequently, if you wish to move a string to your WebAssembly module, you do that by writing it to linear memory.

For chasm we simply need some kind of show, so will use linear reminiscence as a type of Video RAM.

The chasm languages helps a easy set-pixel command which takes three expressions, the x location, y location and color. For instance, the next program fill the display screen with a horizontal gradient:

var y  = 0
whereas (y < 100)
  var x  = 0
  whereas (x < 100)
    setpixel x y (x * 2)
    x = (x + 1)
  y = (y + 1)

(Attempt it online)

The setpixel command is carried out utilizing the wasm retailer instruction that writes to linear reminiscence. On the JavaScript ‘internet hosting’ facet, this identical linear reminiscence is learn and copied to a HTML canvas. I’ll not reproduce the adjustments to the code right here, you possibly can see them on GitHub

And with that – the chasm language is full, and in a position to render the mandelbrot set:

(Attempt it online)


I hope you loved this journey and have both learnt a bit extra about WebAssembly or how compilers work? For me, this venture was a variety of enjoyable – I’ve by no means written a compiler earlier than, however have all the time needed to.

As you possibly can most likely think about, I’ve not stopped there, the temptation was too nice to maintain going – I’ve already carried out if / else, and features / procedures are within the pipeline. I’d additionally actually prefer to discover among the extra concerned subjects like reminiscence administration, for instance introduce string, arrays and a reminiscence allocator for storage inside linear reminiscence.

All subjects for a future publish!

Source Link

What's Your Reaction?
In Love
Not Sure
View Comments (0)

Leave a Reply

Your email address will not be published.

2022 Blinking Robots.
WordPress by Doejo

Scroll To Top