diff --git a/compiler_parse/src/lexer.rs b/compiler_parse/src/lexer.rs
index 5f91d43f..32d78704 100644
--- a/compiler_parse/src/lexer.rs
+++ b/compiler_parse/src/lexer.rs
@@ -382,7 +382,7 @@ impl<'s> Lexer<'s> {
             }
         }
 
-        self.int_range_radix(start, 16)
+        self.int_range_base(start, 16)
     }
 
     fn eat_number_octal(&mut self) -> TokenKind {
@@ -396,7 +396,7 @@ impl<'s> Lexer<'s> {
             }
         }
 
-        self.int_range_radix(start, 8)
+        self.int_range_base(start, 8)
     }
 
     fn eat_number_binary(&mut self) -> TokenKind {
@@ -410,11 +410,11 @@ impl<'s> Lexer<'s> {
             }
         }
 
-        self.int_range_radix(start, 2)
+        self.int_range_base(start, 2)
     }
 
-    fn int_range_radix(&self, start: u32, radix: u32) -> TokenKind {
-        let value = i128::from_str_radix(&self.number_range(start), radix).unwrap();
+    fn int_range_base(&self, start: u32, base: u32) -> TokenKind {
+        let value = i128::from_str_radix(&self.number_range(start), base).unwrap();
         TokenKind::Int(value)
     }
 
diff --git a/std/char.jin b/std/char.jin
index 651c5f49..1408ccb9 100644
--- a/std/char.jin
+++ b/std/char.jin
@@ -5,11 +5,11 @@ use std.(
     str.(?),
 )
 
-fn char.from-digit*(num u32, radix u32) Option[char] = {
-    assert(radix <= 36, "radix is too high (maximum 36)")
+fn char.from-digit*(num u32, base u32) Option[char] = {
+    assert(base <= 36, "base is too high (maximum 36)")
 
-    if num < radix {
-    let num = u8(num)
+    if num < base {
+        let num = u8(num)
         Option.Some(char(if num < 10 {
             b'0' + num
         } else {
diff --git a/std/int.jin b/std/int.jin
index f2996cd2..ba100b16 100644
--- a/std/int.jin
+++ b/std/int.jin
@@ -40,62 +40,49 @@ fn abs*(x i32) i32 = if x > 0 { x } else { -x }
 fn abs*(x i64) i64 = if x > 0 { x } else { -x }
 fn abs*(x int) int = if x > 0 { x } else { -x }
 
-fn to-str*(x i8) str = fmt-impl(uint(x.abs()), x < 0, Format.Decimal)
-fn to-str*(x i8, format Format) str = fmt-impl(uint(x.abs()), x < 0, format)
-fn fmt*(x &i8, buf &mut StrBuf) = buf.push(x.to-str(Format.Decimal))
-
-fn to-str*(x i16) str = fmt-impl(uint(x.abs()), x < 0, Format.Decimal)
-fn to-str*(x i16, format Format) str = fmt-impl(uint(x.abs()), x < 0, format)
-fn fmt*(x &i16, buf &mut StrBuf) = buf.push(x.to-str(Format.Decimal))
-
-fn to-str*(x i32) str = fmt-impl(uint(x.abs()), x < 0, Format.Decimal)
-fn to-str*(x i32, format Format) str = fmt-impl(uint(x.abs()), x < 0, format)
-fn fmt*(x &i32, buf &mut StrBuf) = buf.push(x.to-str(Format.Decimal))
-
-fn to-str*(x i64) str = fmt-impl(uint(x.abs()), x < 0, Format.Decimal)
-fn to-str*(x i64, format Format) str = fmt-impl(uint(x.abs()), x < 0, format)
-fn fmt*(x &i64, buf &mut StrBuf) = buf.push(x.to-str(Format.Decimal))
-
-fn to-str*(x int) str = fmt-impl(uint(x.abs()), x < 0, Format.Decimal)
-fn to-str*(x int, format Format) str = fmt-impl(uint(x.abs()), x < 0, format)
-fn fmt*(x &int, buf &mut StrBuf) = buf.push(x.to-str(Format.Decimal))
-
-fn to-str*(x u8) str = fmt-impl(x, false, Format.Decimal)
-fn to-str*(x u8, format Format) str = fmt-impl(x, false, format)
-fn fmt*(x &u8, buf &mut StrBuf) = buf.push(x.to-str(Format.Decimal))
-
-fn to-str*(x u16) str = fmt-impl(x, false, Format.Decimal)
-fn to-str*(x u16, format Format) str = fmt-impl(x, false, format)
-fn fmt*(x &u16, buf &mut StrBuf) = buf.push(x.to-str(Format.Decimal))
-
-fn to-str*(x u32) str = fmt-impl(x, false, Format.Decimal)
-fn to-str*(x u32, format Format) str = fmt-impl(x, false, format)
-fn fmt*(x &u32, buf &mut StrBuf) = buf.push(x.to-str(Format.Decimal))
-
-fn to-str*(x u64) str = fmt-impl(x, false, Format.Decimal)
-fn to-str*(x u64, format Format) str = fmt-impl(x, false, format)
-fn fmt*(x &u64, buf &mut StrBuf) = buf.push(x.to-str(Format.Decimal))
-
-fn to-str*(x uint) str = fmt-impl(x, false, Format.Decimal)
-fn to-str*(x uint, format Format) str = fmt-impl(x, false, format)
-fn fmt*(x &uint, buf &mut StrBuf) = buf.push(x.to-str(Format.Decimal))
-
-type Format* {
-    Binary
-    Decimal
-    Hex
-}
+fn to-str*(x i8) str = fmt-impl(uint(x.abs()), x < 0, 10)
+fn to-str*(x i8, base u32) str = fmt-impl(uint(x.abs()), x < 0, base)
+fn fmt*(x &i8, buf &mut StrBuf) = buf.push(x.to-str(10))
 
-fn base*(f Format) uint = match f {
-    Format.Binary -> 2
-    Format.Decimal -> 10
-    Format.Hex -> 16
-}
+fn to-str*(x i16) str = fmt-impl(uint(x.abs()), x < 0, 10)
+fn to-str*(x i16, base u32) str = fmt-impl(uint(x.abs()), x < 0, base)
+fn fmt*(x &i16, buf &mut StrBuf) = buf.push(x.to-str(10))
+
+fn to-str*(x i32) str = fmt-impl(uint(x.abs()), x < 0, 10)
+fn to-str*(x i32, base u32) str = fmt-impl(uint(x.abs()), x < 0, base)
+fn fmt*(x &i32, buf &mut StrBuf) = buf.push(x.to-str(10))
+
+fn to-str*(x i64) str = fmt-impl(uint(x.abs()), x < 0, 10)
+fn to-str*(x i64, base u32) str = fmt-impl(uint(x.abs()), x < 0, base)
+fn fmt*(x &i64, buf &mut StrBuf) = buf.push(x.to-str(10))
+
+fn to-str*(x int) str = fmt-impl(uint(x.abs()), x < 0, 10)
+fn to-str*(x int, base u32) str = fmt-impl(uint(x.abs()), x < 0, base)
+fn fmt*(x &int, buf &mut StrBuf) = buf.push(x.to-str(10))
+
+fn to-str*(x u8) str = fmt-impl(x, false, 10)
+fn to-str*(x u8, base u32) str = fmt-impl(x, false, base)
+fn fmt*(x &u8, buf &mut StrBuf) = buf.push(x.to-str(10))
+
+fn to-str*(x u16) str = fmt-impl(x, false, 10)
+fn to-str*(x u16, base u32) str = fmt-impl(x, false, base)
+fn fmt*(x &u16, buf &mut StrBuf) = buf.push(x.to-str(10))
+
+fn to-str*(x u32) str = fmt-impl(x, false, 10)
+fn to-str*(x u32, base u32) str = fmt-impl(x, false, base)
+fn fmt*(x &u32, buf &mut StrBuf) = buf.push(x.to-str(10))
+
+fn to-str*(x u64) str = fmt-impl(x, false, 10)
+fn to-str*(x u64, base u32) str = fmt-impl(x, false, base)
+fn fmt*(x &u64, buf &mut StrBuf) = buf.push(x.to-str(10))
+
+fn to-str*(x uint) str = fmt-impl(x, false, 10)
+fn to-str*(x uint, base u32) str = fmt-impl(x, false, base)
+fn fmt*(x &uint, buf &mut StrBuf) = buf.push(x.to-str(10))
 
 // TODO: We can avoid this allocation if we add stack allocated arrays to the language,
 // and stack allocate an uninitialized [22]u8 instead of using a StrBuf
-fn fmt-impl(mut num uint, is-neg bool, format Format) str = {
-    let base = format.base()
+fn fmt-impl(mut num uint, is-neg bool, base u32) str = {
     let mut buf = StrBuf.with-cap(22)
 
     // TODO: We should be able to use an early return here,
diff --git a/tests/str-interp.jin b/tests/str-interp.jin
index 404c8d61..48358c81 100644
--- a/tests/str-interp.jin
+++ b/tests/str-interp.jin
@@ -1,10 +1,8 @@
-use std.int.(Format)
-
 fn main() = {
     let letter = "R"
     let n = 18
     println("{letter} is the {n}th letter of the alphabet.")
     println("{1} + {2} = {1 + 2}")
-    println("{420} is {420.to-str(Format.Hex)} in hex")
+    println("{420} is {420.to-str(16)} in hex")
     println("bool {true}, {!true}")
 }