diff --git a/src/backend/opencl/Array.cpp b/src/backend/opencl/Array.cpp
@@ -302,10 +302,16 @@ kJITHeuristics passesJitHeuristics(Node *root_node) {
         platform == AFCL_PLATFORM_NVIDIA || platform == AFCL_PLATFORM_APPLE;
     bool isAmd =
         platform == AFCL_PLATFORM_AMD || platform == AFCL_PLATFORM_APPLE;
+    bool isIntel = platform == AFCL_PLATFORM_INTEL;
+
+    /// Intels param_size limit is much smaller than the other platforms
+    /// so we need to start checking earlier with smaller trees
+    int heightCheckLimit =
+        isIntel && getDeviceType() == CL_DEVICE_TYPE_GPU ? 3 : 6;
 
     // A lightweight check based on the height of the node. This is
     // an inexpensive operation and does not traverse the JIT tree.
-    bool isParamLimit = (root_node->getHeight() > 6);
+    bool isParamLimit = (root_node->getHeight() >= heightCheckLimit);
     if (isParamLimit || isBufferLimit) {
         // This is the base parameter size if the kernel had no
         // arguments
@@ -317,11 +323,19 @@ kJITHeuristics passesJitHeuristics(Node *root_node) {
         constexpr size_t max_nvidia_param_size = (4096 - base_param_size);
         constexpr size_t max_amd_param_size    = (3520 - base_param_size);
 
+        // This value is really for the Intel HD Graphics platform. The CPU
+        // platform seems like it can handle unlimited parameters but the
+        // compile times become very large.
+        constexpr size_t max_intel_igpu_param_size =
+            (1024 - 256 - base_param_size);
+
         size_t max_param_size = 0;
         if (isNvidia) {
             max_param_size = max_nvidia_param_size;
         } else if (isAmd) {
             max_param_size = max_amd_param_size;
+        } else if (isIntel && getDeviceType() == CL_DEVICE_TYPE_GPU) {
+            max_param_size = max_intel_igpu_param_size;
         } else {
             max_param_size = 8192;
         }

diff --git a/src/backend/opencl/binary.hpp b/src/backend/opencl/binary.hpp
@@ -17,9 +17,7 @@
 namespace opencl {
 
 template<typename To, typename Ti, af_op_t op>
-struct BinOp {
-    const char *name() { return "__invalid"; }
-};
+struct BinOp;
 
 #define BINARY_TYPE_1(fn)                            \
     template<typename To, typename Ti>               \

diff --git a/src/backend/opencl/platform.cpp b/src/backend/opencl/platform.cpp
@@ -92,13 +92,24 @@ static inline string& ltrim(string& s) {
     return s;
 }
 
+bool verify_present(const std::string& pname, const std::string ref) {
+    auto iter = std::search(
+        begin(pname), end(pname), std::begin(ref), std::end(ref),
+        [](const std::string::value_type& l, const std::string::value_type& r) {
+            return tolower(l) == tolower(r);
+        });
+
+    return iter != end(pname);
+}
+
 static string platformMap(string& platStr) {
     using strmap_t                = map<string, string>;
     static const strmap_t platMap = {
         make_pair("NVIDIA CUDA", "NVIDIA"),
         make_pair("Intel(R) OpenCL", "INTEL"),
         make_pair("AMD Accelerated Parallel Processing", "AMD"),
         make_pair("Intel Gen OCL Driver", "BEIGNET"),
+        make_pair("Intel(R) OpenCL HD Graphics", "INTEL"),
         make_pair("Apple", "APPLE"),
         make_pair("Portable Computing Language", "POCL"),
     };

diff --git a/src/backend/opencl/platform.hpp b/src/backend/opencl/platform.hpp
@@ -54,9 +54,7 @@ class GraphicsResourceManager;
 struct kc_entry_t;  // kernel cache entry
 class PlanCache;    // clfft
 
-static inline bool verify_present(std::string pname, const char* ref) {
-    return pname.find(ref) != std::string::npos;
-}
+bool verify_present(const std::string& pname, const std::string ref);
 
 int getBackend();