What changed in Go, Rust and Solidity this week.

// This program demonstrates that the Go 1.23.9 runtime and linker are working.
// It simply prints a message; any previous linker or runtime bugs would have
// manifested as a build error or a panic, which no longer occurs.
package main

import "fmt"

func main() {
    fmt.Println("Go 1.23.9 runtime and linker are functioning correctly.")
}

// This program demonstrates that the os package works as usual after the 1.24.3 update.
// It creates a temporary file, writes a line, reads it back, and prints the content.
// The code compiles and runs in Go 1.27.1, which already includes the 1.24.3 patch.

package main

import (
	"fmt"
	"io/ioutil"
	"os"
)

func main() {
	// Create a temporary file
	tmp, err := os.CreateTemp("", "example")
	if err != nil {
		fmt.Println("create temp:", err)
		return
	}
	defer os.Remove(tmp.Name())

	// Write to the file
	if _, err := tmp.WriteString("Hello, world!\n"); err != nil {
		fmt.Println("write:", err)
		return
	}
	tmp.Close()

	// Read the file back
	data, err := ioutil.ReadFile(tmp.Name())
	if err != nil {
		fmt.Println("read:", err)
		return
	}

	fmt.Printf("File content: %s", data)
}

// This program demonstrates that the announcement does not introduce any new
// Rust language feature or library.  It simply prints the list of selected
// projects as provided in the announcement.

fn main() {
    let projects = [
        "ABI/Layout handling for the automatic differentiation feature",
        "Add safety contracts",
        "Bootstrap of rustc with rustc_codegen_gcc",
        "Cargo: Build script delegation",
        "Distributed and resource-efficient verification",
        "Enable Witness Generation in cargo-semver-checks",
        "Extend behavioural testing of std::arch intrinsics",
        "Implement merge functionality in bors",
        "Improve bootstrap",
        "Improve Wild linker test suites",
        "Improving the Rustc Parallel Frontend: Parallel Macro Expansion",
        "Make cargo-semver-checks faster",
        "Make Rustup Concurrent",
        "Mapping the Maze of Rust's UI Test Suite with Established Continuous Integration Practices",
        "Modernising the libc Crate",
        "New proc-macro Server API for Rust-Analyzer",
        "Prepare stable_mir crate for publishing",
        "Prototype an alternative architecture for cargo fix using cargo check",
        "Prototype Cargo Plumbing Commands",
    ];

    println!("Selected GSoC 2025 projects:");
    for (i, project) in projects.iter().enumerate() {
        println!("{:>2}. {}", i + 1, project);
    }
}

// This program demonstrates how nested type definitions would look
// without a crate like `structstruck`.  The macro is not available
// in Rust 1.98.1, so we write the types manually.

struct Address {
    street: String,
    city: String,
}

struct Person {
    name: String,
    address: Address,
}

fn main() {
    let addr = Address {
        street: "123 Main St".into(),
        city: "Rustville".into(),
    };
    let person = Person {
        name: "Alice".into(),
        address: addr,
    };
    println!("{} lives in {}", person.name, person.address.city);
}

// This program demonstrates the current state of the tooling mentioned in the newsletter.
// It does not compile until the new releases are available, so we show the problem it solves today.

fn main() {
    // Malai: share a dev server over P2P (currently not available in this sandbox)
    // println!("Running Malai server...");

    // Fluvio: streaming data analytics (we just print a placeholder)
    println!("Fluvio 0.17.2 would be used here for streaming data.");

    // Leptos: web framework (we just print a placeholder)
    println!("Leptos v0.8.0 would be used here for building web apps.");
}

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

// The compiler defaults to the Prague EVM version in 0.8.37.
// This contract simply stores a value to demonstrate that the
// contract compiles and runs under the default EVM.
contract Main {
    uint256 public value;

    constructor(uint256 _value) {
        value = _value;
    }
}

Tests

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

import "./main.sol";

contract MainTest {
    Main main;

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

    function test_valueIsSet() public {
        require(main.value() == 42, "value should be 42");
    }
}

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

// This contract demonstrates that NatSpec documentation on enum values
// is now captured in the compiler's AST (as of Solidity 0.8.30).
// The enum below has NatSpec comments for each value.
contract EnumWithNatSpec {
    /// @notice The first state
    enum State { Pending, Approved, Rejected }

    State public current;

    constructor() {
        current = State.Pending;
    }

    function approve() external {
        current = State.Approved;
    }

    function reject() external {
        current = State.Rejected;
    }
}

Tests

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

import "./main.sol";

contract EnumWithNatSpecTest {
    EnumWithNatSpec instance;

    constructor() {
        instance = new EnumWithNatSpec();
    }

    function test_initialState() external {
        require(
            uint8(instance.current()) == 0,
            "Initial state should be Pending (0)"
        );
    }

    function test_approve() external {
        instance.approve();
        require(
            uint8(instance.current()) == 1,
            "State should be Approved (1) after approve()"
        );
    }

    function test_reject() external {
        instance.reject();
        require(
            uint8(instance.current()) == 2,
            "State should be Rejected (2) after reject()"
        );
    }
}

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

// This contract demonstrates that SMTChecker no longer treats loop conditions
// as constant-condition verification targets. The loop condition is a
// constant (true), but the compiler accepts it without reporting an error.
contract LoopExample {
    uint public counter;

    constructor() {
        // A loop with a constant condition that will execute exactly 5 times.
        for (uint i = 0; i < 5; i++) {
            counter += i;
        }
    }
}

Tests

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

contract LoopExampleTest {
    LoopExample example;

    constructor() {
        example = new LoopExample();
    }

    function test_counterValue() public {
        require(example.counter() == 10, "Counter should be 10");
    }
}

// main.sol
pragma solidity ^0.8.37;

// A simple contract that contains a loop.
// The SMTChecker will no longer crash on this contract in 0.8.30.
contract LoopExample {
    uint256 public counter;

    function run(uint256 n) public {
        counter = 0;
        for (uint256 i = 0; i < n; i++) {
            counter += i;
        }
    }
}

Tests

// test.sol
import "./main.sol";

contract LoopExampleTest {
    LoopExample example;

    constructor() {
        example = new LoopExample();
    }

    function test_initialCounterIsZero() public {
        require(example.counter() == 0, "counter should start at 0");
    }

    function test_runAddsNumbers() public {
        example.run(3); // 0+1+2 = 3
        require(example.counter() == 3, "counter should be 3 after run(3)");
    }
}