The populist spectrum describes political movements on a scale from populist to elitist.

Revolutionary

Political revolution is the extreme of populism. It rejects the political process entirely and uses direct action instead.

The Velvet Revolution was a very popular revolution in Czechoslovakia, mainly consisting of protests and strikes. The fact that it was largely nonviolent actually makes it less populist, because this constitutes some degree of compliance with the laws of the regime.

The Russian Revolution was similar, although perhaps not as popular, seeing as it devolved into civil war. It was also much more violent. You can’t really get more populist than murdering the royal family.

Populist

Populism, after which the populist spectrum is named, is somewhere in the middle of the spectrum. Populism is not revolutionary, and works within the system to elect an outsider. These movements will criticise the status quo, accusing it of dysfunction or outright corruption. They will often scapegoat a specific group of people, such as minorities, extremists or capitalists. They will also make some attempt to dismantle institutions, depending on how committed they are.

Adolf Hitler was a very successful populist. He initially pursued power through revolutionary means but eventually found success within the electoral system. Even during his dictatorship, he held up a veneer of legality and democracy. He scapegoated several groups, especially Jews, but really anyone who was not an ideal Nazi loyalist.

Popularist

Popularism is a strategy where establishment politicians focus on bipartisan legislation and popular policies. This is essentially just a representative democracy working as intended.

Bill Clinton was a successful popularist. He mostly pursued popular, centrist and sometimes even conservative policies using a Nixon goes to China style strategy called triangulation. This contributed to his reelection and average approval of 55%, making him the 5th most popular president.

Elitist

Elitism is rule by experts, professionals, aristocrats, monarchs, dictators, one-party states or philosopher kings. While these governments are often authoritarian for historical reasons, that is not what defines this end of the spectrum. What makes a government elitist is if decisions are made by leaders and not the public.

A good example of modern elitism is the chair of the Federal Reserve. The chair is nominated by the president and confirmed by the senate, so they’re elected by other elitists and only have an indirect democratic mandate. Furthermore, the chair is historically selected from elite institutions, and the position requires technical expertise, so there is little room for demagoguery.

• Initiating a global trade war
• Withdrawing from the Paris Agreement
• Withdrawing from the WHO
• Withdrawing from UNHRC
• Withdrawing from UNESCO
• Withdrawing from the INF Treaty
• Withdrawing from the Treaty on Open Skies
• Withdrawing from the JCPOA
• Withdrawing from the GMCT
• Cutting USAID funding
• Cutting PEPFAR funding
• Cutting UNRWA funding
• Cutting UNICEF funding
• Undermining the UN
• Undermining the EU

However, the overall foreign policy of the administration is not simply “isolationist”. If anything, they have followed a policy of interventionism, especially in the Western Hemisphere:

• Attempting to rename “Gulf of Mexico” to “Gulf of America”
• Proposing the annexation of Canada
• Proposing the annexation of Greenland
• Threatening military intervention in Panama
• Threatening military intervention in Venezuela
• Sanctioning the president of Colombia
• Pardoning the former president of Honduras
• Threatening to cut foreign aid if a Honduran presidential candidate is not elected
• Using sanctions, tariffs and visa revocations to prevent the prosecution of the president of Brazil
• Opening a $20b swap line with Argentina
• Imprisoning deportees in El Salvador
• Killing 105 alleged drug traffickers in the Caribbean and Pacific
• Seizing and blockading Venezuelan oil tankers

I would describe this as a shift towards a continental strategy, rather than simply “isolationism” or “interventionism”. This basically means America is becoming more like Russia: isolated from the international community while bullying its neighbours.

This has been difficult for people to process, especially because America found so much success as the foremost maritime power. It often seems that Trump’s foreign policy is unpredictable, contradictory or heavy-handed. However, this behaviour makes sense once you understand that Trump has a zero-sum worldview, admires continental powers, and prefers an aggressive negotiation style.

This zero-sum paranoia is what leads to the idea that trade deficits are betrayals, that alliances benefit small countries only at the expense of large countries, or that minor powers need to be controlled rather than uplifted. So while this new foreign policy may seem like sabotage by a foreign asset, the more simple explanation is that it’s a strategic misstep caused by ideology.

Many in the international community, especially Europeans, feel betrayed by America. At a time when we are most in need of international cooperation, the supposedly pro-Western president decides to take a critical view of the UN, the EU, NATO and Ukraine. The coalition of the willing followed America into the Middle East, but when Russia invades Europe: “It’s a war in another continent. We’ve got issues in our own hemisphere we need to be dealing with.”

Some internationalists are reacting pessimistically: that we can no longer trust the United States, and that we will need to become independent from this former ally. I find this to be equally isolationist. In the international order, we don’t cut ties. Russia is still in the UN. Hungary is still in the EU. The point of internationalism is that we use democracy, diplomacy, free trade and soft power to make it easy to be a good guy and difficult to be a bad guy. Of course it hurts when good guys turn bad, but you should be working with them, not ignoring the problem. What if Russia’s wartime economy starts to collapse? What if the pro-EU party wins the 2026 Hungarian election?

Conversely, some are reacting naively: that this populism thing is just a fad, and that we just need to wait until 2028 to get an internationalist president. This is similarly counterproductive. Autocratisation is a global trend — not just an American one.

Number of countries experiencing autocratisation and democratisation since 1900

This trend will put international institutions to the test. We will have to sanction. We will have to spend on defence. We will have to form new alliances. Every parliament will have to struggle against populist movements.

Don’t give up.

The Cambridge Analytica scandal in 2018 was the public’s introduction to the power accumulated in Silicon Valley. By this time it was an open secret that we are the product. But it wasn’t clear exactly how our information environment would change.

Would you prefer an environmental metaphor or a feudalism metaphor?

Silicon Valley is like the coal industry. In order to turn a profit, they must manufacture engagement, which creates waste products. An atmosphere of outrage increases the political temperature and causes extreme social events.

If you were addicted to Twitter on the 10th of September 2025, you were probably irradiated by the nuclear fallout of Charlie Kirk’s assassination. For You pages were almost entirely filled with content related to the event. The most inflammatory discourse floated to the top of the pile. Many users were exposed to footage of the brutal killing through Twitter’s autoplay feature. The site was flooded with speculation, misinformation, AI “enhanced” images, political extremism, doxxing and cancellations. Anyone naive to the attention economy might have thought America was about to implode. The victim of the killing was a culture warrior and the perpetrator was terminally online, and so the cycle continues.

Silicon Valley are like feudal lords. They make money by simply owning all the servers. They rent them out to the peasants who create all the information but own none of it. The peasants could revolt, but they don’t, and it will take some catastrophic event like the Black Death for the lords to lose power.

I like the analogy of a feudal manor, because the internet truly is a place where we live now. On the internet we work, play and learn. But this is rented space. There is no freedom of speech on a server owned by someone else. We don’t get to vote on the terms of service. They don’t even tell us what algorithms they’re using. We celebrated the death of the legacy media but we are now standing idly by while the new media is consolidated in the hands of a small group of unelected billionaires.

Will we unionise, by banding together under a browser extension? Or will we leave these sites and form cooperatives on the AT Protocol? If we do nothing, the government will surely subsume this democratic institution before it begins.

The fallacy is that it is up to the steamroller. It is up to the object whether it will be flattened or not.

In The Origins of Wokeness, Paul Graham outlines the rise and fall of the second wave of political correctness. He reports that the first wave took place throughout the 90s, and the second wave throughout the 2010s. I wasn’t around for the first wave, but I was for the second.

I should first make it clear that woke is an AAVE word that is almost 100 years old, but has since been repurposed. Regardless, “woke” is currently the designated term for this 2010s wave of political correctness.

Additionally, it seems “woke” is currently undergoing another semantic shift. With terms like dark woke, we are seeing signs of a post-ironic reclamation of wokeness.

So in short: woke in AAVE originally meant “social consciousness”, then was adopted by white progressives, then became a pejorative for progressivism, and is now being reclaimed by the left (with a meaning that is yet to be fully determined). So while the era of woke political correctness may be in decline, the usage of the term will likely continue.

Is it actually dying?

I have observed several examples of woke decline:

Offensive language

The central force of wokeness is word taboo. This is the ever-growing list of prohibited language. While taboo is an inherent feature of all languages, linguistic orthodoxy is one of the primary symptoms of political correctness.

But recently, we have seen a resurgence in derogatory terms like “gay” and “retard”, which have now become somewhat accepted on the left. For example the highly influential dirtbag left rejected political correctness on an anti-liberal basis, permitting offensive humour and usage of these more benign slurs.

Cancel culture

Another core mechanism of wokeness is mob policing. Because political discourse has moved increasingly online, public shaming has become effortless and instant.

This too resulted in massive overextension and a subsequent backlash. Most netizens are now sceptical of cancellations and have assumed a policy of “innocent until proven guilty”.

Ideology

There are also some ideological propositions that failed to gain traction: prejudice plus power, cultural appropriation, neopronouns, microaggressions and safe spaces, to name a few. These new rules were unpopular because they were, ironically, oppressive.

Establishment

Woke became the establishment. Socially, and to some extent politically. This kind of defeats the purpose. Wokeness was supposed to fight power, but it became power.

Why is it dying?

A simple explanation is that wokeness purity spiralled to death. Extremists found new ways to virtue signal, and moderates were conditioned to accept new standards of virtue. This process predictably ended in a market correction.

What is next?

The left appears to be reevaluating political correctness and free speech, especially in light of recent events such as the proliferation of online safety legislation, the crackdown on Palestine Action, the cancellations related to the assassination of Charlie Kirk and the designation of antifa as a terrorist organisation.

My guess is that the left will become more pro-speech, more irreverent and generally more pragmatic. This will be in reaction to peak woke, but also as a defence against the rise of the far-right. It’s an open secret that the left eats itself and would rather critique power than actually have any. Purity testing will be thrown out once external threats become sufficiently obvious.

The Cold War is coming to an end. The Berlin Wall has fallen. With fascism and communism defeated, Fukuyama declares the end of history. The announcer begins the introduction.

And now to honour America, especially the brave men and women serving our nation in the Persian Gulf, and throughout the world, please join in the singing of our national anthem.

America is 10 days into the Gulf War. They lead a 42-country coalition in a campaign to liberate Kuwait.

The United States enjoys the strongest military in the world, the largest economy, veto power in the UN, powerful positions in NATO and a dominant cultural export.

The anthem will be followed by a flyover of F-16 jets from the 56th Tactical Training Wing at MacDill air force base…

Those same F-16s have just established air superiority over Iraq.

…and will be performed by The Florida Orchestra under the direction of Maestro Jahja Ling and sung by Grammy Award winner Whitney Houston.

The performance is being broadcast to 750 million people around the world. And for the first time, in Russia. 14% of the world will hear John Clayton’s jazz arrangement of The Star-Spangled Banner.

Whitney Houston delivers what is now considered the best rendition of the US national anthem of all time.

The F-16s roar over the stadium. The coalition wins the war a month later.

But after the war, the presence of troops in Saudi Arabia would eventually become one of the motivations for the September 11 attacks. And it was the son of the Gulf War president who would lead the same coalition into the war on terror.

With a growing wealth divide, military overextension and protracted culture wars, America turned to cronyism, isolationism and fascism. It graduated from world police to global pariah.

Rest in peace.

Many US voters are unsatisfied with the two-party system. This post has nothing to do with specific voting preferences, but rather on rational voting within this system.

Most US elections are winner takes all. Third-party supporters are therefore faced with a dilemma: support their party with an inconsequential vote, or vote for the least bad two-party candidate.

This is a basic collective action problem. If all the supporters acted rationally, no votes would be wasted and the third-party would win (or at least the two-party system would start to crack).

In practice, voters don’t act monolithically, and so some supporters stick it out while others chicken out. Therefore the strategy is to grow support until the party becomes viable. Votes are wasted in the short-term, but have some potential to win a future election by persuading other supporters.

Is this strategy feasible? Technically yes. It would take a long time and the opportunity cost would be massive, but you could waste millions of votes on hundreds of elections and eventually break the two-party system.

Is it worth it? This depends on the expected utility of each party. If the third-party supporters expect the third-party to be massively favourable over the major parties, then there is no other option. If they expect the third-party to only be marginally better than the least bad party, then wasting votes becomes more wasteful.

Is it sustainable? Probably not. Even when you finally elect a third-party, the rules of the game don’t change. You’ve merely influenced the behaviour of the players.

But America isn’t a game theory puzzle. There are some real-world variables that are missing from this equation. Rules can be changed.

Remember when I said most US elections are winner takes all? This is because they use a first-past-the-post (FPP) voting system. In this system, whoever gets the most votes wins. Your third-party vote is wasted because you’re forced to choose a single candidate when you really wanted to express your preferences.

But there are several US elections which use ranked-choice voting (RCV)! In fact one of the most important US elections of this year, the 2025 NYC Democratic mayoral primary, used RCV. In Australia, we call this preferential voting, and we use it for almost all of our elections.

RCV would allow American voters to support minor parties without wasting their vote. In the 2016 US presidential election, over 7 million votes were wasted in an election with a margin of 3 million votes.

RCV changes the game rather than the outcome of a few matches. Voting for third parties in a two-party system is like bringing a baseball bat to a basketball game.

How does this change our strategy for US voters who are unsatisfied with the two-party system? Well, now the goal is to introduce RCV instead of winning elections. But even if you just wanted to win elections, a ranked-choice vote is the only realistic way of achieving this. In fact, passing RCV legislation is probably more likely than electing a third-party. Therefore your strategy should actually be to vote for the two-party candidate more likely to introduce RCV!

US House of Representatives, with 0 third-party representation

Australian House of Representatives, with 13 crossbenchers

If we make an AI that is more intelligent than us, or has more agency than us, it will almost certainly eliminate its competition. There is absolutely no reason to assume that its goals will align with ours.

AI alignment is not even close to being solved. We don’t even know if it’s solvable.

Pause AI development immediately.

In this post I will look at some metasyntaxes. These are general-purpose syntaxes that don’t have inherent semantics. Because a metasyntax describes a generic data structure instead of an AST, they are very easy to extend within the language through macros.

Syntax

Most programming languages have a 1:1 relationship between syntax tokens and the AST. You use keywords, delimiters and terminators to change the state of the parser.

def f(x, y) { print(x); print(y); }

def main() { f(1, 2); }

This is very easy to implement with a parser generator.

This approach is fine, and it’s what most programming languages do. However, these languages tend to become more complex over time, and we end up with a very large set of syntax rules. It would be much better if we had a single, predictable way to write expressions.

Metasyntax

S-expressions

With an s-expression syntax, you basically just parse a tree using parentheses. For example:

(def f (x y) (do (print x) (print y)))

(def main () (do (f 1 2)))

Everything is either a tree (f x ...) or an atom x.

You can see that even though it has built-in keywords like def and do, the parser will also recognise something like (table (1 2 3) (4 5 6)), and the language can provide some system to parse that tree within a program. That’s what Lisp’s metaprogramming system is.

Indentation trees

Another way to encode trees is with whitespace:

def f (x y)
  do
    print x
    print y

def main ()
  do (f 1 2)

There are a few ways of doing this, but here I’m using these rules:

1. Add an opening parenthesis to the start of each line
2. Add max(0, 1 - N) closing parentheses to the end of each line, where N is the change in indentation of the next line

You end up with this tree, which is identical to the previous s-expression:

(def f (x y)
  (do
    (print x)
    (print y)))

(def main ()
  (do (f 1 2)))

I like this metasyntax, because we already structure programs with indentation, this just makes it explicit. However based on my research, whitespace-sensitivity is very controversial! I also get the impression that most new languages are completely insensitive to whitespace.

B-expressions

Instead of parsing a rose tree with parentheses, you can also parse a binary tree with binary operators. I call these “b-expressions”.

f = x, y -> print x; print y.

main = () -> f 1 2

Everything is a binary expression f <op> x or an atom x.

• We use an “empty operator” for function application f x. In Haskell this is sometimes called the “whitespace operator”.
• We’re even using a “full-stop operator” to separate definitions, making the entire program one big binary expression.
• We’re using operator precedence and associativity, which removes the need for parentheses:

((f = ((x , y) -> ((print x) ; (print y)))) . (main = (() -> ((f 1) 2))))

This syntax is well-suited for expression-oriented functional programming languages.

I really like this metasyntax, but it does have some quirks.

First of all, it really needs operator precedence, otherwise it’s unwieldy. And if we get a user-defined operator x >>= y, we need a precedence declaration to figure out how to parse it. But we need to parse the program to get the precedence declaration… This is a bit of a chicken-and-egg problem.

Also, top-level expressions are a bit awkward. In my example I used a full-stop operator, similar to Coq. But unlike Coq, it’s a separator and not a terminator, so the last expression can’t actually end in anything.

et al.?

What other metasyntaxes are out there?

Inlining is the mother of all optimisations

- Rémi Forax (earliest source I could find)

Compiler vs Runtime

In programming language implementation, we often separate the compiler from the runtime. This is useful when generating code that remains constant.

For example, arithmetic and conditionals require generating very specific instructions, whereas a built-in data structure should be defined in the runtime system. The compiler can then generate instructions to call into the runtime API. This is especially pertinent if you’re using something like LLVM where generating instructions can be cumbersome.

So basically: if you find yourself defining a function via code generation, you should just define that function in a programming language.

This separation of concerns becomes practically unavoidable for high-level languages where you need to define closures, data structures, I/O, etc.

Link Your Runtime

Ok, so how do we actually use this technique? The most straightforward solution is to implement the programming language as an executable compiler and a runtime library. The compiler generates a binary which is then linked against the runtime library.

This is a fine solution, and I actually recommend it over some of the hacks that I’ll be describing in this post. However, it’s worth understanding some of the downsides of linking your runtime.

By separately compiling the executable and the runtime, we miss out on a lot of the optimisations available in LLVM. While the executable and the runtime can be optimised separately, information is lost in the boundary.

This is particularly problematic because this is the runtime of a programming language. Micro-optimisations actually matter here - a 1% improvement is a 1% improvement for every program.

Inline Your Runtime

Basically we want something like Link Time Optimisation (LTO), which can optimise across module boundaries.

LTO is a bit confusing and I don’t understand it. But basically, instead of linking object files, you tell the compiler (e.g. Clang) to emit something it can actually optimise (e.g. LLVM bitcode). This enables whole-program optimisation.

But how do we do that with the generated code and the runtime? Well, we could compile our runtime to LLVM bitcode ahead of time, generate our code as LLVM bitcode and then link them. For example if rts.bc is our runtime library and output.bc is our generated code:

$ llvm-link rts.bc output.bc -o main.bc
$ opt main.bc -o main.bc
$ llc --filetype=obj main.bc -o main.o
$ cc main.o -o main

Or in the case of JIT compiling:

$ llvm-link rts.bc output.bc -o main.bc
$ opt main.bc -o main.bc
$ lli main.bc

As you can see, this is pretty straightforward. Let’s see how we can actually generate the bitcode, and how we can use this LLVM functionality through the API.

Implementation

To properly implement this in a compiler, we can do the following:

• Build a runtime library
  • Use a Rust toolchain to compile the library to LLVM bitcode
• Build a compiler
  • Include the runtime library in the compiler
  • Link the compiler to the same LLVM version as the runtime library
  • Write some code to call our runtime API
  • Use the Rust toolchain to compile the compiler to a native executable

Toolchain

First we need a development environment which provides LLVM libraries for our compiler, and also a Rust toolchain that uses the same LLVM version.

flake.nix

{
  description = "Rust + LLVM";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.11";
    rust-overlay.url = "github:oxalica/rust-overlay";
    flake-utils.url = "github:numtide/flake-utils";
  };

  outputs =
    {
      self,
      nixpkgs,
      rust-overlay,
      flake-utils,
      ...
    }:
    flake-utils.lib.eachDefaultSystem (
      system:
      let
        overlays = [ (import rust-overlay) ];
        pkgs = import nixpkgs {
          inherit system overlays;
        };
        llvm = pkgs.llvmPackages_18.llvm;
      in
      {
        devShells.default = pkgs.mkShell {
          buildInputs = [
            llvm
            pkgs.valgrind
            pkgs.libffi
            pkgs.libxml2
            (pkgs.rust-bin.nightly."2024-07-31".default.override {
              extensions = [
                "rust-src"
                "rust-analyzer-preview"
                "miri"
              ];
            })
          ];
        };
      }
    );
}

I chose LLVM 18 because it’s supported by the Inkwell crate which provides high-level Rust bindings to LLVM.

We should verify that our LLVM versions match:

$ llvm-config --version
18.1.8

$ rustc -vV
rustc 1.82.0-nightly (f8060d282 2024-07-30)
binary: rustc
commit-hash: f8060d282d42770fadd73905e3eefb85660d3278
commit-date: 2024-07-30
host: x86_64-unknown-linux-gnu
release: 1.82.0-nightly
LLVM version: 18.1.7

Close enough.

To find a Rust version that uses a certain LLVM version, you can trawl through the Rust changelog.

Runtime

The next step is to build the runtime library.

rts/src/lib.rs

#![no_std]
#![allow(internal_features)]
#![feature(rustc_attrs, linkage)]

extern crate alloc;

use alloc::vec;
use alloc::{
    alloc::{GlobalAlloc, Layout},
    boxed::Box,
    vec::Vec,
};
use libc::{abort, aligned_alloc, c_void, free};

#[allow(unused_imports)]
use core::panic::PanicInfo;

struct Allocator;

unsafe impl GlobalAlloc for Allocator {
    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
        unsafe { aligned_alloc(layout.align(), layout.size()) as *mut u8 }
    }

    unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
        unsafe { free(ptr as *mut c_void) };
    }
}

#[global_allocator]
static GLOBAL: Allocator = Allocator;

#[cfg(not(test))]
#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
    unsafe { abort() }
}

#[rustc_std_internal_symbol]
#[linkage = "weak"]
fn __rust_alloc_error_handler(_size: usize, _align: usize) -> ! {
    unsafe { abort() }
}

#[rustc_std_internal_symbol]
#[linkage = "weak"]
#[allow(non_upper_case_globals)]
static __rust_no_alloc_shim_is_unstable: u8 = 0;

pub struct Foo {
    numbers: Vec<i32>,
}

impl Foo {
    #[no_mangle]
    pub extern "C" fn new_foo() -> Box<Foo> {
        Box::new(Foo {
            numbers: vec![1, 2, 3],
        })
    }

    #[no_mangle]
    pub extern "C" fn sum_foo(self: &Foo) -> i32 {
        self.numbers.iter().sum()
    }

    #[no_mangle]
    pub extern "C" fn free_foo(_foo: Box<Foo>) {}
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_rts() {
        let foo = Foo::new_foo();
        let result = foo.sum_foo();
        assert_eq!(result, 6);
        Foo::free_foo(foo);
    }
}

This is a pretty typical no_std library that just depends on libc. The only quirk is that we need to define __rust_alloc_error_handler and __rust_no_alloc_shim_is_unstable, which are special symbols inserted by the Rust compiler which are mysteriously not inserted when compiling to LLVM bitcode.

Our runtime system provides a simple API for allocating, summing and freeing a Foo. Imagine this is a very important built-in data structure in our language.

Verifying the correctness of the runtime system is extremely important. Any bug or vulnerability in this system compromises the security of every program in the language. Here we’re using both of the age-old techniques for program verification:

Types: by providing methods on an opaque pointer, we can write safe Rust code. You don’t have to write your runtime in C.

Tests: because our runtime is just a standalone library, we can develop a comprehensive test suite. We can use the Miri interpreter to verify the safety of any low-level code:

$ cargo miri test -p rts
   Compiling rts v0.1.0 (/home/will/Desktop/inline-your-runtime/rts)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.06s
     Running unittests src/lib.rs (target/miri/x86_64-unknown-linux-gnu/debug/deps/rts-b728a07dc5e60d37)

running 1 test
test test::test_rts ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.13s

   Doc-tests rts

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

Now we can compile the runtime library for consumption in the compiler.

Makefile

ARCH=x86_64-unknown-linux-gnu

.PHONY: debug
debug:
	$(MAKE) build DIR=debug PROFILE=dev

.PHONY: release
release:
	$(MAKE) build DIR=release PROFILE=release

.PHONY: build
build:
	RUSTFLAGS="--emit=llvm-bc" cargo build \
		--package rts \
		--profile $(PROFILE) \
		--target $(ARCH) \
		-Z build-std=core,compiler_builtins,alloc

	llvm-link \
		target/$(ARCH)/$(DIR)/deps/core-*.bc \
		target/$(ARCH)/$(DIR)/deps/compiler_builtins-*.bc \
		target/$(ARCH)/$(DIR)/deps/alloc-*.bc \
		target/$(ARCH)/$(DIR)/deps/libc-*.bc \
		target/$(ARCH)/$(DIR)/deps/rts-*.bc \
		-o target/rts.bc

	opt \
		--internalize-public-api-list="new_foo,sum_foo,free_foo" \
		--passes="internalize,globaldce" \
		target/rts.bc \
		-o target/rts.bc

	opt \
		--passes="internalize" \
		target/rts.bc \
		-o target/rts.bc

Basically we do the following:

• Compile the library and its dependencies to LLVM bitcode
• Link the LLVM modules
• Perform dead-code elimination using internalize and globaldce
• Perform a final internalize pass

The dead-code elimination is important because without it, the final module includes the code of all its dependencies. Also, the size of the runtime module will affect the performance of our compiler.

Let’s check that we have all our symbols:

$ llvm-nm target/rts.bc
---------------- t
---------------- t .Ltmp0
---------------- t .Ltmp1
---------------- t _ZN5alloc5alloc18handle_alloc_error17he8ceb1c27494fe14E
---------------- t __rust_alloc_error_handler
---------------- d __rust_no_alloc_shim_is_unstable
---------------- T __rust_probestack
                 U abort
                 U aligned_alloc
                 U free
---------------- T free_foo
---------------- T new_foo
---------------- T sum_foo

Perfect - the only undefined symbols are the C functions we’re calling. Note that this is for the release profile and the dev profile will create a much larger module.

If you want to simplify this setup, it seems that if you write C-like code (i.e. only using the libc crate and manually managing memory), then the --emit=llvm-bc flag will pretty much give you a standalone LLVM module. As soon as you import Box however, things start to get complicated.

Compiler

Finally we can write our compiler.

compiler/src/main.rs

use inkwell::{
    context::Context,
    memory_buffer::MemoryBuffer,
    module::Module,
    passes::PassBuilderOptions,
    targets::{FileType, InitializationConfig, Target, TargetMachine, TargetMachineOptions},
    OptimizationLevel,
};
use std::{env::args, path::Path, process::exit};

const RTS_BC: &[u8] = include_bytes!("../../target/rts.bc");

fn main() {
    Target::initialize_all(&InitializationConfig::default());
    let triple = TargetMachine::get_default_triple();
    let target = Target::from_triple(&triple).unwrap();
    let options = TargetMachineOptions::new().set_level(OptimizationLevel::None);
    let machine = target
        .create_target_machine_from_options(&triple, options)
        .unwrap();

    let context = Context::create();
    let buffer = MemoryBuffer::create_from_memory_range(RTS_BC, "main");
    let module = Module::parse_bitcode_from_buffer(&buffer, &context).unwrap();
    let builder = context.create_builder();

    let main_fun_type = context.i32_type().fn_type(&[], false);
    let main_fun = module.add_function("main", main_fun_type, None);

    let block = context.append_basic_block(main_fun, "start");
    builder.position_at_end(block);

    let new_foo = module.get_function("new_foo").unwrap();
    let foo = builder
        .build_call(new_foo, &[], "foo")
        .unwrap()
        .try_as_basic_value()
        .unwrap_left()
        .into_pointer_value();

    let sum_foo = module.get_function("sum_foo").unwrap();
    let result = builder
        .build_call(sum_foo, &[foo.into()], "result")
        .unwrap()
        .try_as_basic_value()
        .unwrap_left()
        .into_int_value();

    let free_foo = module.get_function("free_foo").unwrap();
    builder.build_call(free_foo, &[foo.into()], "").unwrap();

    builder.build_return(Some(&result)).unwrap();

    module
        .run_passes("default<O3>", &machine, PassBuilderOptions::create())
        .unwrap();

    module.verify().unwrap();

    let eval = args().any(|arg| arg == "-e");
    if eval {
        let engine = module
            .create_jit_execution_engine(OptimizationLevel::Aggressive)
            .unwrap();
        let code = unsafe { engine.run_function_as_main(main_fun, &[]) };
        exit(code)
    } else {
        machine
            .write_to_file(&module, FileType::Object, Path::new("main.o"))
            .unwrap();
    }
}

The compiler is the easy part.

• Include the runtime bitcode directly in the executable
• Load the runtime bitcode to create a main module
• Define a main function which calls our runtime API
• Run some optimisation passes
• Verify the module
• Either run the JIT or compile to an object file

Let’s JIT:

$ ./target/debug/compiler -e
$ echo $?
6

Success! We got our 1 + 2 + 3.

What’s great about the JIT compiler is that it basically doesn’t require anything from the environment. No opening files, no invoking a C compiler, just direct execution.

Let’s compile:

$ ./target/debug/compiler
$ cc main.o -o main
$ ./main
$ echo $?
6

We can even make a static binary if we want:

$ gcc -static main.o -o main -L $(nix path-info nixpkgs#glibc.static)/lib
$ ldd main
        not a dynamic executable

Conclusion

• We’ve achieved a clear separation of concerns between our compiler and runtime.
• The runtime is safe, ergonomic, correct, efficient, testable and small.
• The runtime can be directly embedded into the compiler for maximum portability.
• The compiler can generate code that can easily call into the runtime API.
• The runtime code occupies the same module as the generated code, and we run optimisations on the whole program - allowing LLVM to inline our runtime functions.

However:

• This relies on RUSTFLAGS="--emit=llvm-bc", which is a pretty creative workflow.
• We have to be very selective with our Rust version because we need to generate code that uses the same LLVM version. This really limits our flexibility.
• We have to be careful about what code we generate and what our runtime API looks like. Of course, code generation is always dangerous, but Rust brings with it a lot of extra rules (e.g. aliasing)

Homework

Build the runtime on std

I used no_std to simplify the build. But there shouldn’t be anything stopping us from linking to std.

Use a better allocator

The allocator I’m using in rts/src/lib.rs isn’t very efficient. We need to also implement alloc_zeroed and realloc. Better yet, integrate a modern allocator like mimalloc or rpmalloc.

Target machine optimisations

For some reason, using anything other than OptimizationLevel::None for the TargetMachine causes memory errors when compiling to an object file.

let options = TargetMachineOptions::new().set_level(OptimizationLevel::Aggressive);

$ valgrind ./target/debug/compiler 
Conditional jump or move depends on uninitialised value(s)
   at 0x34A0BA2: llvm::APInt::setBits(unsigned int, unsigned int) (in /home/will/Desktop/inline-your-runtime/target/debug/compiler)
   by 0x6BB0684: computeKnownBits(llvm::Value const*, llvm::APInt const&, llvm::KnownBits&, unsigned int, llvm::SimplifyQuery const&) (in /home/will/Desktop/inline-your-runtime/target/debug/compiler)
   by 0x6BBAADF: llvm::computeKnownBits(llvm::Value const*, llvm::KnownBits&, llvm::DataLayout const&, unsigned int, llvm::AssumptionCache*, llvm::Instruction const*, llvm::DominatorTree const*, bool) (in /home/will/Desktop/inline-your-runtime/target/debug/compiler)
   by 0x5AADDA2: llvm::SelectionDAG::InferPtrAlign(llvm::SDValue) const (in /home/will/Desktop/inline-your-runtime/target/debug/compiler)
   by 0x599C8DF: (anonymous namespace)::DAGCombiner::visitLOAD(llvm::SDNode*) (in /home/will/Desktop/inline-your-runtime/target/debug/compiler)
   by 0x59E8E14: (anonymous namespace)::DAGCombiner::combine(llvm::SDNode*) (in /home/will/Desktop/inline-your-runtime/target/debug/compiler)
   by 0x59EA68C: llvm::SelectionDAG::Combine(llvm::CombineLevel, llvm::AAResults*, llvm::CodeGenOptLevel) (in /home/will/Desktop/inline-your-runtime/target/debug/compiler)
   by 0x5AFE320: llvm::SelectionDAGISel::CodeGenAndEmitDAG() (in /home/will/Desktop/inline-your-runtime/target/debug/compiler)
   by 0x5B00EE6: llvm::SelectionDAGISel::SelectAllBasicBlocks(llvm::Function const&) (in /home/will/Desktop/inline-your-runtime/target/debug/compiler)
   by 0x5B03469: llvm::SelectionDAGISel::runOnMachineFunction(llvm::MachineFunction&) [clone .part.0] (in /home/will/Desktop/inline-your-runtime/target/debug/compiler)
   by 0x36D3D4F: (anonymous namespace)::X86DAGToDAGISel::runOnMachineFunction(llvm::MachineFunction&) (in /home/will/Desktop/inline-your-runtime/target/debug/compiler)
   by 0x5E18707: llvm::MachineFunctionPass::runOnFunction(llvm::Function&) [clone .part.0] (in /home/will/Desktop/inline-your-runtime/target/debug/compiler)

This code path doesn’t have any unsafe blocks, and the module has been verified, so there’s likely a bug in Inkwell or LLVM.

Statically linked compiler

Rust supports static linking, but I haven’t looked too deep into it. It would be great to have a compiler that is completely self-contained.

Portable static linking

It would be awesome if the compiler could be distributed with a static libc and a linker, so that it can simply emit binaries that are statically linked without depending on the system libc or C compiler.

Haskell is great, but not low-level. Fortunately, Haskell has a low-overhead FFI which allows you to call C. Of course, it doesn’t have to be C. Any C ABI will do.

C ABI

If you want to learn what “C ABI” actually means, I highly recommend Alexis King’s answer to the Stack Exchange question “Why do common Rust packages depend on C code?”

But basically, it’s the lingua franca. Rust speaks the lingua franca like this:

rs/lib.rs

#[repr(C)]
#[derive(Debug)]
pub struct Point {
    x: f64,
    y: f64,
}

impl Point {
    #[no_mangle]
    pub extern "C" fn new_point(x: f64, y: f64) -> Box<Point> {
        Box::new(Point { x, y })
    }

    #[no_mangle]
    pub extern "C" fn point_length(&self) -> f64 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }

    #[no_mangle]
    pub extern "C" fn print_point(&self) {
        println!("{:?}", self)
    }
}

#[no_mangle]
pub extern "C" fn free_point(_point: Box<Point>) {}

The free_point definition is interesting - since we take the Box<Point> by value, it is moved into the function and dropped. So while the function looks redundant, there is a call to std::mem::drop. You can verify that this works if you call it from C and compile with -fsanitize=leak.

We need to set up our crate to compile to a static library (.a) and a header file (.h):

Cargo.toml

[package]
name = "hsrs"
version = "0.1.0"
edition = "2021"

[lib]
path = "rs/lib.rs"
crate-type = ["staticlib"]

[build-dependencies]
cbindgen = "0.28.0"

We’re using cbindgen to generate header files, which you can run via Rust build script:

build.rs

fn main() {
    let crate_name = std::env::var("CARGO_PKG_NAME").unwrap();
    let crate_dir = std::env::var("CARGO_MANIFEST_DIR").unwrap();
    let header_path = std::path::PathBuf::from(format!("lib/{}.h", crate_name));

    cbindgen::Builder::new()
        .with_crate(crate_dir)
        .with_language(cbindgen::Language::C)
        .generate()
        .unwrap()
        .write_to_file(header_path);
}

Now we can build our library:

$ cargo build -Z unstable-options --artifact-dir=lib
   Compiling hsrs v0.1.0 (/home/will/Desktop/hsrs)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.11s

$ ls lib
hsrs.h  libhsrs.a

Perfect. This can be consumed by anything that speaks the C ABI. Let’s set up our Haskell project to do so.

Into the burrito

hsrs.cabal

cabal-version: 3.4
name:          hsrs
version:       0.1.0.0
build-type:    Simple

executable hsrs
  hs-source-dirs:     hs
  main-is:            Main.hs
  other-modules:      Lib
  include-dirs:       lib
  extra-lib-dirs:     lib
  extra-libraries:    hsrs
  default-language:   GHC2024
  build-depends:      base >=4.7 && <5
  build-tool-depends: c2hs:c2hs >=0.28.8

The important parts are include-dirs, extra-lib-dirs, extra-libraries and the dependency on c2hs, which basically does the opposite of cbindgen - consuming C header files.

You will need a bit of interfacing code however:

hs/Lib.chs

module Lib where

import Foreign.Ptr
import Foreign.C.Types

#include "hsrs.h"

{#pointer *Point as PointPtr foreign newtype #}

{#fun new_point as ^ { `Double', `Double' } -> `PointPtr' #}

{#fun point_length as ^ { `PointPtr' } -> `Double' #}

{#fun print_point as ^ { `PointPtr' } -> `()' #}

{#fun free_point as ^ { `PointPtr' } -> `()' #}

This isn’t a Haskell file - it’s a .chs file, which c2hs will use to generate marshalling code and FFI calls.

We’re including the C header file that we generated with cbindgen and defining some bindings to it. In this case, I’m not defining the fields of the Point struct - I’m just defining an opaque pointer.

I find this pattern very useful: you marshal an opaque pointer to an object which has some state in it, and you call functions with it. This is basically OOP encapsulation - define an object and only access it through methods, because the insides are too hairy to work with directly. This design makes your FFI layer thin, which means less can go wrong.

Let’s call our new FFI functions.

hs/Main.hs

module Main where

import Lib

main :: IO ()
main = do
  point <- newPoint 1.5 2.0
  printPoint point
  length <- pointLength point
  putStrLn $ "point length: " <> show length
  freePoint point

You can see that snake_case became camelCase. Other than that, no surprises.

$ cabal run
Point { x: 1.5, y: 2.0 }
point length: 2.5

Awesome.

This setup is available as a template on GitHub. It includes a Nix flake to install everything you need to develop a Haskell + Rust project, including language servers and formatters.