What changed in Go, Rust and Solidity this week.

// This program demonstrates that the experimental `simd` package is not
// available in Go 1.27.1. It attempts to import the package and falls
// back to a simple message when the import fails.

package main

import (
	"fmt"
)

func main() {
	// The import of "simd" is commented out because it does not exist
	// in the standard library for Go 1.27.1. If you uncomment the line
	// below, the compiler will emit an error: cannot find package "simd".
	//
	// import "simd"

	fmt.Println("The experimental simd package is not available in Go 1.27.1.")
}

// This program demonstrates that there is no new language feature in this update.
// It simply prints a message confirming that the update contains only project
// management information, not code changes.
fn main() {
    println!("No Rust code change in the April 2026 program‑management update.");
}

// This program demonstrates that the project goals update does not introduce
// any new language feature. It simply prints a message indicating that
// no code change is required.
fn main() {
    println!("Project goals update: no code change needed.");
}

// This program demonstrates Cargo's min publish age feature.
// Since the feature is not yet in Rust 1.98.1, we simulate the check manually.

use std::time::{SystemTime, UNIX_EPOCH};

fn main() {
    // Simulated publish time: 10 days ago
    let publish_time = SystemTime::now() - std::time::Duration::from_secs(10 * 24 * 60 * 60);
    // Minimum age required: 7 days
    let min_age = std::time::Duration::from_secs(7 * 24 * 60 * 60);

    let age = SystemTime::now()
        .duration_since(publish_time)
        .expect("time went backwards");

    if age >= min_age {
        println!("Version is old enough to use (age: {} days)", age.as_secs() / 86400);
    } else {
        println!("Version is too new (age: {} days)", age.as_secs() / 86400);
    }
}

// This program demonstrates how to run the `cargo-crap` subcommand
// to calculate the Change Risk Anti‑Patterns metric for a crate.
// `cargo-crap` is not part of the standard library and is not
// available in Rust 1.98.1, so we simply print a placeholder
// message that would be produced by the tool if it were installed.

fn main() {
    // In a real environment you would run:
    //   cargo install cargo-crap
    //   cargo crap
    // Here we just simulate the output.
    println!("Change Risk Anti‑Patterns metric: 42");
}

// This program demonstrates the message that Toasty 0.6.0 is now available.
// Toasty is a crate that is not yet part of Rust 1.98.1, so we simply print the
// notification that would appear when the crate is updated.
fn main() {
    println!("Toasty 0.6.0 is now available. Update your Cargo.toml to use it.");
}

// This program demonstrates that the Rust language has not changed for this crate.
// The ex_ratatui crate is an Elixir binding; it does not compile in Rust alone.
// We simply print a message to show the program runs.
fn main() {
    println!("ex_ratatui is an Elixir binding; Rust code alone does not use it.");
}

// This program demonstrates how OmniScope would be invoked on a Rust crate.
// Since OmniScope is not yet shipped, we show the command that would be run
// after building the crate. In a real environment you would replace
// `my_crate` with your crate name and run this from the crate root.

fn main() {
    // Build the crate first
    println!("Running: cargo build --release");
    // Then run OmniScope on the generated LLVM IR
    println!("Running: omniscape analyze target/release/deps/my_crate");
    // The output would list unsafe/FFI boundaries found in the IR.
}

// This program demonstrates that the `citum` crate is not available in
// Rust 1.98.1 (edition 2024). It simply prints a message to that effect.
fn main() {
    println!("The `citum` crate is not available in this Rust version.");
}

// 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");
    }
}