Andrey Penechko MrSmith33

WIDL compiler incompatibilities with Windows SDK

I attempted to compile the IDL files distributed in https://github.com/microsoft/win32metadata/tree/master/generation/WinSDK/RecompiledIdlHeaders using the latest (7.0.1-rc.1) version of the Wine IDL compiler, called WIDL. Unlike Microsoft's MIDL compiler which ships with Visual Studio, WIDL is open source.

More importantly, WIDL contains patches to generated header files that make e.g. COM calling conventions compatible with mingw-w64 and clang when targetting GNU ABI.

Bugs
- Imports are incorrectly case sensitive
- WIDL does not allow double slashes in string literals
Segmentation faults

A quick breakdown of lighting in the restir-meets-surfel branch of my renderer, where I revive some olde surfel experiments, and generously sprinkle ReSTIR on top.

General remarks

Please note that this is all based on work-in-progress experimental software, and represents a single snapshot in development history. Things will certainly change 😛

Due to how I'm capturing this, there's frame-to-frame variability, e.g. different rays being shot, TAA shimmering slightly. Some of the images come from a dedicated visualization pass, and are anti-aliased, and some show internal buffers which are not anti-aliased.

Final images

Approachable PL Papers for Undergrads

On September 28, 2021, I asked on Twitter:

PL Twitter:

you get to recommend one published PL paper for an undergrad to read with oversight by someone experienced. the paper should be interesting, approachable, and (mostly) self-contained.

what paper do you recommend?

A traditional table-based DFA implementation looks like this:

uint8_t table[NUM_STATES][256]

uint8_t run(const uint8_t *start, const uint8_t *end, uint8_t state) {
    for (const uint8_t *s = start; s != end; s++)
        state = table[state][*s];
    return state;
}

	#!/usr/bin/env scheme --script

	(import (nanopass))

	(define unique-var
	(let ()
	(define count 0)
	(lambda (name)
	(let ([c count])
	(set! count (+ count 1))

	#include <bench_path.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include "entt.hpp"

	#define MILLION (1000 * 1000)
	#define BILLION (1000 * MILLION)

	#define ENTITY_COUNT (255)
	#define COMPONENT_COUNT (10)

	import re
	import sys
	import fontforge

	print(f"MSDF Multi-Font Merger & Generator! Python {sys.version}")

	merged = None
	#merged = fontforge.font()
	#merged.fontname = "merged"
	#merged.encoding = "UnicodeFull"

	package objc_test

	import NS "vendor:darwin/Foundation"
	import MTL "vendor:darwin/Metal"
	import CA "vendor:darwin/QuartzCore"

	import SDL "vendor:sdl2"

	import "core:fmt"
	import "core:os"

	// See <https://gist.github.com/pervognsen/b58108d134824e61caedffcc01004e03> for
	// Per Vognsen gist on value speculation.
	//
	// I compile this on linux with
	//
	// $ clang --version
	// clang version 12.0.0
	// Target: x86_64-unknown-linux-gnu
	// $ clang -static -Wall -O3 value-speculation-linux.c -o value-speculation-linux
	//

	INLINE
	u32 index(Ref r) {
	return r >> 4;
	}

	INLINE
	u32 tag(Ref r) {
	return r & 15;
	}