Rust 1.100.0: What DevOps Engineers Need to Know

GPU teams face a bad trade-off: a control plane per team, or weak isolation in a shared cluster. This reproducible lab combines Kamaji (control planes as pods) and HAMi (fractional GPUs) on a single GPU-less machine using HAMi's mock device plugin.

Part of the DevOps & Operations section — practical guides for running systems in production.

Framing: Rust Release Notes.

Rust 1.100.0 was released on November 12, 2026. The first edition where ! is stable, and the Allocator trait is production-ready. Changes touch every stage: from dependency management to build artifacts, from custom memory to platform support.

Executive Summary

Details below — with copy-paste-ready snippets.

1. Stable Allocator API

What: The entire Allocator trait and associated types are now stable. Write custom allocators for production.

Quick start:

// 30-second custom allocator (delegates to Global)
use std::alloc::{Allocator, Global, Layout};
use std::ptr::NonNull;

struct MyAllocator;

unsafe impl Allocator for MyAllocator {
    fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, std::alloc::AllocError> {
        Global.allocate(layout)
    }
    fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
        Global.deallocate(ptr, layout)
    }
}

// Use it
let v = Vec::new_in(MyAllocator);
let b: Box<i32, MyAllocator> = Box::new_in(42, MyAllocator);

With jemalloc:

// Cargo.toml: jemallocator = "0.5"
#[global_allocator]
static G: jemallocator::Jemalloc = jemallocator::Jemalloc;

// Or per-type
use jemallocator::Jemalloc;
let vec: Vec<u8, Jemalloc> = Vec::new_in(Jemalloc);

2. Never Type ! Stabilized

What: The never type is stable. Infallible is now an alias for !.

Function that never fails:

fn parse_infallible(s: &str) -> Result<i32, !> {
    s.parse().ok().unwrap_unchecked()
}

Match exhaustiveness:

match result {
    Ok(v) => v,
    Err(e) => match e {}, // This arm is unreachable, return type is `!`
}

New stable utilities:

use std::mem::{DropGuard, conjure_zst};

// Run cleanup even if panicking
let _guard = DropGuard::new(|| println!("cleaning up"),());

// Create a zero-sized value
let _zst: MyZst = unsafe { conjure_zst() };

⚠️ Breaking change: box patterns removed

// ❌ removed
let box x = some_box;  // syntax error

// ✅ do this
let x = *some_box;

3. Cargo Lints

What: Cargo has its own lints now. Unused dependencies emit warnings by default.

# Cargo.toml
[lints.cargo]
# Fail CI on unused dependencies
unused_dependencies = "deny"

# Check in CI
cargo build 2>&1 | grep -q "cargo::unused_dependencies" && exit 1

4. Minimum Publish Age (RFC 3923)

What: Dependencies must be a minimum age before Cargo uses them. Prevents surprise breakage from brand-new releases.

# .cargo/config.toml
[resolver]
publish-age = "24 hours"   # ignore versions < 24h old

# For CI (more conservative)
[resolver]
publish-age = "7 days"

Notes:

• ✅ Lockfile versions are always allowed (even if minutes old)
• ✅ Explicit versions in Cargo.toml override the cooldown
• ✅ Prevents CI breakage from bad transitive dependency releases

5. Build Directory Layout Change

What: target/ layout changed. Do not parse target/ — use JSON messages instead.

# Get all built files as JSON
cargo build --message-format=json 2>&1 | jq 'select(.message?.files?[] ) | .message.files[]'

# Get metadata
cargo metadata --format-version=1 | jq '.packages[] | {name: .name, targets: [.targets[].name]}'

6. New Stabilized APIs

Vec::from_fn

// Old way
let mut v = Vec::with_capacity(5);
for i in 0..5 {
    v.push(i * i);
}

// New way (stable in 1.100)
let v: Vec<_> = Vec::from_fn(5, |i| i * i);
// [0, 1, 4, 9, 16]

Box::{take,map}, Rc::{map}, Arc::{map}

// Take the value, leaving None
let mut b = Box::new(42);
let v = b.take();  // b is now an empty Box (Box<()>)

// Map over contained value
let b: Box<i32> = Box::new(42);
let b_str: Box<String> = b.map(|n| n.to_string());

str::{trim_prefix, trim_suffix}

let s = "---hello===";
assert_eq!(s.trim_prefix("---"), "hello===");
assert_eq!(s.trim_suffix("==="), "---hello");

[T]::{trim_prefix, trim_suffix}

let bytes = b"HTTP/1.1\r\nGET /\r\n";
let body = bytes.trim_prefix(b"HTTP/1.1\r\n");
// b"GET /\r\n"

Path::trim_prefix

use std::path::Path;
let p = Path::new("/usr/local/bin/rustc");
let rest = p.trim_prefix("/usr");
// Ok("/local/bin/rustc")

bool::toggle

let mut on = true;
on.toggle();   // on is now false

UnsafeCell::{replace, as_ref_unchecked, as_mut_unchecked}

use std::cell::UnsafeCell;
let cell = UnsafeCell::new(42);
let old = unsafe { cell.replace(100) };  // returns 42, cell now contains 100

Once::default

use std::sync::Once;
let once: Once = Once::default();
once.call_once(|| init());

Windows-specific

// Get main thread handle of a child process
use std::os::windows::process::CommandExt;
let handle = child.main_thread_handle();

// Show/hide window
use std::os::windows::process::CommandExt;
cmd.show_window(true);

7. Compiler & Solver

Next solver in orphanck:

# If you hit any issues, opt out temporarily
[unstable]
next_solver_in_orphanck = false

Profile-guided optimization stable:

# Build with instrumentation
RUSTFLAGS="-Cprofile-generate" cargo build --release
# Run workload: generates *.profraw files
./target/release/myapp
# Merge and rebuild with PGO
llvm-profdata merge *.profraw -output=app.profdata
RUSTFLAGS="-Cprofile-use=app.profdata -Cprofile-sample-use" cargo build --release

8. New Lint: aligned_fields_in_packed

#[repr(packed)]
struct Bad {
    #[repr(align(8))]  // ⚠️ lint: aligned field in packed struct
    a: u64,
    b: u8,  // will still have padding!
}

// Fix: choose one
#[repr(align(8))] struct Fixed1 { a: u64, b: u8, }
#[repr(packed)]  struct Fixed2 { a: u64, b: u8, }  // packed, accepts padding

9. Platform Support

Upgrade Checklist

• rustup update stable
• cargo check --all-features --all-targets
• Fix box patterns: let box x → let x = *box
• Switch tools from parsing target/ to JSON messages
• Consider [resolver] publish-age = "24 hours" in CI

November 12, 2026. Questions? GitHub.