diff --git a/toolchainlib/src/compression.luau b/toolchainlib/src/compression.luau
index f6bbad1..54241da 100644
--- a/toolchainlib/src/compression.luau
+++ b/toolchainlib/src/compression.luau
@@ -64,7 +64,11 @@ local decompress: { [CompressionFormat]: (compressed: buffer) -> Result<pathfs.A
 					-- FIXME: remove unknown usage
 					:withStdioStrategy({
 						stdout = Option.Some("pipe" :: CommandBuilder.StdioStrategy) :: Option<unknown>,
-						stderr = Option.Some(if process.env.PESDE_LOG == "debug" then "forward" else "pipe" :: CommandBuilder.StdioStrategy) :: Option<unknown>,
+						stderr = Option.Some(
+							if process.env.PESDE_LOG == "debug"
+								then "forward"
+								else "pipe" :: CommandBuilder.StdioStrategy
+						) :: Option<unknown>,
 					} :: CommandBuilder.IoStrategyMapping)
 					:intoChildProcess()
 
@@ -91,7 +95,4 @@ local decompress: { [CompressionFormat]: (compressed: buffer) -> Result<pathfs.A
 	-- TODO: Other formats
 }
 
--- local path = "pesde-0.5.0-rc.7-windows-x86_64.zip"
--- print(decompress[detectFormat(path):unwrap()](buffer.fromstring(pathfs.readFile(path))))
-
 return { decompress = decompress, detectFormat = detectFormat }
diff --git a/toolchainlib/src/init.luau b/toolchainlib/src/init.luau
index 24825a1..3fcfc60 100644
--- a/toolchainlib/src/init.luau
+++ b/toolchainlib/src/init.luau
@@ -47,22 +47,30 @@ export type GithubReleases = {
 	}
 }
 
+local WARN_PREFIX = `{stdio.color("yellow")}{stdio.style("bold")}warn{stdio.color("reset")}:`
+
+local function warn(...)
+	stdio.ewrite(`{WARN_PREFIX} {stdio.format(...)}\n`)
+end
+
 local function downloadAndDecompress(asset: {
 	name: string,
 	browser_download_url: string,
 	size: number,
 	content_type: string,
-}): pathfs.Path
+}): Option<pathfs.Path>
+	-- TODO: Small optimization by first detecting that its a valid format we support
+	-- before downloading the file
 	local contentsResp = net.request(asset.browser_download_url)
 	if not contentsResp.ok then
 		return error(`Failed to download asset {asset.name}: HTTP Code {contentsResp.statusCode}`)
 	end
 
-	local decompressedPath = compression.decompress
-		[compression.detectFormat(asset.name):unwrap()](buffer.fromstring(contentsResp.body))
-		:unwrap() :: pathfs.Path
-
-	return decompressedPath
+	return compression
+			.detectFormat(asset.name)
+			:map(function(format: compression.CompressionFormat)
+				return compression.decompress[format](buffer.fromstring(contentsResp.body)):unwrap() :: pathfs.Path
+			end) :: Option<pathfs.Path>
 end
 
 local function toolAliasOrDefault(tool: ToolId): string
@@ -125,30 +133,39 @@ function installTool(tool: ToolId, installPath: pathfs.Path)
 	local aliasPath = pathfs.Path.from(toolAlias):withExtension(if currentDesc.os == "windows" then "exe" else "")
 
 	for _, asset in assets do
-		local desc = PlatformDescriptor.fromString(asset.name):unwrap()
-		if eq(currentDesc, desc) then
+		local desc = PlatformDescriptor.fromString(asset.name)
+		local descWithArch = desc:map(function(inner: PlatformDescriptor.PlatformDescriptor)
+			-- FIXME: unknown usage
+			return inner
+		end)
+
+		if descWithArch:isOk() and eq(currentDesc, descWithArch:unwrap()) then
 			matchingAsset = asset
+			break
 		end
 	end
 
 	local binaryPath: pathfs.Path
 	if matchingAsset == nil then
-		stdio.ewrite("No matching asset found, testing all binaries")
+		warn("Pesde could not find a matching binary for your system")
+		warn("Will now attempt to download all binaries and find a matching one")
 		for _, asset in assets do
 			local decompressedPath = downloadAndDecompress(asset)
+			if decompressedPath:isSome() then
+				local path = decompressedPath:unwrap()
+				for _, file in pathfs.readDir(path) do
+					local filePath = path:join(file)
+					local nativeDesc = PlatformDescriptor.fromExecutable(filePath:toString()):unwrap()
 
-			for _, file in pathfs.readDir(decompressedPath) do
-				local filePath = decompressedPath:join(file)
-				local nativeDesc = PlatformDescriptor.fromExecutable(filePath:toString()):unwrap()
-
-				if eq(currentDesc, nativeDesc) then
-					binaryPath = filePath
-					break
+					if eq(currentDesc, nativeDesc) then
+						binaryPath = filePath
+						break
+					end
 				end
 			end
 		end
 	else
-		local decompressedPath = downloadAndDecompress(matchingAsset)
+		local decompressedPath = downloadAndDecompress(matchingAsset):unwrap()
 		binaryPath = decompressedPath:join(aliasPath)
 		if not pathfs.isFile(binaryPath) then
 			error(`No matching binary found in {decompressedPath}`)
diff --git a/toolchainlib/src/platform/descriptor.luau b/toolchainlib/src/platform/descriptor.luau
index 4c39de7..516ea93 100644
--- a/toolchainlib/src/platform/descriptor.luau
+++ b/toolchainlib/src/platform/descriptor.luau
@@ -14,11 +14,15 @@ type Option<T> = types.Option<T>
 type Result<T, E> = types.Result<T, E>
 
 local PlatformDescriptor = {}
-type PlatformDescriptor = {
+export type PlatformDescriptor = {
 	os: process.OS,
 	arch: Option<arch.Arch>,
 	toolchain: Option<toolchain.Toolchain>,
 }
+type ExecutableDetectionResult = {
+	os: Option<process.OS>,
+	arch: Option<arch.Arch>,
+}
 
 function PlatformDescriptor.currentSystem(): PlatformDescriptor
 	return {
@@ -43,12 +47,20 @@ end
 
 function PlatformDescriptor.fromExecutable(path: string): result.PlatformResult<PlatformDescriptor>
 	local binaryContents = fs.readFile(path)
-	local detected =
-		Option.from(detectFromExecutable(buffer.fromstring(binaryContents))) :: Option<detectFromExecutable.ExecutableDetectionResult>
-	local platformDesc = detected:map(function(inner: detectFromExecutable.ExecutableDetectionResult)
-		local innerClone: PlatformDescriptor = table.clone(inner) :: any
-		innerClone.toolchain = Option.None :: Option<toolchain.Toolchain>
-		return innerClone
+	local detected = Option.from(detectFromExecutable(buffer.fromstring(binaryContents)))
+		:map(function(inner: detectFromExecutable.ExecutableDetectionResult): ExecutableDetectionResult
+			return {
+				os = Option.from(inner.os) :: Option<process.OS>,
+				arch = Option.from(inner.arch) :: Option<arch.Arch>,
+			}
+		end) :: Option<ExecutableDetectionResult>
+
+	local platformDesc = detected:map(function(inner: ExecutableDetectionResult): PlatformDescriptor
+		return {
+			os = inner.os:unwrap(),
+			arch = inner.arch :: Option<arch.Arch>,
+			toolchain = Option.None :: Option<toolchain.Toolchain>,
+		}
 	end) :: Option<PlatformDescriptor>
 
 	return platformDesc:okOr(
diff --git a/toolchainlib/src/platform/detection/executable.luau b/toolchainlib/src/platform/detection/executable.luau
index 7baf63b..f950745 100644
--- a/toolchainlib/src/platform/detection/executable.luau
+++ b/toolchainlib/src/platform/detection/executable.luau
@@ -79,13 +79,13 @@ return function(binaryContents: buffer): ExecutableDetectionResult?
 
 		return {
 			os = "macos",
-            --stylua: ignore
-			arch = (
-                if is64bit and cpuType == MACHO_CPU_TYPES.x86 then "x86_64"
-				elseif is64bit and cpuType == MACHO_CPU_TYPES.arm then "aarch64"
-				elseif is32bit and cpuType == MACHO_CPU_TYPES.x86 then "x86"
-				elseif is32bit and cpuType == MACHO_CPU_TYPES.arm then "arm"
-				else nil
+            --stylua: ignore
+			arch = (
+                if is64bit and cpuType == MACHO_CPU_TYPES.x86 then "x86_64"
+				elseif is64bit and cpuType == MACHO_CPU_TYPES.arm then "aarch64"
+				elseif is32bit and cpuType == MACHO_CPU_TYPES.x86 then "x86"
+				elseif is32bit and cpuType == MACHO_CPU_TYPES.arm then "arm"
+				else nil
             ),
 		}
 	end
diff --git a/toolchainlib/src/platform/detection/pattern.luau b/toolchainlib/src/platform/detection/pattern.luau
index 28efc52..44f12ac 100644
--- a/toolchainlib/src/platform/detection/pattern.luau
+++ b/toolchainlib/src/platform/detection/pattern.luau
@@ -24,8 +24,10 @@ return function<T>(str: string, substrings: { [T]: { string } }, fullWords: { [T
 	local components = String.splitAtChar(lowercased, charWordSep)
 	for _, component in components do
 		for item, keywords in fullWords do
-			if table.find(keywords, component) then
-				return Option.Some(item) :: Option<T>
+			for _, keyword in keywords do
+				if string.find(component, keyword) then
+					return Option.Some(item) :: Option<T>
+				end
 			end
 		end
 	end