Are there any dialects of scheme that support multiple integer sizes?

I wish to write a program in Scheme that models the hardware registers of a hypothetical CPU. To this end, I'm going to need signed and unsigned integral datatypes that respect their intended bit widths, for behaviors like overflow and underflow.

Specifically: I'd want {signed,unsigned} x {8-bit,16-bit,32-bit,64-bit}.

But all of my experiences with Scheme so far have been just a single class of signed integers, where the single range is implementation defined (ignoring BIGNUM, for now.)

Is there any existing dialect of Scheme that allows programmers -- possibly via some prefix in front of the literal -- to say e.g. "treat this value as an exact 16-bit unsigned value"?

I would also consider other lispy languages, beyond the Schemes. I just need to know if there is some established syntax for accomplishing the above.

This is very much going to be implementation dependent, unless you want to use modular arithmetic everywhere. Kawa Scheme supports them, with its type annotations and JVM primitive integer types. For example:

#|:kawa:1|# (define (+/u16 a::ushort b::ushort) ::ushort (+ a b))
#|:kawa:2|# (+/u16 65535 50)
49
#|:kawa:3|# (->ushort 500) ; Coerce a literal integer to a ushort
500
#|:kawa:4|# (->ushort 65537) ; does range checking
/dev/tty:9:11: warning - integer 65536 not in range of ushort
1
#|:kawa:5|# (as ushort 65537) ; this form however is quiet
1
#|:kawa:6|# (ushort? -10)
#f

And of course many Schemes supports SRFI-4 Homogenous Numeric Vectors for storing arrays of fixed-width types, but that doesn't come with any arithmetic operations on them. Still useful if you want to represent a set of registers as one, of course.

Scheme has several numeric types, but none are limited by register width. When that said if you have a Scheme implementation with a full numeric tower you should be able to simulate those types.

#!r6rs
(import (rnrs base)
        (rnrs arithmetic bitwise))
    
(define (get-mask width)
  ;; simple to make a table, but I don't care for speed
  (- (bitwise-arithmetic-shift-left 1 width) 1))

(define (binary-add width carry n1 n2)
  (define mask (get-mask width))
  (define res (+ carry n1 n2))
  (define new-carry (> res mask))
  (define res-truncated (bitwise-and mask res))
  (values res-truncated new-carry))

(binary-add 8 1 128 128)
; ==> 1
; ==> #t

You might choose to wrap your values in boxes or that flags should be side effects, but these are just design decisions that have different pros and cons. Eg. I do imagine you do want to pass a bigger number eg. the "eax" register to an operation that only cares about the 16 first bits of each value, just like a real processor does