[YeonwooSung]

What this adds

gpu_printf! now chooses the C conversion from the argument's type for every placeholder without a type character. Before, {} and {:.N} packed every argument as i64 and printed %lld, so floats printed as truncated integers, {:.2} on a float printed a zero-padded integer, and unsigned values above i64::MAX printed negative. The per-type table cuda-device has carried since the first release, GpuPrintfArg, is now the single source of that decision.

let big: u64 = u64::MAX;
let x: f32 = 3.14159;
gpu_printf!("{} {} {:.2}\n", big, x, x);

before:  -1 3 03
after:   18446744073709551615 3.141590 3.14

#[kernel]
pub fn show(data: &[f32]) {
    let tid = thread::index_1d().get();
    gpu_printf!("thread {}: data[{}] = {}\n", tid, tid, data[tid]);
    // thread 0: data[0] = 1.100000
}

What we fixed

• {}, {:8}, {:08}, {:+} and {:.N} without a type character took the argument through as i64 and %lld, whatever its type. They now resolve the conversion from the argument's GpuPrintfArg impl at compile time: %d or %lld for signed integers, %u or %llu for unsigned, %f for floats, %d for bool, %p for raw pointers.
• The compile-time format string is returned as &'static [u8; N]. The importer rejects an anonymous slice constant, so the first version of this change failed device codegen on every {} over a binding and broke the printf, dynamic_smem, debug-tests and toolchain_pairing_smoke examples.
• The format buffer is sized from the format skeleton instead of a 48-byte-per-placeholder estimate, which overflowed const evaluation at 54 literal % and padded every format global.
• All arguments, runtime width included, are evaluated left to right, as println! does.
• Sign flags on an unsigned argument and runtime precision {:.*} are compile-time errors; device printf leaves the first undefined and does not support the second.

Default conversion contract

• A placeholder without a type character accepts any GpuPrintfArg type: i8 to i64, isize, u8 to u64, usize, f32, f64, bool, *const T, *mut T.
• Literals follow Rust's rules: an unsuffixed integer is i32, an unsuffixed float is f64.
• Precision on an integer argument is C's minimum digit count; on a float it is the number of digits after the point.
• + and space flags need a signed integer or float argument.
• char takes {:c}; a fieldless enum needs an as i32 cast; i128 and u128 are not accepted.
• Explicit type characters ({:x}, {:d}, {:.2f}, {:e}, ...) keep their previous casts and conversions.

Implementation

• Each placeholder without a type character becomes a generic parameter __Ti: GpuPrintfArg of a per-call-site #[inline(always)] helper. Its inline const calls cuda_device::debug::__gpu_printf_format::<N>, a const fn next to __gpu_assert_c_string, with the literal parts and per-placeholder specs as data; the trait's FORMAT_CHAR, IS_64BIT and IS_FLOAT select ll and the type character after monomorphization.
• Arguments are packed through GpuPrintfArg::promote into a #[repr(C)] struct whose fields are the promoted types at natural alignment, the layout vprintf reads.
• N is computed by the macro: literal parts with % doubled, fixed specifiers, prefix plus four bytes per typed placeholder, one NUL. The builder asserts the fit and NUL-terminates.
• The byte-literal fast path remains for call sites whose placeholders all carry a type character.
• The builder is unit-tested on the host (conversion per type, %% doubling, fit, rejection of + on unsigned); the macro tests check the expansion; the printf example checks the device output.

Verification

Checked at a61a7e965 (nightly-2026-10-11, RTX 5090):

• ✅ cargo test -p cuda-macros --all-targets (143 unit tests plus the trybuild cases) and cargo test -p cuda-device --all-targets (124) pass, builder and expansion tests included. Clippy with warnings as errors on both, rustdoc, cargo oxide fmt --check, the 18 guards and the lock check are clean.
• ✅ Fails before, passes after: with main's macro, 8 of the 11 rewritten macro tests fail; the submitted head fails device codegen on the printf example (Unsupported constant type in translate_constant).
• ✅ cargo oxide run printf: === ALL PRINTF TESTS PASSED === with the new Test 8 lines matching the README, memcheck 0 errors; the same values through the libNVVM route.
• ✅ dynamic_smem, debug-tests and toolchain_pairing_smoke build again; device_ffi_test's fixed-route format globals are unchanged.
• ✅ On main the same box printed 03 for {:.2} of 3.14159, -1 for {} of u64::MAX and 3 for {} of an f32 binding.

Caveats

• Code that relied on the old as i64 path changes: {} on char and on a fieldless enum no longer compiles (use {:c} or as i32), {} on a raw pointer prints %p hex instead of a decimal, {} on a float prints six decimals where it printed a truncated integer.
• Precision on integers keeps C semantics ({:.3} on -42 prints -042); Rust ignores precision on integers.
• The importer still rejects anonymous slice constants in device code; that is a separate compiler gap.
• Device printf formats on the host, so each conversion's output follows the host C library.

[copy-pr-bot]

This pull request requires additional validation before any workflows can run on NVIDIA's runners.

Pull request vetters can view their responsibilities here.

Contributors can view more details about this message here.

[nihalpasham]

/ok to test a61a7e9

[nihalpasham]

Thanks for tracking this down; the defaults were wrong and the trait route is the right idea. As submitted, every {} on a binding failed device codegen (the format helper returned a slice constant the importer rejects), so I took the fix the rest of the way:

• The format helper returns &'static [u8; N], sized from the format skeleton, and the assembly moved into a const fn in cuda-device that is tested on the host.
• GpuPrintfArg is now the one source of the default conversion; the token classifier and the as f64 precision arm are gone.
• Arguments evaluate left to right; + or space on an unsigned argument and {:.*} are compile-time errors; char, fieldless enums and i128 are documented as not accepted.
• The printf example carries the cases that were wrong, and the docs state the contract.

At a61a7e965, {} on u64::MAX, on floats and on data[tid] print correctly on the 5090 through both routes, memcheck is clean, dynamic_smem and the other three examples build again, and all CI checks passed.