What changed in Go, Rust and Solidity this week.

The Go standard library has a package called hash/maphash that is used internally by maps to compute hash values. In older versions, the package did not expose a clear way for users to define their own hash functions for custom types. The change adds a generic interface called Hasher[T any] and a helper type ComparableHasher[T comparable]. Hasher describes two methods: Hash, which writes the hash of a value into a maphash.Hash, and Equal, which tells whether two values are considered the same for hashing purposes. ComparableHasher implements this interface for any type that already supports the == operator, so you can use it without writing extra code. With this change you can now write your own hash logic that works with Go’s map implementation, rather than relying on the default hashing of built‑in types.

Clippy is a tool that checks Rust code for common mistakes and style issues. Starting with Rust 1.89.0 beta on June 26 2025, Clippy will be on a feature‑freeze for 12 weeks. During that period no new lint rules will be added; only bug fixes are accepted. After the freeze ends, new lints can be added again.

The bzip2 crate used to rely on a C library to compress and decompress data. That meant you had to have a C compiler and the library installed on the machine where you built your Rust program. The crate has been rewritten entirely in Rust, so it no longer needs any external C code. You can now add bzip2 to your Cargo.toml and build on any platform that supports Rust without worrying about C toolchains.

The Rust team released a new survey that asks developers about how long the compiler takes to build their code. The goal is to collect data on real‑world build times and how they affect productivity. The survey is open from now until July 7, 2025, and it will be used to guide future performance work. No code changes are required to participate; you just fill out the online form.

Slint 1.12 adds support for the wgpu graphics backend, a port that lets Slint run on iOS devices, and a way to import variables from Figma design files. Before this release, Slint could only use the older glium backend and ran only on desktop platforms. With the new wgpu support, Slint can target WebGPU, Vulkan, Metal, and DirectX 12, giving developers more flexibility. The iOS port means you can now build Slint applications that run on iPhones and iPads. Finally, the Figma integration lets designers export variable values that the UI can read at runtime, keeping design and code in sync.

Solidity lets you write custom error types to make revert messages cheaper and clearer. When you call require with a custom error and use named parameters, the compiler used to put the arguments on the stack in the order you wrote them. In 0.8.37 the compiler now puts them on the stack in the order the error type declares them, regardless of the order you write them. This means the runtime data that represents the error is always in declaration order, which is what the ABI expects.

Mutual recursion is when two or more functions call each other. When a function is compiled, the compiler puts temporary values in memory slots. If two recursive functions are active at the same time, the compiler had to give them different slots. Before Solidity 0.8.37 the slot‑allocation logic could give the same slot to two active functions, so one function would overwrite the other’s data. The new release fixes that logic so each active function gets its own slot and the data stays intact.

Solidity 0.8.37 fixes a bug that affected the delete keyword when used on a single byte inside a bytes array that lives in memory. Before the fix, deleting a byte would clear the whole 32‑byte word that contains that byte, wiping out the other 31 bytes in the same word. Now the compiler generates code that only zeroes the targeted byte, leaving the rest of the word untouched. This change is invisible to most contracts that never delete individual bytes, but it matters for low‑level code that manipulates memory arrays byte‑by‑byte.