How can I use UnityShaderCompiler.exe?

Okay so this is relevant enough to the question that I figure it is worth sharing.

I still wanted to be able to compile shaders during runtime, so I made a OpenGL context that runs under the hood (it's "headless", i.e., not attached to a window) and renders to a texture, and then transfers data back to Unity. Cool part about this is now I have the full functionality of any OpenGL call in unity, even if my project itself is using, say, DirectX11. It uses OpenGL.NET which allows all of this code to work without any external plugins.

Here's the code. After dropping OpenGL.Net.dll into your Assets/Plugin folder, attach this script to some game object and press Play. Then, if you look at its unityTexture, it will display a texture that is the result after running a native compute shader :) (It should be come gradient thing)

 using UnityEngine;
 using OpenGL;
 using System.Runtime.InteropServices;
 using System;
 using System.Text;
 using System.IO;
 
 public class NativeCompute : MonoBehaviour {
 
     public Texture2D unityTexture;
 
     // From http://www.pinvoke.net
     [DllImport("user32.dll")]
     static extern IntPtr GetActiveWindow();
 
     [DllImport("user32.dll")]
     static extern IntPtr GetDC(IntPtr hWnd);
 
     [DllImport("user32.dll")]
     static extern bool ReleaseDC(IntPtr hWnd, IntPtr hDC);
 
     void MakeTempContext()
     {
         // OpenGl context without window, from http://stackoverflow.com/questions/576896/can-you-create-opengl-context-without-opening-a-window
         // We'll just use the active window and then not perturb it
         hwnd = GetActiveWindow();
         Wgl.PIXELFORMATDESCRIPTOR pfd = new Wgl.PIXELFORMATDESCRIPTOR();
         
         // Get the device context
         hdc = GetDC(hwnd);
 
         // Set the pixel format for the DC
         pfd.nSize = (short)Marshal.SizeOf(typeof(Wgl.PIXELFORMATDESCRIPTOR));
         pfd.nVersion = 1;
         pfd.dwFlags = Wgl.PixelFormatDescriptorFlags.SupportOpenGL;
         pfd.iPixelType = Wgl.PFD_TYPE_RGBA;
         pfd.cColorBits = 32;
         pfd.cDepthBits = 24;
 
         int iFormat = Wgl.ChoosePixelFormat(hdc, ref pfd);
 
         Wgl.SetPixelFormat(hdc, iFormat, ref pfd);
 
         // Create our temporary OpenGL context
         hrc = Wgl.CreateContext(hdc);
         Wgl.MakeCurrent(hdc, hrc);
     }
 
     IntPtr hwnd;
     IntPtr hdc;
     IntPtr hrc;
 
     void DeleteTempContext()
     {
         // We have made our actual context, we can get rid of our temporary one now
         Wgl.MakeCurrent(IntPtr.Zero, IntPtr.Zero);
         Wgl.DeleteContext(hrc);
     }
 
 
     uint CompileComputeShader(string shaderText, out string infoLog)
     {
         // Create shader
         uint shader = Gl.CreateShader(Gl.COMPUTE_SHADER);
 
         // Set shader source code
         Gl.ShaderSource(shader, new string[] { shaderText });
 
         // Compile shader
         Gl.CompileShader(shader);
 
         // Check for compilation errors, false (0) if error, true (1) if success
         int didCompile;
         Gl.GetShader(shader, Gl.COMPILE_STATUS, out didCompile);
 
         if (didCompile == Gl.FALSE)
         {
             int infoLogLength;
             Gl.GetShader(shader, Gl.INFO_LOG_LENGTH, out infoLogLength);
 
             StringBuilder resultInfo = new StringBuilder(infoLogLength);
             int gotLength;
             Gl.GetShaderInfoLog(shader, infoLogLength, out gotLength, resultInfo);
             infoLog = "Compilation error:\n" + resultInfo.ToString();
             return 0;
         }
 
         // Create shader program that holds our compute shader
         uint program = Gl.CreateProgram();
 
         // Attach our shader
         Gl.AttachShader(program, shader);
 
         // Link the program together
         Gl.LinkProgram(program);
 
         // Check for link errors
         int didLink;
         Gl.GetProgram(program, Gl.LINK_STATUS, out didLink);
 
         if (didLink == Gl.FALSE)
         {
             int infoLogLength;
             Gl.GetProgram(program, Gl.INFO_LOG_LENGTH, out infoLogLength);
 
             StringBuilder resultInfo = new StringBuilder(infoLogLength);
             int gotLength;
             Gl.GetProgramInfoLog(program, infoLogLength, out gotLength, resultInfo);
             infoLog = "Link error:\n" + resultInfo.ToString();
             return 0;
         }
 
         // No errors were found, compiled successfully!
         infoLog = "";
 
         return program;
     }
 
 
     void Start()
     {
         // Make temporary context
         MakeTempContext();
 
         // Use OpenGL 4.3, min OpenGL needed for compute shaders
         int[] attribs = new int[]
         {
             Wgl.CONTEXT_MAJOR_VERSION_ARB, 4,
             Wgl.CONTEXT_MINOR_VERSION_ARB, 3,
             0
         };
 
         // Make actual context
         // We need to make our temporary one first because OpenGL is weird and
         //   doesn't let you call this unless you are in an active context already
         IntPtr other = Wgl.CreateContextAttribsARB(hdc, IntPtr.Zero, attribs);
 
         // Delete temporary context
         DeleteTempContext();
 
         // Set our actual context to be used
         Wgl.MakeCurrent(hdc, other);
 
 
         // Put shaders in ProjectRoot/Shaders (make a new folder named that)
         // If these shaders are in Assets, Unity will get upset because they aren't in its format
         string shaderFolder = Application.dataPath + "/../Shaders/";
 
         // Compile our compute shader and test for errors
         string infoLog;
         uint testProgram = CompileComputeShader(File.ReadAllText(shaderFolder + "test.compute"), out infoLog);
         if (testProgram == 0)
         {
             Debug.Log("Failed to compile compute shader: " + infoLog);
             return;
         }
 
         // Create the texture we will be rendering to
         int textureWidth = 512;
         int textureHeight = 512;
         uint texture = Gl.GenTexture();
         Gl.BindTexture(TextureTarget.Texture2d, texture);
         Gl.TexParameter(TextureTarget.Texture2d, TextureParameterName.TextureMagFilter, Gl.NEAREST);
         Gl.TexParameter(TextureTarget.Texture2d, TextureParameterName.TextureMinFilter, Gl.NEAREST);
         Gl.TexParameter(TextureTarget.Texture2d, TextureParameterName.TextureWrapS, Gl.CLAMP_TO_EDGE);
         Gl.TexParameter(TextureTarget.Texture2d, TextureParameterName.TextureWrapT, Gl.CLAMP_TO_EDGE);
         Gl.TexImage2D(TextureTarget.Texture2d, 0, Gl.RGBA8, textureWidth, textureHeight, 0, PixelFormat.Bgra, PixelType.UnsignedByte, IntPtr.Zero);
 
         // Create framebuffer
         uint framebuffer = Gl.GenFramebuffer();
         Gl.BindFramebuffer(Gl.FRAMEBUFFER, framebuffer);
         Gl.FramebufferTexture2D(Gl.FRAMEBUFFER, Gl.COLOR_ATTACHMENT0, Gl.TEXTURE_2D, texture, 0);
 
         // Create renderbuffer
         uint depthRenderbuffer = Gl.GenRenderbuffer();
         Gl.BindRenderbuffer(Gl.RENDERBUFFER, depthRenderbuffer);
         Gl.RenderbufferStorage(Gl.RENDERBUFFER, Gl.DEPTH_COMPONENT24, textureWidth, textureHeight);
 
         // Attach renderbuffer to framebuffer
         Gl.FramebufferRenderbuffer(Gl.FRAMEBUFFER, Gl.DEPTH_ATTACHMENT, Gl.RENDERBUFFER, depthRenderbuffer);
 
         // Make sure we successfully attached it
         int framebufferStatus = Gl.CheckFramebufferStatus(Gl.FRAMEBUFFER);
 
         if (framebufferStatus != Gl.FRAMEBUFFER_COMPLETE)
         {
             Debug.Log("Failed to create framebuffer");
             return;
         }
 
         // Clear texture to black. This isn't actually needed since we are going to overwrite every pixel
         Gl.ClearColor(0, 0, 0, 0);
         Gl.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
 
         // Tell OpenGl that we are going to be using our program soon
         Gl.UseProgram(testProgram);
 
         // Bind our texture to the destTex uniform variable in the shader
         // (uniform means that it gets values from some non-shader code)
         uint unit = 0;
         int location = Gl.GetUniformLocation(testProgram, "destTex");
         Gl.Uniform1(location, unit);
         Gl.BindImageTexture(unit, texture, 0, false, 0, Gl.READ_WRITE, Gl.RGBA8);
 
         // Run our compute shader with one work group per pixel. This is not optimal but works as an example
         Gl.DispatchCompute((uint)textureWidth, (uint)textureHeight, 1);
 
         // Wait until our compute shader is done
         Gl.MemoryBarrier(Gl.SHADER_IMAGE_ACCESS_BARRIER_BIT);
 
         // Now we can retreive the data, we want to store it to a Color32[] to be sent to our Unity textures
         Color32[] pixels = new Color32[textureWidth * textureHeight];
 
         // Get the IntPtr to our array
         GCHandle pinnedArray = GCHandle.Alloc(pixels, GCHandleType.Pinned);
         IntPtr pixelArrayPointer = pinnedArray.AddrOfPinnedObject();
 
         // Read our pixels. This writes directly to our Color32[] array as desired
         Gl.ReadPixels(0, 0, textureWidth, textureHeight, PixelFormat.Bgra, PixelType.UnsignedByte, pixelArrayPointer);
 
         // Free our IntPtr since we are done with it
         pinnedArray.Free();
 
         // Create our unity texture. Remember that SetPixels32 only works when you are using TextureFormat.ARGB32
         unityTexture = new Texture2D(textureWidth, textureHeight, TextureFormat.ARGB32, false);
         unityTexture.filterMode = FilterMode.Point;
 
         // Set the contents of our new texture to the retreived texture pixels
         unityTexture.SetPixels32(pixels);
         unityTexture.Apply();
 
         // Unbind framebuffer
         Gl.BindFramebuffer(Gl.FRAMEBUFFER, 0);
 
         // Delete texture
         Gl.DeleteTextures(1, texture);
 
         // Delete renderbuffer
         Gl.DeleteRenderbuffers(1, depthRenderbuffer);
 
         // Delete framebuffer
         Gl.DeleteFramebuffers(1, framebuffer);
 
         // Delete OpenGl context because we are done
         // You shouldn't do this until you are done using native OpenGL,
         // for example it might make sense to put this in OnApplicationQuit
         Wgl.MakeCurrent(IntPtr.Zero, IntPtr.Zero);
         Wgl.DeleteContext(other);

         Wgl.ReleaseDC(hwnd, hdc);
     }
 }

And here's the compute shader. Name this test.compute and put it in ProjectRoot/Shaders (make a new folder named that), because if native shaders are in Assets, Unity will get upset because they aren't in its format.

 #version 430
 layout(local_size_x = 1, local_size_y = 1) in;
 layout(rgba32f) uniform image2D destTex;
 
 void main() {
     ivec2 pos = ivec2(gl_GlobalInvocationID.xy);
     imageStore(destTex, pos, vec4(sin(pos.x/512.0), sin(pos.y/512.0), cos(pos.x/512.0), 1.0));
 }