Tessera

Patrick Dubroy

@dubroy.com

Programmer & researcher, co-creator of https://ohmjs.org. 🇨🇦 🇩🇪 🇪🇺 Co-author of https://wasmgroundup.com — learn Wasm by building a simple compiler in JavaScript. Prev: CDG/HARC, Google, BumpTop

669 Posts1618 Follower 295 Folgt

Patrick Dubroy @dubroy.com · 2mo ago

Another great post from @thorstenball.com: Building software is learning → registerspill.thorstenball.com/p/building-s...

Building Software Is Learning

An internal note to the Amp team on feedback and shipping faster

registerspill.thorstenball.com

Patrick Dubroy @dubroy.com · 2mo ago

Tag yourself, I'm "future altered by doing request"

A diagram illustrating a request-response communication pattern between two services, labelled "Figure 2: Requests for Work"

It shows two white boxes, labelled "service A" and "service B" on a teal background. It clockwise order, it reads:

(service A) hopeful for the future…decides to issue request → request → (service B) minding own business → (service B) future altered by doing request → response → (service A) hopes fulfilled, the future is now

Patrick Dubroy @dubroy.com · 2mo ago

New blog post: Fast is better than slow → dubroy.com/blog/fast-is...

About 10 years ago, I realized all the best programmers I had worked with had something in common: they were fast. By that I mean that they moved quickly: we’d discuss a problem and an hour or two later they’d already have a patch ready or a prototype to show off.

It took me a while, but eventually I realized: they weren’t fast because they were great programmers, they were great programmers because they were fast.

Think about it — if you’re fast, you get data more quickly. That helps you make better decisions, sooner. It also means you learn faster, and over longer periods it means you learn more. Being fast also means you can try out multiple approaches to a problem and pick the best one.

A lot of people push back on this because it sounds like hustle culture. But there are lots of ways to move faster that don’t involve working long hours. Jamie Brandon has written a pair of excellent posts on this: Speed matters and Moving faster. You should go and read those if you haven’t already.

I have a few suggestions of my own — things that are a bit more about the messy reality of working as a software engineer than they are about coding per se. And I’m slightly embarrassed to admit that, unlike Jamie, they took me more than a decade to learn.

Patrick Dubroy @dubroy.com · 4mo ago

"You don't know which afternoon of debugging was the one that taught you something fundamental about your data until three years later, when you're working on a completely different problem and the insight surfaces" ergosphere.blog/posts/the-ma...

The machines are fine. I'm worried about us.

On AI agents, grunt work, and the part of science that isn't replaceable.

ergosphere.blog

Patrick Dubroy @dubroy.com · 4mo ago

TIL: Python signal handling → github.com/pdubroy/til/...

Python signal handling
I've written signal handlers in Python many times before, but never looked deeply into the exact mechanics until today.

Here's a simple example of a SIGINT handler:

import signal

def handler(signum, frame):
print('Signal handler called with signal', signum)

signal.signal(signal.SIGINT, handler)
Some questions I had, along with the answers that I discovered:

Q: When does handler run, and how it is interleaved with whatever's happening on the main thread?

Answer:

A Python signal handler does not get executed inside the low-level (C) signal handler. Instead, the low-level signal handler sets a flag which tells the virtual machine to execute the corresponding Python signal handler at a later point (for example, at the next bytecode instruction).

and

Python signal handlers are always executed in the main Python thread of the main interpreter, even if the signal was received in another thread.

(From the doc for the signal module)

Q: Isn't this kind of scary? So the main thread can be preempted at an arbitrary point to run the signal handler?

Answer:

Unfortunately, yes! This also means:

Warning: Synchronization primitives such as threading.Lock should not be used within signal handlers. Doing so can lead to unexpected deadlocks.

So the restrictions are pretty similar to C — see the signal-safety(7) man page.

Q: Ok, so what's the recommended pattern?

A: On option is to just assign to a global variable in the handler (shutdown_requested = True), and do the actual handling in your main loop or whatever. But in many cases you may need some way to park/wake the code in the main loop. In C you can use the self-pipe trick; Python has built-in support for this with signal.set_wakeup_fd().

How deadlock can occur
It's interesting to look at exactly how deadlock can occur. Here's the implementation of Event from cpython/Lib/threading.py:

def __init__(self):
self._cond = Condition(Lock())
self._flag = False

# ...

def wait(self, timeout=None):
with self._cond:
signaled = self._flag
if not signaled:
signaled = self._cond.wait(timeout)
return signaled
So the main thread could get preempted after acquiring the lock, but before the wait. Then suppose the signal handler tried to use the set() method on Event. Here's how it's defined:

def set(self):
with self._cond:
self._flag = True
self._cond.notify_all()
…so you'd have a self-deadlock when the main thread tried to acquire a lock again in the handler.

CodeTV @codetv.dev · 4mo ago

Did you miss @dubroy.com teaching us about WebAssembly No worries! Check out our conversation on the Web Dev Podcast, then code along with us on Learn with Jason. WDP: codetv.dev/series/web-d... LWJ: codetv.dev/series/learn...

WebAssembly is not as hard as it seems | The Web Dev Podcast Series 1

Its common to only hear Wasm talked about in contexts that seem… advanced. How can mere mortals like us hope to build with it? Patrick Dubroy talks about flattening the learning curve and putting…

codetv.dev

Patrick Dubroy @dubroy.com · 4mo ago

New post on the @ohmjs.org blog — Inside Ohm's PEG-to-Wasm compiler → ohmjs.org/blog/2026/03... v18 is now more than 50x faster for real-world grammars while using about 10% of the memory 🔥 …this post goes into the details of how it's built.

Bar chart comparing performance improvements across three technologies: JSON shows 15.6ms (v17) reduced to 0.35ms (v18), a 44.6x speed increase; LiquidHTML shows 2,250ms (JS) reduced to 36ms (Wasm), a 62.8x speed increase; and ES5 shows 3,308ms (JS) reduced to 55ms (Wasm), a 60.3x speed increase. Blue bars represent 'Before' measurements and green bars represent 'After' measurements

Patrick Dubroy @dubroy.com · 5mo ago

Love this — microui: A tiny, portable, immediate-mode UI library written in ANSI C → github.com/rxi/microui Only around 1100 SLoC (!)

GitHub - rxi/microui: A tiny immediate-mode UI library

A tiny immediate-mode UI library. Contribute to rxi/microui development by creating an account on GitHub.

github.com

Patrick Dubroy @dubroy.com · 5mo ago

In 30 minutes!

CodeTV@codetv.dev · 5mo ago

⚠️ In 90 Minutes WASM is one of those technologies that we hear about all the time, but how many of us are actually able to take advantage of it? @dubroy.com teaches us first steps toward becoming fluent in WebAssembly. Details:

Patrick Dubroy @dubroy.com · 5mo ago

Tomorrow at 17:20 CET / 12:20 EDT / 9:20 PDT, I'll be livestreaming at twitch.tv/jlengstorf, teaching @jason.energy about WebAssembly!! I'll do my best to condense the best parts of our Wasm book (@wasmgroundup.com) into ~60 minutes. 😄

Twitch

Twitch is the world

twitch.tv

Patrick Dubroy @dubroy.com · 5mo ago

Looking forward to a couple of @ohmjs.org- and @wasmgroundup.com-related things next week: 1️⃣ Talking about PEG-to-#Wasm compilation in Ohm v18 at MoreVMs: 2026.programming-conference.org/home/MoreVMs... 2️⃣ Live-streaming with @jason.energy on Thursday at 17:30 CET, teaching him about WebAssembly.

MoreVMs 2026 - MoreVMs'26 - ‹Programming› 2026

The 10th MoreVMs workshop aims to bring together industrial and academic programmers to discuss the design, implementation, and usage of modern languages and runtimes. This includes aspects such as re...

2026.programming-conference.org

Patrick Dubroy @dubroy.com · 5mo ago

One more time — I'm looking for new consulting clients. Some ways I can help: ∙ Fractional tech leadership (tackling "leadership debt" in small eng orgs) ∙ Full-stack, 0 to 1 projects ∙ Language design & impl (eg with @ohmjs.org) ∙ JavaScript/TypeScript perf (🔁 appreciated)

Patrick Dubroy@dubroy.com · 5mo ago

Also I finally put together a consulting/ page, for anyone who's interested in working with me. dubroy.com/consulting/ Did I mention I still have availability this year? 😇

Consulting
I do technical advising and freelance development for companies big and small.

Some recent examples:

Part-time advising for a small startup, doing regular 1-on-1s with the CTO and selected ICs. Advised on technical architecture and team issues, and helped them hire a Head of Engineering and their first Staff Engineer.
Worked with HCI pioneer Michel Beaudouin-Lafon and his research group to build a fully incremental processing pipeline for Asciidoc with Ohm.
For a research group investigating parametric CAD/CAE systems, implemented a GPU-based interpreter (in Rust and WGSL) for rendering implicit surfaces.
For engineering projects, I’m especially interested in work where I can combine my deep systems expertise with frontend development and UX work.

Patrick Dubroy @dubroy.com · 5mo ago

What I'm up to now → dubroy.com/now/ ∙ Teaching another Scratch course ∙ Still have availability in 2026 for consulting ∙ Ohm v18 is now ~50x faster than v17 🔥 ∙ Invited talk at MoreVMs next week ∙ Live pair programming with @jason.energy next Thursday at ~17:30 CET!

Spring has sprung over here; I’m enjoying the sunshine.

I’m teaching another Scratch course at my kids’ Montessori school. It’s 90 minutes once a week for 5 weeks, and this time, the theme is “programming artificial life”:

Learn programming and create your own interactive digital creature. First, you’ll design your character (on paper or on the iPad). Then you learn how to give it behaviour in Scratch. Let it walk across the screen, search for food, decide when it needs to sleep. Turn your iPad into a virtual world!

The bee-like thing above is my creature, of course. It flaps its wings, gets happy when you feed it ants, and loves when you “pet” it with your cursor.

I still have availability for new consulting projects in 2026. I also finally put together a consulting page in case you’re curious how I could help you. I’m always happy to chat about potential projects, so feel free to get in touch.

Over the past few weeks, I’ve been finishing up the last little bits of WebAssembly support in Ohm, and officially announced the v18 beta. I’ve continued to make performance improvements, and am pretty psyched that it’s now about 50x faster on real-world grammars 🔥.

Speaking of Ohm, I’ve been invited to do a talk at the MoreVMs Workshop next week. So I’ve been spending time preparing that.

And I’ll be doing live pair programming with Jason Lengstorf on Learn with Jason on Thursday, March 19. You should tune in!

Patrick Dubroy @dubroy.com · 5mo ago

TIL: Multithreaded WebAssembly → github.com/pdubroy/til/... (corrected)

Just like in JavaScript, you can do shared memory multithreading in WebAssembly! I've long known this was possible, but until the other day, had never actually played with it myself, so I decided to put together a small, self-contained example.

(This is for Node, but it's pretty much the same in the browser.)

Details
Structured cloning of WebAssembly.Module
Normally you'd instantiate a Wasm module with WebAssembly.instantiate, which gives you a module instance. Here, we use WebAssembly.compile, which gives us a WebAssembly.Module. This is a stateless object that is structured-cloneable, which allows it to be safely shared across realm boundaries.

Serialization (an implicit part of structured cloning) of WebAssembly modules is defined in §3 of the WebAssembly Web API, which says:

Engines should attempt to share/reuse internal compiled code when performing a structured serialization, although in corner cases like CPU upgrade or browser update, this might not be possible and full recompilation may be necessary.

Shared memory
WebAssembly.Memory also support structured cloning. When we pass shared: true, the buffer property is a SharedArrayBuffer:

The structured clone algorithm accepts SharedArrayBuffer objects and typed arrays mapped onto SharedArrayBuffer objects. In both cases, the SharedArrayBuffer object is transmitted to the receiver resulting in a new, private SharedArrayBuffer object in the receiving agent (just as for ArrayBuffer). However, the shared data block referenced by the two SharedArrayBuffer objects is the same data block, and a side effect to the block in one agent will eventually become visible in the other agent.

Atomic add
The last piece of the puzzle is the i32.atomic.rmw.add instruction used in the addId function:

(func (export "add") (result i32)
;; mem[0] += workerId
i32.const 0
global.get 0
i32.atomic.rmw.add))
This instruction is defined in the threads proposal (a Stage 4 proposal, so not finalized yet), which defines "a new shared linear memory type and some new operations for atomic memory access".

i32.atomic.rmw.add is equivalent to LOCK XADD on x86. As described in the threads proposal:

Patrick Dubroy @dubroy.com · 5mo ago

A while back, someone in the @wasmgroundup.com Discord asked about resources for learning the formal notation used in the WebAssembly spec. One I like is Jeremy Siek's "Crash Course on Notation in Programming Language Theory": siek.blogspot.com/2012/07/cras...

Crash Course on Notation in Programming Language Theory

This blog post is meant to help my friends get started in reading my other blog posts, that is, this post is a crash course on the notation ...

siek.blogspot.com

Patrick Dubroy @dubroy.com · 5mo ago

TIL: Fibonacci hashing → https://github.com/pdubr...

$It comes up rarely, but on a few projects I've wanted a dead simple hash table implementation. Most recently, it was for an experiment in the Ohm WebAssembly compiler. When I'm compiling a grammar, I assign each rule name a unique ID, but I wanted a fixed size cached (e.g. 8 or 32 items) keyed by rule ID. I discovered Fibonacci hashing, aka "Knuth's muliplicative method": So here's the idea: Let's say our hash table is 1024 slots large, and we want to map an arbitrarily large hash value into that range. The first thing we do is we map it using the above trick into the full 64 bit range of numbers. So we multiply the incoming hash value with 2^64/φ ≈ 11400714819323198485. (the number 11400714819323198486 is closer but we don't want multiples of two because that would throw away one bit) Multiplying with that number will overflow, but just as we wrapped around the circle in the flower example above, this will wrap around the whole 64 bit range in a nice pattern, giving us an even distribution across the whole range from 0 to 2^64. To illustrate, let's just look at the upper three bits. So we'll do this: size_t fibonacci_hash_3_bits(size_t hash) { return (hash * 11400714819323198485llu) >> 61; } All we have to do to get an arbitrary power of two range is to change the shift amount. So if my hash table is size 1024, then instead of just looking at the top 3 bits I want to look at the top 10 bits. So I shift by 54 instead of 61. Easy enough. It turns out the Linux kernel has used this for ~6 years; here's the comment from include/linux/hash.h: /* * This hash multiplies the input by a large odd number and takes the * high bits. Since multiplication propagates changes to the most * significant end only, it is essential that the high bits of the * product be used for the hash value. * * Chuck Lever verified the effectiveness of this technique: * http://www.citi.umich.edu/techreports/reports/citi-tr-00-1.pdf * * Although a random odd number will do, it turns out that the golden * ratio phi = (sqrt(5)-1)/2, or its negative, has particularly nice * properties. (See Knuth vol 3, section 6.4, exercise 9.) * * These are the negative, (1 - phi) = phi**2 = (3 - sqrt(5))/2, * which is very slightly easier to multiply by and makes no * difference to the hash distribution. */ #define GOLDEN_RATIO_32 0x61C88647 #define GOLDEN_RATIO_64 0x61C8864680B583EBull Why would you use this? (I may get some details of this explanation wrong, because hashing and hash table sizing are a surprisingly complex subject!) If I understand correctly, it makes sense to use this if (a) you don't have access to a good hash function, and (b) you want power-of-two (not prime) table sizes; and/or (c) you want the bucket calculation operation to be as fast as possible. (A multiplication plus a shift is significantly faster than modulo/division.)$

Patrick Dubroy @dubroy.com · 5mo ago

My 80/20, grug-brained personal productivity system: - Cool stuff: URLs, books, movies, etc. I want to remember. - Useful stuff: how/where/etc for things I do a few times a year. - Cooked: for cooking/baking: what recipe (URL or book), any adjustments I made, how it turned out.

Raycast Notes search interface, with three notes highlighted with blue rectangles: 'Useful stuff’ (preview shows “Replacement parts for Roborock…”), 'Cool stuff’, and 'Cooked’ (preview shows “2026-02-12: Made gyoza again…”).

Patrick Dubroy @dubroy.com · 5mo ago

TIL that everyone who installs the Vercel CLI now gets a copy of @ohmjs.org

OhmJS@ohmjs.org · 5mo ago

Whoah. Today we discovered that ohm-js is now a "high-impact" NPM package (>1M downloads/week). The mystery was: why? Turns out it's now a transitive dependency of the Vercel CLI, via pip-requirements-js, an Ohm-based package for parsing requirements.txt files: github.com/Twixes/pip-r...

Line chart showing weekly downloads for the npm package "ohm-js" from February 28, 2025 to February 26, 2026. The graph displays relatively flat growth at around 200,000 weekly downloads for most of the year, then shows dramatic exponential growth starting in late January 2026, skyrocketing from approximately 200,000 to 1.8 million weekly downloads by late February 2026. The y-axis shows weekly downloads ranging from 0 to 1.8M, and the x-axis shows dates with major tick marks every few months

WebAssembly from the Ground Up @wasmgroundup.com · 5mo ago

Is it the end of February already?? Yes, yes it is. Which means we just sent out our #Wasm tidbits. Sign up here to get it in your inbox once a month (ish): sendfox.com/wasmgroundup

Ahoy!

Hope your February has been swell. Here in southern Germany, it's been a relatively snowy winter…but it's finally starting to feel like spring.

First and foremost, we wanted to let you know that we published a new blog post last week, A WebAssembly interpreter (Part 2). In Part 1, we created a simple Wasm interpreter from scratch, but it was only able to evaluate expressions consisting of literals. In the latest post, we add support for local and global variables. Give it a look!

And here are your Wasm tidbits for February:
• "WebCC is a lightweight, zero-dependency C++ toolchain and framework for building WebAssembly applications. It provides a direct, high-performance bridge between C++ and HTML5 APIs." And then there's Coi, "a modern, component-based language for building reactive web apps", which is built on WebCC.
• Marimo is an open-source reactive Python notebook; like Jupyter, but better in many ways (no hidden state, stored as pure Python files, …). And it also supports WebAssembly notebooks, powered by Pyodide; in other words, Wasm notebooks execute entirely in the browser, without a backend executing Python.
• Along the same lines: Pandoc for the People is a fully-featured GUI interface for Pandoc (probably the most-used Haskell program ever). It lets you run any kind of conversion that pandoc supports, without the documents ever leaving your computer. It's based on the recent Pandoc 3.9 release, which supports Wasm via the GHC wasm backend.

Patrick Dubroy @dubroy.com · 5mo ago

Starting another Scratch course at my kids' (Montessori) school today. A bit different this time — the theme is "artificial life". Taking some inspiration from @shiffman.lol's natureofcode.com

Programmierung künstlichen Lebens in Scratch

Lerne Programmieren und erstelle dein eigenes, interaktives, digitales Wesen. Zuerst entwirfst du deine Figur (auf Papier oder auf dem iPad). Dann lernst du, wie du ihr in Scratch Verhalten gibst. Lass sie über den Bildschirm laufen, nach Futter suchen, entscheiden, wann sie schlafen muss. Dein iPad wird zu einer virtuellen Welt!

Programming Artificial Life in Scratch
Learn programming and create your own interactive digital creature. First, you design your character (on paper or on the iPad). Then you learn how to give it behaviour in Scratch. Let it walk across the screen, search for food, decide when it needs to sleep. Your iPad becomes a virtual world!

Patrick Dubroy @dubroy.com · 5mo ago

slowmo.dev by @seflless.bsky.social is pretty damn cool — "Slow down, pause, or speed up time of any web content." Here's how it works.

* This library intercepts time at multiple levels to slow down (or speed up)
* all animations on a web page.
*
* ## How it works:
*
* 1. **requestAnimationFrame patching**: We replace window.requestAnimationFrame
* with a wrapper that passes modified timestamps to callbacks. Time-based
* animations that use the timestamp parameter will automatically slow down.
*
* 2. **performance.now() patching**: We replace performance.now() to return
* virtual time. Libraries that use this for timing will be affected.
*
* 3. **Date.now() patching**: We replace Date.now() to return virtual epoch
* milliseconds. Libraries like Motion/Framer Motion use this for timing.
*
* 4. **setTimeout/setInterval patching**: We scale delays by inverse of speed
* so timed callbacks fire at the expected virtual time.
*
* 5. **Web Animations API**: We poll document.getAnimations() and modify the
* playbackRate of all Animation objects. This affects CSS animations,
* CSS transitions, and element.animate() calls.
*
* 6. **Media elements**: We set playbackRate on video/audio elements.
*
* ## Limitations:
*
* - Frame-based animations (that increment by a fixed amount per frame without
* using timestamps) cannot be smoothly slowed down.
*
* - Animations created by libraries that cache their own time references
* before we patch may not be affected. The Chrome extension runs at
* document_start to minimize this issue.

a ton of crates @tonofcrates.bsky.social · 5mo ago

people often don't appreciate how dramatically the intensity of knowledge work, especially in STEM, has changed in the last 60 years even prior to the advent of AI. tough to imagine that a scientist would spend most of their time literally plotting data

Bild

Patrick Dubroy @dubroy.com · 5mo ago

TIL: Set difference vs symmetric difference → https://github.com/pdubr...

I just spent an annoying 30 minutes debugging an issue caused by a silly mistake —

I wanted to verify that two sets had the same contents. So I wrote something like this:

assert(newSet.difference(oldSet).size === 0, 'sets are different!')
But this doesn't detect if oldSet has some items that aren't in newSet! What I should have been using was symmetricDifference:

assert(newSet.symmetricDifference(oldSet).size === 0, 'sets are different!')
Both of these methods are Baseline 2024 features.

On the names
Swift's name for difference is subtracting, which less confusing imo.

I decided to see where the naming was discussed on the original TC39 proposal, and found tc39/proposal-set-methods#7, with a the following comment from tabatkins

Sorry for this being back-and-forth, but difference has the same lack of implicit ordering as complement did — it's not immediately, intuitively clear which element's values are retained. minus and subtract are both good; removeAll, while it implies mutation semantics, is also extremely clear and good in this regard.

Related: "symmetricDifference" vastly exceeds my design instincts for what is an allowable level of spelling difficulty in an API. "symmetric" is not an easy word to spell (my fingers just now tried to type it with a single "m"!), and combined with another 10 letters after, it's huge and terrible. xor has a non-obvious meaning for many people, including native English speakers, but it's short and easy to spell; unsure if it's good enough or not.

Interestingly, the conclusion in that thread was to use except. There was further discussion in #24: Method names should pick a theme, but I couldn't figure out where (or why) they decided on difference.

Patrick Dubroy @dubroy.com · 5mo ago

Finally! 😅

WebAssembly from the Ground Up@wasmgroundup.com · 5mo ago

We've released a new version of @wasmground/emit — the small, simple #Wasm 1.0 "assembler library" for JS/TS, which we build up piece by piece in our book. The headline feature: proper TypeScript types! Give it a spin and let us know what you think: www.npmjs.com/package/@was...

$import * as w from "@wasmgroundup/emit"; const mod = w.module([ w.typesec([w.functype([w.valtype.i32, w.valtype.i32], [w.valtype.i32])]), w.funcsec([w.typeidx(0)]), w.exportsec([w.export_("add", w.exportdesc.func(w.funcidx(0)))]), w.codesec([ w.code( w.func( [], w.expr([ [w.instr.local.get, ...w.i32(0)], [w.instr.local.get, ...w.i32(1)], w.instr.i32.add, ]), ), ), ]), ]); const { instance } = await WebAssembly.instantiate(w.flatten(mod)); const { add } = instance.exports as { add: (a: number, b: number) => number }; console.log(add(1, 2)); // 3$

Patrick Dubroy @dubroy.com · 5mo ago

TIL: api-extractor → github.com/pdubroy/til/...

The new version of ohm-js (v18), is now in beta. It's written in TypeScript, whereas v17 was written in JavaScript with manually-updated type definitions.

I was looking for a way to make sure that I don't accidentally make changes to the API, which led me to api-extractor:

API Extractor is a TypeScript analysis tool that produces three different output types:

API Report - API Extractor can trace all exports from your project's main entry point and generate a report to be used as the basis for an API review workflow.

.d.ts Rollups - Similar to how Webpack can "roll up" all your JavaScript files into a single bundle for distribution, API Extractor can roll up your TypeScript declarations into a single .d.ts file.

API Documentation - API Extractor can generate a "doc model" JSON file for each of your projects. This JSON file contains the extracted type signatures and doc comments. The api-documenter companion tool can use these files to generate an API reference website, or you can use them as inputs for a custom documentation pipeline.

How I'm using it
In each package, I have an api-extractor.json like this:

{
"$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
"mainEntryPointFilePath": "./dist/index.d.ts",
"apiReport": {
"enabled": true,
"reportFolder": "./"
},
"newlineKind": "lf",
"dtsRollup": {
"enabled": false
},
"docModel": {
"enabled": false
},
"messages": {
"extractorMessageReporting": {
"ae-missing-release-tag": { "logLevel": "none" },
"ae-forgotten-export": { "logLevel": "none" }
}
}
}
Note that I'm only using API reports for now — no .d.ts rollup or documentation. (I'm using tsdown as well, which already bundles my types into a single .d.ts.)

Then, in my package.json, I have a package script named api-report:

{
"name": "@ohm-js/compiler",
"version": "18.0.0-beta.8",
// ...
"scripts": {
"api-report": "api-extractor run",
// ...
},
// ...
}
This script runs in CI. When it's run, if the API report has changed, I get an error like this:

> @ohm-js/compiler@18.0.0-beta.8 api-report /Users/pdubroy/dev/ohmjs/ohm/packages/compiler
> api-extractor run

api-extractor 7.56.3 - https://api-extractor.com/

Using configuration from ./api-extractor.json
Analysis will use the bundled TypeScript version 5.8.2
Warning: You have changed the API signature for this project. Please copy the file "temp/compiler.api.md" to "compiler.api.md", or perform a local build (which does this automatically). See the Git repo documentation for more info.

API Extractor completed with warnings
ELIFECYCLE Command failed with exit code 1

Patrick Dubroy @dubroy.com · 6mo ago

Looking forward to this — I'll be doing an invited talk at MoreVMs in Munich on March 17. Hope to see some of you there!

Stefan Marr@stefan-marr.de · 6mo ago

A bit late and not yet finalized, but our program for MoreVMs'26 is online. Early registration deadline is in a few hours, but will remain open afterwards still. Join us in Munich for a day of talks around language implementation! 2026.programming-conference.org/home/MoreVMs...

Patrick Dubroy @dubroy.com · 6mo ago

So excited to officially released the beta version! It's been a lot of work over the past ~year.

OhmJS@ohmjs.org · 6mo ago

A couple big announcements for y'all — 1️⃣ We have a blog now! 2️⃣ We just published the beta version of Ohm v18: ohmjs.org/blog/ohm-v18 Give it a spin and tell us what you think!

WebAssembly from the Ground Up @wasmgroundup.com · 6mo ago

Happy Friday! We just published a new blog post — A WebAssembly Interpreter: Part 2 → wasmgroundup.com/blog/wasm-vm... In the first post, we wrote a small #Wasm interpreter from scratch in JS. In Part 2, we extend the interpreter to support local and global variables.

A WebAssembly interpreter (Part 2)

Adding local and global variable support to our Wasm Interpreter

wasmgroundup.com

Patrick Dubroy @dubroy.com · 6mo ago

I'm extremely hyped about the performance of the upcoming (#Wasm-based) @ohmjs.org v18. !!! (please don't let this be a mistake in my benchmarking)

Performance comparison tables showing WebAssembly significantly outperforming JavaScript. In the "After" state: JS matching takes 3267ms with 1090.7MB memory while Wasm matching takes only 146ms with 174.5MB memory (22.4x faster). Overall, JS total is 2291ms compared to Wasm total of 100ms (22.99x speedup). Wasm uses dramatically less memory: 6.88 MB heap vs 247.52 MB for JS.

‹Programming› 2026 @programming-conf.bsky.social · 6mo ago

Final 24h! Early bird for #prog26 ends tomorrow, Feb 20. Don't miss the art & science of programming in Munich (Mar 16–20)! Register: 2026.programming-conference.org Submit to the Substrates workshop: 2026.programming-conference.org/home/substra...

‹Programming› 2026

The International Conference on the Art, Science, and Engineering of Programming—or ‹Programming› for short—is a new conference focused on programming topics including the experience of programming. ‹...

2026.programming-conference.org