Resolve Metal shader beside executable

Author: kernelzeroday

README.md

@@ -26,6 +26,18 @@ mkdir -p outputs
 mapping all weights or generating media. Run `./h3 --help` for the complete CLI
 reference.
 
+The Metal shader source is compiled at runtime. To run `h3` outside the source
+directory, install `h3_shaders.metal` beside the executable:
+
+```sh
+mkdir -p "$HOME/bin"
+install -m 755 h3 "$HOME/bin/h3"
+install -m 644 h3_shaders.metal "$HOME/bin/h3_shaders.metal"
+```
+
+Relative shader paths are checked in the current directory first and then next
+to the executable, so source-tree workflows remain unchanged.
+
 Without `-p`, the same binary starts an Iris-style interactive session:
 
 ```sh

h3_gpu.m

@@ -8,6 +8,7 @@
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
+#include <mach-o/dyld.h>
 #include <math.h>
 #include <stdarg.h>
 #include <stdio.h>
@@ -325,6 +326,25 @@ static int h3_gpu_dispatch_rows(H3GPU *gpu, NSString *name, uint32_t rows,
     return 1;
 }
 
+static NSString *h3_gpu_executable_relative_path(NSString *relative_path) {
+    if (!relative_path || relative_path.isAbsolutePath) return nil;
+
+    uint32_t size = 0;
+    if (_NSGetExecutablePath(NULL, &size) != -1 || !size) return nil;
+    char *buffer = malloc(size);
+    if (!buffer) return nil;
+    if (_NSGetExecutablePath(buffer, &size) != 0) {
+        free(buffer);
+        return nil;
+    }
+
+    NSString *executable = [NSString stringWithUTF8String:buffer];
+    free(buffer);
+    if (!executable) return nil;
+    return [[executable stringByDeletingLastPathComponent]
+        stringByAppendingPathComponent:relative_path];
+}
+
 h3_gpu *h3_gpu_create(const char *shader_source_path,
                       char *error, size_t error_size) {
     @autoreleasepool {
@@ -352,11 +372,24 @@ static int h3_gpu_dispatch_rows(H3GPU *gpu, NSString *name, uint32_t rows,
         }
         const char *source_path = shader_source_path ? shader_source_path :
                                                        "h3_shaders.metal";
-        NSString *path = [NSString stringWithUTF8String:source_path];
+        NSString *requestedPath = [NSString stringWithUTF8String:source_path];
+        NSString *path = requestedPath;
+        NSString *executableRelativePath = nil;
         NSError *libraryError = nil;
         NSString *source = [NSString stringWithContentsOfFile:path
                                                      encoding:NSUTF8StringEncoding
                                                         error:&libraryError];
+        if (!source) {
+            executableRelativePath =
+                h3_gpu_executable_relative_path(requestedPath);
+            if (executableRelativePath) {
+                libraryError = nil;
+                source = [NSString stringWithContentsOfFile:executableRelativePath
+                                                   encoding:NSUTF8StringEncoding
+                                                      error:&libraryError];
+                if (source) path = executableRelativePath;
+            }
+        }
         if (source) {
             MTLCompileOptions *options = [[MTLCompileOptions alloc] init];
             options.mathMode = MTLMathModeSafe;
@@ -396,8 +429,16 @@ static int h3_gpu_dispatch_rows(H3GPU *gpu, NSString *name, uint32_t rows,
         if (!gpu.library) {
             if (error && error_size) {
                 const char *description = libraryError.localizedDescription.UTF8String;
-                snprintf(error, error_size, "cannot compile %s: %s",
-                         source_path, description ? description : "unknown error");
+                if (!source && executableRelativePath) {
+                    snprintf(error, error_size, "cannot read %s or %s: %s",
+                             requestedPath.UTF8String,
+                             executableRelativePath.UTF8String,
+                             description ? description : "unknown error");
+                } else {
+                    snprintf(error, error_size, "cannot compile %s: %s",
+                             path.UTF8String,
+                             description ? description : "unknown error");
+                }
             }
             return NULL;
         }