Today we are releasing Spade v0.16.0, a release packed with several improvements to several parts of the language.

>10x Performance Improvement🔗

The compiler is now much faster than before. On one project the comile time went from "hours" to 17 seconds, and on the project I used for benchmarking we see a 10x improvement in runtime. While these projects are slight outliers, the compiler should be faster across the board.

Our goal is for the compile time to be under one second for all projects, so if you encounter code that takes longer to compile, please get in touch so we can improve things further.

Visibility markers🔗

Spade now supports visibility markers like pub and pub(lib). Like public and private in most languages, this allows you as a library author to only expose parts of your library to the outside world.

Import and Namespace System Improvements🔗

We have made several improvements to to the namespace system. You can now use more than one item in a single use statement:

use std::{array::{zip, interleave_arrays}, conv::transmute};

You can also use self and super in namespaces to traverse the module tree

Match Conditionals🔗

Match branches now support conditionals after the pattern, like so:

impl Option<uint<8>> {
  fn inner_is_even(self) -> bool {
    match self {
      Some(val) if val & 1 == 1 => true,
      Some(_) => false,
      None => false
    }
  }
}

Type Expressions in Traits🔗

For a long time, it has been impossible to write things like

impl<T, #uint N> [T; N] {
  fn append(self, new: T) -> [T; {N + 1}] {
    self.concat([new])
  }
}

instead, you had to introduce an additional type variable on the function. This restriction has now been lifted and the above code now compiles!

Syntax Changes🔗

We have made several changes to improve the Spade syntax. Most of these are simply warnings for now allowing you to gracefully migrate your projects

• The function traits that were previously written as Fn((Arg1, Arg2...), Out) are now written as Fn(Arg1, Arg2..) -> Out
• Tuple indexing is now written as tuple.0 instead of tuple#1, mimicking Rust

More Verilog Interoperability🔗

You can now annotate some things with #[verilog_attrs(..)] which gets translated to (* ... *) in the generated Verilog. This is useful for vendor primitives that need attributes for configuration.

You can now also use r#ident to write identifiers that conflict with Spade keywords, making it possible to interoperate with Verilog modules that, for example, use reset as an input or output signal.

Improved Self🔗

Self can now be used in more contexts in impl blocks. For example, you can now do

enum Thing<T> {
  A,
  B{val: T}
}
impl Thing<uint<8>> {
  fn inner_eq(self, val: uint<8>) -> bool {
    match self {
      Self::A => false,
      Self::B(inner) => inner == val
    }
  }
}

ASCII literals🔗

You can now write ascii char literals like b'a' and b"This is a\nmulti line string". This is very useful when working with human readable strings, such as when sending things back and forth via UART, or when solving advent of code 😉 https://gitlab.com/TheZoq2/aoc2025

Array Labels🔗

You can now add labels to arrays and refer to those labels later to get the corresponding indices. For example

  Insn::Set(0, 0),
'loop_start
  Insn::Addi(0, 1),
  Insn::Branchi(0, Cond::Eq, 255, @loop_start.index)

for more details on this, and how it can be used, see our previous blog post

Thanks🔗

This release marks a small milestone for external contributions to Spade. Out of the 17 merge requests in the changelog, 12 of them are by José Miguel Sánchez García, making it the first release where Frans hasn't made the majority of the changes! Thanks José 🎉