diff --git a/runtime/src/main/kotlin/argument/primitive/ByteArgument.kt b/runtime/src/main/kotlin/argument/primitive/ByteArgument.kt
new file mode 100644
index 0000000..1d4ef48
--- /dev/null
+++ b/runtime/src/main/kotlin/argument/primitive/ByteArgument.kt
@@ -0,0 +1,31 @@
+package dev.kord.x.commands.argument.primitive
+
+import dev.kord.x.commands.argument.SingleWordArgument
+import dev.kord.x.commands.argument.result.WordResult
+
+internal class InternalByteArgument(
+    override val name: String = "Number",
+    private val radix: Int = 10
+) :
+    SingleWordArgument<Byte, Any?>() {
+
+    override suspend fun parse(word: String, context: Any?): WordResult<Byte> =
+        when (val number = word.toByteOrNull(radix)) {
+            null -> failure("Expected a number.")
+            else -> success(number)
+        }
+}
+
+/**
+ * Argument that matches against a single world,
+ * emitting success when the word is a valid [Byte] value.
+ */
+val ByteArgument: dev.kord.x.commands.argument.Argument<Byte, Any?> = InternalByteArgument()
+
+/**
+ * Argument with [name] and [radix] that matches against a single world,
+ * emitting success when the word is a valid [Byte] value.
+ */
+@Suppress("FunctionName")
+fun ByteArgument(name: String, radix: Int = 10): dev.kord.x.commands.argument.Argument<Byte, Any?> =
+    InternalByteArgument(name, radix)
diff --git a/runtime/src/main/kotlin/argument/primitive/FloatArgument.kt b/runtime/src/main/kotlin/argument/primitive/FloatArgument.kt
new file mode 100644
index 0000000..09362f3
--- /dev/null
+++ b/runtime/src/main/kotlin/argument/primitive/FloatArgument.kt
@@ -0,0 +1,26 @@
+package dev.kord.x.commands.argument.primitive
+
+import dev.kord.x.commands.argument.SingleWordArgument
+import dev.kord.x.commands.argument.result.WordResult
+
+internal class InternalFloatArgument(override val name: String = "Number") :
+    SingleWordArgument<Float, Any?>() {
+
+    override suspend fun parse(word: String, context: Any?): WordResult<Float> =
+        when (val number = word.toFloatOrNull()) {
+            null -> failure("Expected a number.")
+            else -> success(number)
+        }
+}
+
+/**
+ * Argument that matches against a single world, emitting success when the word is a valid [Float] value.
+ */
+val FloatArgument: dev.kord.x.commands.argument.Argument<Float, Any?> = InternalFloatArgument()
+
+/**
+ * Argument with [name] that matches against a single world, emitting success when the word is a valid [Float] value.
+ */
+@Suppress("FunctionName")
+fun FloatArgument(name: String): dev.kord.x.commands.argument.Argument<Float, Any?> =
+    InternalFloatArgument(name)
diff --git a/runtime/src/main/kotlin/argument/primitive/IntArgument.kt b/runtime/src/main/kotlin/argument/primitive/IntArgument.kt
index 64e784d..142ad3c 100644
--- a/runtime/src/main/kotlin/argument/primitive/IntArgument.kt
+++ b/runtime/src/main/kotlin/argument/primitive/IntArgument.kt
@@ -3,12 +3,15 @@ package dev.kord.x.commands.argument.primitive
 import dev.kord.x.commands.argument.SingleWordArgument
 import dev.kord.x.commands.argument.result.WordResult
 
-internal class InternalIntArgument(override val name: String = "Number") :
+internal class InternalIntArgument(
+    override val name: String = "Number",
+    private val radix: Int = 10
+) :
     SingleWordArgument<Int, Any?>() {
     override suspend fun parse(
         word: String,
         context: Any?
-    ): WordResult<Int> = when (val number = word.toIntOrNull()) {
+    ): WordResult<Int> = when (val number = word.toIntOrNull(radix)) {
         null -> failure("Expected a whole number.")
         else -> success(number)
     }
@@ -16,13 +19,15 @@ internal class InternalIntArgument(override val name: String = "Number") :
 }
 
 /**
- * Argument that matches against a single world, emitting success when the word is a valid integer value.
+ * Argument that matches against a single world,
+ * emitting success when the word is a valid [Int] value.
  */
 val IntArgument: dev.kord.x.commands.argument.Argument<Int, Any?> = InternalIntArgument()
 
 /**
- * Argument with [name] that matches against a single world, emitting success when the word is a valid integer value.
+ * Argument with [name] and [radix] that matches against a single world,
+ * emitting success when the word is a valid [Int] value.
  */
 @Suppress("FunctionName")
-fun IntArgument(name: String): dev.kord.x.commands.argument.Argument<Int, Any?> =
-    InternalIntArgument(name)
+fun IntArgument(name: String, radix: Int = 10): dev.kord.x.commands.argument.Argument<Int, Any?> =
+    InternalIntArgument(name, radix)
diff --git a/runtime/src/main/kotlin/argument/primitive/LongArgument.kt b/runtime/src/main/kotlin/argument/primitive/LongArgument.kt
index 0978403..a1fd49d 100644
--- a/runtime/src/main/kotlin/argument/primitive/LongArgument.kt
+++ b/runtime/src/main/kotlin/argument/primitive/LongArgument.kt
@@ -3,13 +3,16 @@ package dev.kord.x.commands.argument.primitive
 import dev.kord.x.commands.argument.SingleWordArgument
 import dev.kord.x.commands.argument.result.WordResult
 
-internal class InternalLongArgument(override val name: String = "Number") :
+internal class InternalLongArgument(
+    override val name: String = "Number",
+    private val radix: Int = 10
+) :
     SingleWordArgument<Long, Any?>() {
 
     override suspend fun parse(
         word: String,
         context: Any?
-    ): WordResult<Long> = when (val number = word.toLongOrNull()) {
+    ): WordResult<Long> = when (val number = word.toLongOrNull(radix)) {
         null -> failure("Expected a number.")
         else -> success(number)
     }
@@ -17,13 +20,15 @@ internal class InternalLongArgument(override val name: String = "Number") :
 }
 
 /**
- * Argument that matches against a single world, emitting success when the word is a valid long value.
+ * Argument that matches against a single world,
+ * emitting success when the word is a valid [Long] value.
  */
 val LongArgument: dev.kord.x.commands.argument.Argument<Long, Any?> = InternalLongArgument()
 
 /**
- * Argument with [name] that matches against a single world, emitting success when the word is a valid long value.
+ * Argument with [name] and [radix] that matches against a single world,
+ * emitting success when the word is a valid [Long] value.
  */
 @Suppress("FunctionName")
-fun LongArgument(name: String): dev.kord.x.commands.argument.Argument<Long, Any?> =
-    InternalLongArgument(name)
+fun LongArgument(name: String, radix: Int = 10): dev.kord.x.commands.argument.Argument<Long, Any?> =
+    InternalLongArgument(name, radix)
diff --git a/runtime/src/main/kotlin/argument/primitive/ShortArgument.kt b/runtime/src/main/kotlin/argument/primitive/ShortArgument.kt
new file mode 100644
index 0000000..79e64f6
--- /dev/null
+++ b/runtime/src/main/kotlin/argument/primitive/ShortArgument.kt
@@ -0,0 +1,32 @@
+package dev.kord.x.commands.argument.primitive
+
+import dev.kord.x.commands.argument.SingleWordArgument
+import dev.kord.x.commands.argument.result.WordResult
+
+internal class InternalShortArgument(override val name: String = "Number", private val radix: Int) :
+    SingleWordArgument<Short, Any?>() {
+
+    override suspend fun parse(word: String, context: Any?): WordResult<Short> =
+        when (val number = word.toShortOrNull(radix)) {
+            null -> failure("Expected a number.")
+            else -> success(number)
+        }
+}
+
+/**
+ * Argument that matches against a single world,
+ * emitting success when the word is a valid [Short] value.
+ */
+val ShortArgument: dev.kord.x.commands.argument.Argument<Short, Any?> =
+    InternalShortArgument(radix = 10)
+
+/**
+ * Argument with [name] and [radix] that matches against a single world,
+ * emitting success when the word is a valid [Short] value.
+ */
+@Suppress("FunctionName")
+fun ShortArgument(
+    name: String,
+    radix: Int = 10
+): dev.kord.x.commands.argument.Argument<Short, Any?> =
+    InternalShortArgument(name, radix)