What changed in Go, Rust and Solidity this week.

// This program demonstrates that Go 1.26.2 does not introduce new APIs.
// It simply compiles and runs with the standard library as of Go 1.27.1.
package main

import "fmt"

func main() {
	// Print a simple message to confirm the program runs.
	fmt.Println("Go 1.26.2 changes are internal; no new API to showcase.")
}

// This program demonstrates that the standard library does not yet provide a
// `uuid` package. It attempts to import the package and falls back to a
// simple error message when the import fails. The output shows the current
// state of Go 1.27.1, which does not include the proposed UUID API.

package main

import (
	"fmt"
)

func main() {
	// The following import would succeed once the `uuid` package is added to
	// the standard library in a future release. Until then, it is omitted.
	// import "uuid"

	// Since the package is unavailable, we simply inform the user.
	fmt.Println("The standard library does not yet provide a uuid package.")
}

package main

import "fmt"

func main() {
	// This program demonstrates that the Go command no longer supports
	// fetching modules directly from Bazaar (bzr) repositories.
	// In Go 1.27.1, attempting to use `go get` with a bzr URL would
	// result in an error, so we simply print a confirmation message.
	fmt.Println("Bazaar support has been removed from the Go command.")
}

// This program demonstrates that extern blocks must be marked unsafe
// in Rust 1.98.1 (edition 2024). The change to WebAssembly targets
// removes the --allow-undefined flag, so any extern function that
// is not linked will cause a compile‑time error unless it is
// explicitly marked unsafe. The following code compiles and
// prints a message, showing the correct usage.

fn main() {
    // Define an external C function. The block must be unsafe.
    unsafe extern "C" {
        fn js_log(n: u32);
    }

    // We don't actually call js_log here, but the compiler
    // accepts the definition because it is marked unsafe.
    println!("Extern function declared safely.");
}

// This program demonstrates the current default behaviour of docs.rs.
// It prints the default target that docs.rs would use when building
// documentation for a crate that does not specify any targets.
//
// In a real Cargo.toml you would set this under
// [package.metadata.docs.rs] as shown in the change description.

fn main() {
    // The default target used by docs.rs build servers.
    let default_target = "x86_64-unknown-linux-gnu";
    println!("Docs.rs default target: {}", default_target);
}

// This program demonstrates that the Rust language has not changed
// with respect to the Leadership Council update.  It simply prints
// a message confirming that the language remains the same.
fn main() {
    println!("Rust language unchanged by the March 2026 Leadership Council update.");
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;

// This contract demonstrates that delete on a memory bytes array element
// clears only the targeted byte, not the whole 32‑byte word.
contract Main {
    function clearByte(uint index) external pure returns (bytes memory) {
        bytes memory data = new bytes(5);
        // set all bytes to 0xFF for visibility
        for (uint i = 0; i < data.length; i++) {
            data[i] = 0xFF;
        }
        // delete the element at `index`
        delete data[index];
        return data;
    }
}

Tests

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;

import "./main.sol";

contract MainTest {
    Main main;

    constructor() {
        main = new Main();
    }

    function test_singleByteCleared() public {
        bytes memory result = main.clearByte(2);
        // bytes[2] should be 0x00, others remain 0xFF
        require(result[2] == 0x00, "byte not cleared");
        require(result[0] == 0xFF, "other byte altered");
        require(result[1] == 0xFF, "other byte altered");
        require(result[3] == 0xFF, "other byte altered");
        require(result[4] == 0xFF, "other byte altered");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;

// This contract demonstrates the 0.8.37 delete‑byte‑array‑element fix.
// It creates a memory bytes array, sets each element to 0x01,
// deletes the middle element, and returns the array.
contract Demo {
    function deleteMiddle() external pure returns (bytes memory) {
        bytes memory b = new bytes(3);
        b[0] = 0x01;
        b[1] = 0x01;
        b[2] = 0x01;
        delete b[1]; // only b[1] should become 0x00
        return b;
    }
}

Tests

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;
import "./main.sol";

contract DemoTest {
    Demo demo;

    constructor() {
        demo = new Demo();
    }

    function test_deleteLeavesOtherBytes() external {
        bytes memory result = demo.deleteMiddle();
        require(result.length == 3, "wrong length");
        require(result[0] == 0x01, "b[0] altered");
        require(result[1] == 0x00, "b[1] not zeroed");
        require(result[2] == 0x01, "b[2] altered");
    }
}