Which integer types and languages does the reference cover?

All common fixed-width integer types across seven languages: C/C++ (int8_t/uint8_t/int16_t/uint16_t/int32_t/uint32_t/int64_t/uint64_t, char/short/int/long/long long, size_t, intptr_t/uintptr_t, ptrdiff_t), Rust (i8/u8/i16/u16/i32/u32/i64/u64/i128/u128/isize/usize), Go (int8/uint8/int16/uint16/int32/uint32/int64/uint64, int/uint/uintptr, byte/rune), Java (byte/short/int/long/char — no unsigned), C# (sbyte/byte/short/ushort/int/uint/long/ulong, nint/nuint), JavaScript (Number safe-int range and BigInt), and Python (int — arbitrary precision). Each entry shows the exact min/max using BigInt, the bit width, signed/unsigned flag, the printf-style format specifier where applicable, and the language's named constant (e.g. INT_MAX, i32::MAX, math.MaxInt32, Integer.MAX_VALUE).

How does the overflow calculator work?

Type any integer (decimal, 0x hex, 0b binary or 0o octal) and pick a target type. The calculator tells you whether the value fits in that type and, if it doesn't, exactly how each language would treat it: C/C++ signed overflow is undefined behavior (UB) while unsigned wraps modulo 2^N; Rust panics in debug builds and wraps modulo 2^N in release; Go always wraps modulo 2^N for both signed and unsigned; Java wraps modulo 2^N (two's complement) and has no unsigned types; C# wraps in unchecked context and throws OverflowException in checked context; JavaScript Number loses precision beyond 2^53; Python ints never overflow. The wrapped/stored bit pattern is shown in decimal, hex and binary.

Are the min/max values really exact for 64-bit and 128-bit types?

Yes. All range math is done with native JavaScript BigInt, so int64's −9,223,372,036,854,775,808 to 9,223,372,036,854,775,807, uint64's 0 to 18,446,744,073,709,551,615, and even Rust's i128/u128 (−170,141,183,460,469,231,731,687,303,715,884,105,728 to 170,141,183,460,469,231,731,687,303,715,884,105,727) are computed exactly. There is no floating-point loss anywhere — BigInt is exact by definition.

Does it really reflect how each language behaves on overflow?

It reflects the documented semantics. C/C++ signed overflow is UB by the standard (so we label it as such, even if many compilers wrap in practice); C/C++ unsigned arithmetic is defined to wrap mod 2^N. Rust's debug-panic vs release-wrap distinction is encoded. Go's spec defines two's-complement wrapping for both signed and unsigned. Java's JLS defines wraparound. C# distinguishes checked vs unchecked arithmetic. JS Number follows IEEE-754 double precision (53-bit mantissa), and BigInt is unbounded. Python ints are unbounded. Real programs can still differ due to compiler flags, optimization levels, UB exploitation, or compiler-specific intrinsics — always verify on your target.

What extra features does this tool have versus a static cheatsheet?

(1) Cross-language comparison view for one type family (e.g. int32 → C int32_t, Rust i32, Go int32, Java int, C# int). (2) Interactive overflow simulator with per-language semantics labels (wrap/panic/UB/saturate/promote-to-bignum). (3) Copyable language constants (INT_MAX, i32::MAX, math.MaxInt32, Integer.MAX_VALUE, int.MaxValue, …) with one-click copy. (4) printf / fmt / format-specifier column. (5) Input accepts decimal, 0x hex, 0b binary, 0o octal with underscores. (6) Signed/unsigned toggle for the calculator. (7) Search/filter across type names, languages and bit widths. (8) Result of overflow shown in decimal, hex and binary. (9) History (localStorage, last 20, clickable to reload). (10) Shareable URL with the input + type + language encoded. (11) Bit-grid visualization of the wrapped result. (12) Overflow semantics cheatsheet card per language. 100% client-side and offline — your numbers never leave the device.

Developer Runs in your browser

Integer Data Type Range & Overflow Reference

Reference table for integer types (int8, uint8, int16, …, int64, uint64, size_t, intptr_t, byte, char, short, long, i32, u64, isize, usize) across C/C++, Rust, Go, Java, C#, JavaScript and Python. Show min/max (BigInt-exact), bit width, overflow behavior, format specifiers and copyable language constants. Interactive overflow calculator — enter a value and a type, see whether it fits and exactly how it wraps/saturates/panics/errors per language. 100% client-side, no network.

100% Private Works Offline Instant

Overflow Simulator

Value (dec / 0x hex / 0b bin / 0o oct)

Type

Build mode (Rust/C#)

OverflowC / C++8-bitunsignedWraps (modular)

Input

300

0x12C · 0b100101100

After wrap

0x2C · 0b101100

Type range

min: 0

max: 255

Overflow behavior

Unsigned arithmetic wraps mod 2^N (well-defined).

Stored bit pattern (MSB → LSB), 8 bits

00101100

Reference Table (63 types)

Lang	Bits	Sign	Min	Max	Format	Overflow
C / C++	8	signed	-128	127	%hhd / PRId8	Signed overflow is UB in C/C++; unsigned wraps mod 2^N.
C / C++	8	unsigned	0	255	%hhu / PRIu8	Unsigned arithmetic wraps mod 2^N (well-defined).
C / C++	16	signed	-32_768	32_767	%hd / PRId16	Signed overflow is UB in C/C++; unsigned wraps mod 2^N.
C / C++	16	unsigned	0	65_535	%hu / PRIu16	Unsigned arithmetic wraps mod 2^N.
C / C++	32	signed	-2_147_483_648	2_147_483_647	%d / PRId32	Signed overflow is UB in C/C++; unsigned wraps mod 2^N.
C / C++	32	unsigned	0	4_294_967_295	%u / PRIu32	Unsigned arithmetic wraps mod 2^N.
C / C++	64	signed	-9_223_372_036_854_775_808	9_223_372_036_854_775_807	%lld / PRId64	Signed overflow is UB in C/C++; unsigned wraps mod 2^N.
C / C++	64	unsigned	0	18_446_744_073_709_551_615	%llu / PRIu64	Unsigned arithmetic wraps mod 2^N.
C / C++	8	signed	-128	127	%c / %hhd	Signedness of `char` is implementation-defined. Treated as signed here.
C / C++	8	unsigned	0	255	%hhu	Wraps mod 2^N.
C / C++	16	signed	-32_768	32_767	%hd	Signed overflow is UB in C/C++; unsigned wraps mod 2^N.
C / C++	16	unsigned	0	65_535	%hu	Wraps mod 2^N.
C / C++	32	signed	-2_147_483_648	2_147_483_647	%d	Signed overflow is UB in C/C++; unsigned wraps mod 2^N. (Assumes 32-bit int.)
C / C++	32	unsigned	0	4_294_967_295	%u	Wraps mod 2^N. (Assumes 32-bit int.)
C / C++	64	signed	-9_223_372_036_854_775_808	9_223_372_036_854_775_807	%ld	Signed overflow is UB in C/C++; unsigned wraps mod 2^N. (LP64: 64-bit long.)
C / C++	64	unsigned	0	18_446_744_073_709_551_615	%lu	Wraps mod 2^N. (LP64: 64-bit long.)
C / C++	64	signed	-9_223_372_036_854_775_808	9_223_372_036_854_775_807	%lld	Signed overflow is UB in C/C++; unsigned wraps mod 2^N.
C / C++	64	unsigned	0	18_446_744_073_709_551_615	%llu	Wraps mod 2^N.
C / C++	64	unsigned	0	18_446_744_073_709_551_615	%zu	Unsigned; wraps mod 2^N. (LP64: 64-bit.)
C / C++	64	signed	-9_223_372_036_854_775_808	9_223_372_036_854_775_807	%ld / PRIdPTR	Signed overflow is UB in C/C++; unsigned wraps mod 2^N. (LP64: 64-bit.)
C / C++	64	unsigned	0	18_446_744_073_709_551_615	%lu / PRIuPTR	Unsigned; wraps mod 2^N. (LP64: 64-bit.)
C / C++	64	signed	-9_223_372_036_854_775_808	9_223_372_036_854_775_807	%td	Signed overflow is UB in C/C++; unsigned wraps mod 2^N. (LP64: 64-bit.)
Rust	8	signed	-128	127	—	Debug: panics. Release: wraps mod 2^N. Use wrapping_* / checked_* / saturating_*.
Rust	8	unsigned	0	255	—	Debug: panics. Release: wraps mod 2^N.
Rust	16	signed	-32_768	32_767	—	Debug: panics. Release: wraps mod 2^N.
Rust	16	unsigned	0	65_535	—	Debug: panics. Release: wraps mod 2^N.
Rust	32	signed	-2_147_483_648	2_147_483_647	—	Debug: panics. Release: wraps mod 2^N. Default integer type.
Rust	32	unsigned	0	4_294_967_295	—	Debug: panics. Release: wraps mod 2^N.
Rust	64	signed	-9_223_372_036_854_775_808	9_223_372_036_854_775_807	—	Debug: panics. Release: wraps mod 2^N.
Rust	64	unsigned	0	18_446_744_073_709_551_615	—	Debug: panics. Release: wraps mod 2^N.
Rust	128	signed	-170_141_183_460_469_231_731_687_303_715_884_105_728	170_141_183_460_469_231_731_687_303_715_884_105_727	—	Debug: panics. Release: wraps mod 2^N.
Rust	128	unsigned	0	340_282_366_920_938_463_463_374_607_431_768_211_455	—	Debug: panics. Release: wraps mod 2^N.
Rust	64	signed	-9_223_372_036_854_775_808	9_223_372_036_854_775_807	—	Pointer-sized. 64-bit on 64-bit targets. Debug panics, release wraps.
Rust	64	unsigned	0	18_446_744_073_709_551_615	—	Pointer-sized. 64-bit on 64-bit targets. Debug panics, release wraps.
Go	8	signed	-128	127	—	Always wraps mod 2^N (two's complement). Use math/bits Add/Sub/etc. for checked ops.
Go	8	unsigned	0	255	—	Always wraps mod 2^N. byte is an alias for uint8.
Go	16	signed	-32_768	32_767	—	Always wraps mod 2^N.
Go	16	unsigned	0	65_535	—	Always wraps mod 2^N.
Go	32	signed	-2_147_483_648	2_147_483_647	—	Always wraps mod 2^N. rune is an alias for int32.
Go	32	unsigned	0	4_294_967_295	—	Always wraps mod 2^N.
Go	64	signed	-9_223_372_036_854_775_808	9_223_372_036_854_775_807	—	Always wraps mod 2^N.
Go	64	unsigned	0	18_446_744_073_709_551_615	—	Always wraps mod 2^N.
Go	64	signed	-9_223_372_036_854_775_808	9_223_372_036_854_775_807	—	Platform-sized (64-bit on 64-bit targets). Wraps mod 2^N.
Go	64	unsigned	0	18_446_744_073_709_551_615	—	Platform-sized (64-bit on 64-bit targets). Wraps mod 2^N.
Go	64	unsigned	0	18_446_744_073_709_551_615	—	Unsigned pointer-sized. Wraps mod 2^N.
Java	8	signed	-128	127	%d	Always wraps mod 2^N. No unsigned types in Java. Use Math.addExact for checked ops.
Java	16	signed	-32_768	32_767	%d	Always wraps mod 2^N.
Java	32	signed	-2_147_483_648	2_147_483_647	%d	Always wraps mod 2^N. Use Math.*Exact for checked operations.
Java	64	signed	-9_223_372_036_854_775_808	9_223_372_036_854_775_807	%d	Always wraps mod 2^N.
Java	16	unsigned	0	65_535	%c	Only unsigned 16-bit type in Java. Wraps mod 2^16.
C#	8	signed	-128	127	{0:d}	unchecked: wraps mod 2^N. checked: throws OverflowException.
C#	8	unsigned	0	255	{0:d}	unchecked: wraps mod 2^N. checked: throws OverflowException.
C#	16	signed	-32_768	32_767	{0:d}	unchecked: wraps. checked: throws OverflowException.
C#	16	unsigned	0	65_535	{0:d}	unchecked: wraps. checked: throws OverflowException.
C#	32	signed	-2_147_483_648	2_147_483_647	{0:d}	unchecked: wraps. checked: throws OverflowException.
C#	32	unsigned	0	4_294_967_295	{0:d}	unchecked: wraps. checked: throws OverflowException.
C#	64	signed	-9_223_372_036_854_775_808	9_223_372_036_854_775_807	{0:d}	unchecked: wraps. checked: throws OverflowException.
C#	64	unsigned	0	18_446_744_073_709_551_615	{0:d}	unchecked: wraps. checked: throws OverflowException.
C#	64	signed	-9_223_372_036_854_775_808	9_223_372_036_854_775_807	—	Native-sized signed (64-bit on 64-bit). unchecked: wraps. checked: throws.
C#	64	unsigned	0	18_446_744_073_709_551_615	—	Native-sized unsigned (64-bit on 64-bit). unchecked: wraps. checked: throws.
JavaScript	53	signed	-9_007_199_254_740_991	9_007_199_254_740_991	—	IEEE-754 double. Integers beyond ±2^53-1 lose precision (silently). Use BigInt instead.
JavaScript	∞	signed	−∞	+∞	—	Arbitrary-precision. No overflow; memory-limited only.
Python	∞	signed	−∞	+∞	—	Arbitrary-precision. No overflow; memory-limited only.

Cross-language Comparison

int32_tC / C++

32-bit · signed

min: -2_147_483_648

max: 2_147_483_647

intC / C++

32-bit · signed

min: -2_147_483_648

max: 2_147_483_647

i32Rust

32-bit · signed

min: -2_147_483_648

max: 2_147_483_647

int32 / runeGo

32-bit · signed

min: -2_147_483_648

max: 2_147_483_647

intJava

32-bit · signed

min: -2_147_483_648

max: 2_147_483_647

intC#

32-bit · signed

min: -2_147_483_648

max: 2_147_483_647

Overflow Semantics Cheatsheet

C / C++

Signed overflow is UB in C/C++; unsigned wraps mod 2^N.

Rust

Debug: panics. Release: wraps mod 2^N. Use wrapping_* / checked_* / saturating_*.

Always wraps mod 2^N (two's complement). Use math/bits Add/Sub/etc. for checked ops.

Java

Always wraps mod 2^N. No unsigned types in Java. Use Math.addExact for checked ops.

unchecked: wraps mod 2^N. checked: throws OverflowException.

JavaScript

IEEE-754 double. Integers beyond ±2^53-1 lose precision (silently). Use BigInt instead.

Python

Arbitrary-precision. No overflow; memory-limited only.

Honesty note: Reflects documented semantics. Compiler flags, optimization levels, and UB mean real programs can still differ — always test on your target.

How to use

Enter your input in the tool above.
Adjust any options to your preference.
Use the Copy or Download buttons to save the result.
Everything happens locally — your data never leaves your browser.

All tools