diff --git HexagonBase/includes/alter/theme_registry.alter.inc HexagonBase/includes/alter/theme_registry.alter.inc
index fd13f59..2a7ace9 100644
--- HexagonBase/includes/alter/theme_registry.alter.inc
+++ HexagonBase/includes/alter/theme_registry.alter.inc
@@ -24,84 +24,88 @@ foreach (hex_get_theme_registry_files() as $file) {
  */
 function hex_theme_registry_hex_alter(&$registry) {
 
+  $active_theme   = hex_active_theme();
+  $active_plugins = hex_plugin_list();
+  $vars_processors_inc = hex_path('theme', 'hex') . '/includes/vars_processors.inc';
+
   // hook_theme() for plug-ins.
-  foreach (hex_plugin_list() as $plugin) {
-    _theme_process_registry($registry, $plugin, 'plugin', $plugin, hex_plugin_path($plugin));
+  foreach ($active_plugins as $plugin) {
+    _theme_process_registry($registry, $plugin, 'plugin', $plugin, hex_path('plugin', $plugin));
   }
 
+  // Fill in gaps in the theme registry.
+  hex_theme_registry_fill($registry);
+
   $includes = array();
   foreach (hex_get_theme_registry_files() as $file) {
     switch ($file->type) {
       case 'theme':
       case 'func' :
       case 'vars' :
-        $includes[$file->name][] = $file->uri;
+        $includes[$file->name][end($file->hosts)] = $file->uri;
     }
   }
 
-  $active_theme = hex_active_theme();
-  $include_vars = hex_path('theme', 'hex') . '/includes/include_vars.inc';
-
   foreach ($registry as $theme_hook => &$hook_info) {
 
-    // build hook info.
-    $hex_info = hex_hook_info($registry, $theme_hook, $hook_info);
+    // Get hook info.
+    $hex_info = hex_hook_info($registry, $theme_hook);
 
     // Initialize. Make sure these elements are available.
     // Empty elements will be removed later.
     $hook_includes = &$hook_info['includes'];
+    $vars_includes = &$hook_info['vars includes'];
     $preprocesses  = &$hook_info['preprocess functions'];
     $processes     = &$hook_info['process functions'];
-    foreach (array('includes', 'preprocess functions', 'process functions') as $key) {
+
+    foreach (array('includes', 'vars includes', 'preprocess functions', 'process functions') as $key) {
       if (!isset($hook_info[$key])) {
         $hook_info[$key] = array();
       }
     }
 
-    // Add HOOK_SOURCE.theme.inc files into Core's ability to include them on
-    // the fly through theme() calls. The hook source is which ever module,
-    // theme or plug-in that originally implements the theming hook.
+    // Add HOOK_ORIGIN.theme.inc files into Core's ability to include them on
+    // the fly through theme() calls. The hook origin is which ever module,
+    // theme or plug-in that originally implements the theming hook through
+    // hook_theme().
     //
     // Process:
     // - [ MODULE | THEME | PLUGIN ].theme.inc
-
-    if ($hex_info->implement_level !== 'module') {
-      // Multiple sources since hook patterns can be defined separately from base hook.
-      foreach ($hex_info->sources as $source) {
-        if (isset($includes["$source.theme"]) && !in_array("$source.theme", $hook_includes)) {
-          $hook_includes = array_merge($hook_includes, $includes["$source.theme"]);
+    if ($hex_info->is_base) {
+      foreach ($hex_info->processed_by as $component) {
+        if (isset($includes["{$hex_info->origin}.theme"][$component])) {
+          $hook_includes[] = $includes["{$hex_info->origin}.theme"][$component];
         }
       }
     }
 
-    // ->hooks can contain both the base hook and pattern hook.
-    foreach ($hex_info->hooks as $hook) {
-      $hook_name = str_replace('_', '-', $hook);
+    // Include:
+    // - [ HOOK ].func.inc
+    $hook_name = str_replace('_', '-', $theme_hook);
 
-      // Process:
-      // - [ HOOK ].func.inc
-      // - [ HOOK--PATTERN ].func.inc
+    if ($hex_info->host_type === 'theme'
+    &&  $hex_info->implement_type  === 'func'
+    &&  isset($includes["$hook_name.func"])) {
+      // Use last element which will be in the child-most theme.
+      $hook_includes[] = end($includes["$hook_name.func"]);
+    }
 
-      if ($hex_info->implement_level === 'theme'
-      &&  $hex_info->implement_type  === 'func'
-      &&  isset($includes["$hook_name.func"])) {
-        // Use last element which will be in the child-most theme.
-        $hook_includes[] = end($includes["$hook_name.func"]);
-      }
+    // The following files will host variables specific to the theming hook
+    // whether it is implemented as a function or template. Some are more
+    // focused than others.
+    //
+    // Process:
+    // - [ HOOK ].vars.inc
+    // - [ HOOK ].[ ACTIVE-THEME ].vars.inc
+    // - [ HOOK ].[ func | tpl ].vars.inc
+    // - [ HOOK ].[ ACTIVE-THEME ].[ func | tpl ].vars.inc
+    // - [ HOOK--PATTERN ].vars.inc
+    // - [ HOOK--PATTERN ].[ ACTIVE-THEME ].vars.inc
+    // - [ HOOK--PATTERN ].[ func | tpl ].vars.inc
+    // - [ HOOK--PATTERN ].[ ACTIVE-THEME ].[ func | tpl ].vars.inc
 
-      // The file will host variables specific to the theming hook whether it
-      // is implemented as a function or template. Some are more focused than
-      // others.
-      //
-      // Process:
-      // - [ HOOK ].vars.inc
-      // - [ HOOK ].[ ACTIVE-THEME ].vars.inc
-      // - [ HOOK ].[ func | tpl ].vars.inc
-      // - [ HOOK ].[ ACTIVE-THEME ].[ func | tpl ].vars.inc
-      // - [ HOOK--PATTERN ].vars.inc
-      // - [ HOOK--PATTERN ].[ ACTIVE-THEME ].vars.inc
-      // - [ HOOK--PATTERN ].[ func | tpl ].vars.inc
-      // - [ HOOK--PATTERN ].[ ACTIVE-THEME ].[ func | tpl ].vars.inc
+    foreach ($hex_info->hooks as $hook) {
+      $hook_name = str_replace('_', '-', $hook);
 
       foreach (array($hook_name,
                     "$hook_name.$active_theme",
@@ -111,73 +115,119 @@ function hex_theme_registry_hex_alter(&$registry) {
         if (isset($includes["$named.vars"])) {
 
           // Include the file that handles hook.vars.inc files.
-          if (!in_array($include_vars, $hook_includes)) {
-            $hook_includes[] = $include_vars;
+          if (!in_array($vars_processors_inc, $hook_includes)) {
+            $hook_includes[] = $vars_processors_inc;
           }
 
           // Move to the front of second phase process so it always comes after
           // preprocess functions but before process functions.
-
           if (!in_array('hex_variable_include_process', $processes)) {
             array_unshift($processes, 'hex_variable_include_process');
           }
+
           // Add path to allow the custom preprocessor to load the file.
-          if (!isset($hex_info->hex_variable_includes)) {
-            $hex_info->variable_includes = array();
-          }
-          $hex_info->variable_includes = array_merge($hex_info->variable_includes, $includes["$named.vars"]);
+          $vars_includes = array_merge($vars_includes, array_values($includes["$named.vars"]));
         }
       }
+    }
 
-      // Add in variable process functions for plugins.
-      if (hex_plugin_list()) {
-        $process_functions = array(
-          'preprocess' => &$preprocesses, 
-          'process'    => &$processes,
-        );
-        foreach ($process_functions as $phase => &$phase_process) {
-          foreach (hex_plugin_list() as $prefix) {
-            $var_func = $prefix . '_' . $phase;
-            if (isset($hook_info['template'])
-            && function_exists($var_func)
-            && !in_array($var_func, $phase_process)) {
-              // PLUGIN_preprocess() and PLUGIN_process() pushed up front.
-              array_unshift($phase_process, $var_func);
-            }
-            // The rest come last.
-            $var_hook_functions = array(
-              $var_func . '_' . $hook,
-              $var_func . '_' . $active_theme . '_' . $hook,
-            );
-            foreach ($var_hook_functions as $var_func) {
-              if (function_exists($var_func)
-              && !in_array($var_func, $phase_process)) {
-                $phase_process[] = $var_func;
-              }
-            }
+    // Add in variable process functions for plugins.
+    // Core only knows of modules and themes so plug-ins are added here manually.
+    foreach (array('preprocess', 'process') as $phase) {
+      foreach ($active_plugins as $prefix) {
+
+        $var_func = "{$prefix}_$phase";
+        if ($hex_info->is_base
+        &&  isset($hook_info['template'])
+        &&  function_exists($var_func)
+        && !in_array($var_func, $hook_info["$phase functions"])) {
+          // PLUGIN_preprocess/PLUGIN_process() pushed up front.
+          // Must be a base hook and be implemented as a template.
+          array_unshift($hook_info["$phase functions"], $var_func);
+        }
+
+        $var_func .= "_$theme_hook";
+        if (function_exists($var_func)
+        && !in_array($var_func, $hook_info["$phase functions"])) {
+          // PLUGIN_preprocess_HOOK/PLUGIN_process_HOOK() come last.
+          $hook_info["$phase functions"][] = $var_func;
+        }
+      }
+    }
+
+    // This is used to invoke variable processors when hook suggestions are
+    // involved. It works on two levels:
+    //
+    // 1. When theme('hook__suggestion') is invoked, the variable processors
+    //    for that hook will not be complete. What this does is add a specialzed
+    //    processor (hex_variable_preprocess_base & hex_variable_process_base)
+    //    to handle the invocation of the base functions. It does this by looking
+    //    at the differences between hook__suggestion and the base hook effectively
+    //    providing a complete set of variable processors.
+    // 2. When the suggestion is set from a variable processor, it prevents
+    //    the hook suggestion from having its own variable processors from
+    //    being invoked since it's in the same scope. What this does is add a
+    //    specialized processor (hex_variable_preprocess_suggestion &
+    //    hex_variable_process_suggestion) which handles the invocation of the
+    //    remaining processors for the suggestion.
+
+    if ($hex_info->base_hook) {
+      $hook_info['base'] = $hex_info->base_hook;
+    }
+
+    foreach (array('preprocess', 'process') as $phase) {
+      foreach ($hex_info->suggestions as $suggestion) {
+        $suggestion_info = &$registry[$suggestion];
+
+        if (!isset($suggestion_info["$phase functions"])) {
+          $suggestion_info["$phase functions"] = array();
+        }
+        elseif ($hex_info->is_base && !in_array("hex_variable_{$phase}_suggestion", $hook_info["$phase functions"])) {
+          $hook_info["$phase functions"][] = "hex_variable_{$phase}_suggestion";
+        }
+
+        $ignore = $suggestion_info["$phase functions"];
+        $ignore[] = "hex_variable_{$phase}_suggestion";
+        $ignore[] = 'hex_variable_include_process';
+        foreach ($hook_info["$phase functions"] as $i => $phase_function) {
+          if (!in_array($phase_function, $ignore)) {
+            $suggestion_info["$phase base diff"][] = $i;
+          }
+        }
+
+        if (!empty($suggestion_info["$phase base diff"])) {
+          if (!isset($suggestion_info['includes'])) {
+            $suggestion_info['includes'] = array();
+          }
+          if (!in_array($vars_processors_inc, $suggestion_info['includes'])) {
+            $suggestion_info['includes'][] = $vars_processors_inc;
+          }
+          if (!in_array("hex_variable_{$phase}_base", $suggestion_info["$phase functions"])) {
+            array_unshift($suggestion_info["$phase functions"], "hex_variable_{$phase}_base");
           }
         }
       }
     }
 
     // Optimize the registry.
-    foreach (array('includes', 'preprocess functions', 'process functions') as $key) {
+    foreach (array('includes', 'vars includes', 'preprocess functions', 'process functions') as $key) {
       if (empty($hook_info[$key])) {
         unset($hook_info[$key]);
       }
     }
-
-    // Add hex info to the registry.
-    $hook_info['hex_info'] = $hex_info;
+    // Base hook not needed. This is poorly handed in core's theme function so remove it.
+    if (isset($hook_info['base hook'])) {
+      unset($hook_info['base hook']);
+    }
   }
 }
 
 /**
- * Builds info about a theming hook for the theme registry.
+ * Builds metadata about a theming hook for the theme registry.
  */
-function hex_hook_info($registry, $theme_hook, $hook_info) {
+function hex_hook_info($registry, $theme_hook) {
 
-  $implement_levels = array(
+  $host_types = array(
     'module'            => 'module',
     'base_theme_engine' => 'theme',
     'base_theme'        => 'theme',
@@ -186,56 +236,143 @@ function hex_hook_info($registry, $theme_hook, $hook_info) {
     'plugin'            => 'plugin',
   );
 
-  $hex_info = new stdClass();
-  $hex_info->implement_level = $implement_levels[$hook_info['type']];
-  $hex_info->implement_type  = isset($hook_info['function']) ? 'func' : 'tpl';
-  $hex_info->element_type    = NULL;
-  if (isset($hook_info['render element'])) {
-    $hex_info->element_type = $hook_info['render element'];
-  }
+  $hook_info = $registry[$theme_hook];
 
-  $hook_sources = hex_get_theme_hook_sources();
+  $hex_info = new stdClass();
+  $hex_info->host_type      = $host_types[$hook_info['type']];
+  $hex_info->implement_type = isset($hook_info['function']) ? 'func' : 'tpl';
 
-  // Multiple hooks used since this accounts for hook__suggestions.
-  $hex_info->hooks = array($theme_hook);
+  $hook_origins = hex_get_theme_hook_origins();
+  $base_hook    = hex_find_parent_hook($hook_origins, $theme_hook, FALSE);
 
-  // Identify the source of the hook.
-  $_hook = isset($hook_info['base hook']) ? $hook_info['base hook'] : $theme_hook;
-  $hex_info->sources = array($hook_sources[$_hook]);
+  $hex_info->is_base   = isset($hook_origins[$theme_hook]);
+  $hex_info->base_hook = $base_hook;
 
-  // Do the same looking through named patterns.
+  // Multiple hooks used since this looks through hook__suggestions.
+  $hex_info->hooks = array($theme_hook);
   $hook = $theme_hook;
-  while ($pos = strrpos($hook, '__')) {
-    $hook = substr($hook, 0, $pos);
-    if (isset($registry[$hook])) {
-
-      $hex_info->hooks[] = $hook;
-
-      $_hook = isset($registry[$hook]['base hook']) ? $registry[$hook]['base hook'] : $hook;
-      if (!in_array($hook_sources[$_hook], $hex_info->sources)) {
-        $hex_info->sources[] = $hook_sources[$_hook];
-      }
+  // Stop when a base hook is reached or it can't go any further.
+  while (!isset($hook_origins[$hook]) && $hook = hex_find_parent_hook($registry, $hook, TRUE)) {
+    array_unshift($hex_info->hooks, $hook);
+  }
 
-    }
+  // Identify the origin of the hook.
+  if (isset($hook_origins[$theme_hook])) {
+    $hex_info->origin = $hook_origins[$theme_hook];
+  }
+  elseif ($base_hook && isset($hook_origins[$base_hook])) {
+    $hex_info->origin = $hook_origins[$base_hook];
   }
 
   // Look for the current host.
-  if ($hex_info->implement_level === 'module') {
-    $hex_info->host = $hex_info->sources[0];
+  if ($hex_info->host_type === 'module') {
+    $hex_info->host = $hex_info->origin;
   }
   else {
-    foreach (hex_list($hex_info->implement_level) as $name) {
-      if ($hook_info['theme path'] === hex_path($hex_info->implement_level, $name)) {
+    foreach (hex_list($hex_info->host_type) as $name) {
+      if ($hook_info['theme path'] === hex_path($hex_info->host_type, $name)) {
         $hex_info->host = $name;
         break;
       }
     }
   }
 
+  // Find out which themes or plugins processes the variables.
+  $components = hex_list('theme') + hex_list('plugin');
+  $hex_info->processed_by = array();
+
+  foreach (array('preprocess', 'process') as $phase) {
+    $phase_aggregate = array();
+    if (isset($hook_info["$phase functions"])) {
+      $phase_aggregate = $hook_info["$phase functions"];
+    }
+    if ($base_hook && isset($registry[$base_hook]["$phase functions"])) {
+      $phase_aggregate = array_merge($phase_aggregate, $registry[$base_hook]["$phase functions"]);
+    }
+    foreach ($phase_aggregate as $phase_function) {
+      $component = substr($phase_function, 0, strpos($phase_function, "_$phase"));
+      if (isset($components[$component]) && !in_array($component, $hex_info->processed_by)) {
+        $hex_info->processed_by[] = $component;
+      }
+    }
+  }
+
+  // Find "hook suggestions".
+  $hex_info->suggestions = array();
+  if (isset($hook_origins[$theme_hook])) {
+    foreach (preg_grep("/^($theme_hook)__/", array_keys($registry)) as $suggestion) {
+      if (!isset($hook_origins[$suggestion])) {
+        $hex_info->suggestions[] = $suggestion;
+      }
+    }
+  }
+
   return $hex_info;
 }
 
 /**
+ * Fills missing gaps in the theme registry.
+ * 
+ * Provides the following:
+ *  - New hooks based on variable process functions.
+ *  - New hooks based on .vars.inc files.
+ *  - Pattern based preprocess and process function connected to the new hook.
+ *  - Inherits includes, preprocess and process functions from a base hook to
+ *    the derivative hook pattern.
+ *
+ * It also removes the 'base hook' from the registry due to the poor way core
+ * handles it in the theme() function.
+ */
+function hex_theme_registry_fill(&$registry) {
+  
+  $hook_origins = hex_get_theme_hook_origins();
+  
+  // Register hooks based on variable process functions and .vars.inc files.
+  // All user defined functions.
+  list(, $user_func) = array_values(get_defined_functions());
+
+  // All known base hooks. Discovered functions must be based on these.
+  $hooks = implode('|', array_keys($hook_origins));
+
+  // Find new hook suggestions derived from variable processor names.
+  // Create a new entry by inheriting all the data from the closest parent hook.
+  foreach (hex_list('theme') + hex_list('plugin') as $prefix) {
+    foreach (preg_grep("/^{$prefix}_(pre)?process_($hooks)__/", $user_func) as $processor) {
+      $hook = substr($processor, strpos($processor, 'process_') + strlen('process_'));
+      if ($parent_hook = hex_find_parent_hook($registry, $hook, TRUE)) {
+        // Uses the immediate parent hook. Not necessarily the base hook.
+        $registry[$hook] = $registry[$parent_hook];
+        // Remove variable processors. They are handled separately.
+        foreach (array('preprocess functions', 'process functions') as $phase_process) {
+          if (isset($registry[$hook][$phase_process])) {
+            unset($registry[$hook][$phase_process]);
+          }
+        }
+        // Add the variable processor.
+        $phase = strpos($processor, 'preprocess') ? 'preprocess functions' : 'process functions';
+        $registry[$hook][$phase][] = $processor;
+      }
+    }
+  }
+
+  // Find hooks derived from vars.inc files. Same idea as above.
+  foreach (hex_get_theme_registry_files() as $file) {
+    if ($file->type === 'vars') {
+      $hook = str_replace('-', '_', $file->basename);
+      if (!isset($registry[$hook]) && $parent_hook = hex_find_parent_hook($registry, $hook, TRUE)) {
+        $registry[$hook] = $registry[$parent_hook];
+        // Remove variable processors. They are handled separately.
+        foreach (array('preprocess functions', 'process functions') as $phase_process) {
+          if (isset($registry[$hook][$phase_process])) {
+            unset($registry[$hook][$phase_process]);
+          }
+        }
+      }
+    }
+  }
+}
+
+/**
  * Scans for files needed for the theme registry.
  */
 function hex_get_theme_registry_files() {
@@ -247,11 +384,7 @@ function hex_get_theme_registry_files() {
     // Start by creating a filter so only valid files are returned.
     $hooks = $origins = array();
     foreach (hex_get_theme_hook_origins() as $hook => $origin) {
-      // Gather hooks ignoring patterns.
-      if (!strpos($hook, '__')) {
-        $hooks[] = $hook;
-      }
-      // Gather hook origin.
+      $hooks[] = $hook;
       if (!in_array($origin, $origins)) {
         $origins[] = $origin;
       }
@@ -281,9 +414,9 @@ function hex_get_theme_registry_files() {
 }
 
 /**
- * Returns all theming hooks and their sources.
+ * Returns all theming hooks and their origins.
  */
-function hex_get_theme_hook_sources() {
+function hex_get_theme_hook_origins() {
   $cache = &drupal_static(__FUNCTION__, NULL);
 
   if (!isset($cache)) {
@@ -296,16 +429,16 @@ function hex_get_theme_hook_sources() {
     $theme_hooks = array();
     foreach (array('module' => hex_list('module'),
                    'theme'  => hex_list('theme'),
-                   'plugin' => hex_list('plugin')) as $type => $sources) {
+                   'plugin' => hex_list('plugin')) as $type => $origins) {
 
-      foreach ($sources as $source_key) {
-        $hook_theme = $source_key . '_theme';
+      foreach ($origins as $origin_key) {
+        $hook_theme = $origin_key . '_theme';
         if (function_exists($hook_theme)) {
-          $result = $hook_theme($theme_hooks, $type, $source_key, hex_path($type, $source_key));
+          $result = $hook_theme($theme_hooks, $type, $origin_key, hex_path($type, $origin_key));
           foreach (array_keys($result) as $hook) {
-            // Maintain first source.
+            // Maintain first origin.
             if (!isset($cache[$hook])) {
-              $cache[$hook] = $source_key;
+              $cache[$hook] = $origin_key;
             }
           }
           $theme_hooks += $result;
@@ -316,3 +449,34 @@ function hex_get_theme_hook_sources() {
 
   return $cache;
 }
+
+/**
+ * Looks for the parent hook when given a hook based on a pattern.
+ * 
+ * @param $hooks
+ *  The set of hooks to check against. Either a set of base hooks or the
+ *  complete registry. Only the keys are used.
+ * @param $hook_pattern
+ *  The hook pattern being processed.
+ * @param $force_fallback
+ *  If set to TRUE, $hook_pattern will not be checked against $hooks before
+ *  attempting to find a parent hook. It is important to set this to FALSE
+ *  when checking for the base hook since hook patterns defined from
+ *  hook_theme() does not need a fallback.
+ */
+function hex_find_parent_hook($hooks, $hook_pattern, $force_fallback) {
+  $hook = $hook_pattern;
+
+  if (!$force_fallback && isset($hooks[$hook])) {
+    return FALSE;
+  }
+
+  while ($pos = strrpos($hook, '__')) {
+    $hook = substr($hook, 0, $pos);
+    if (isset($hooks[$hook])) {
+      break;
+    }
+  }
+
+  return $hook !== $hook_pattern ? $hook : FALSE;
+}
diff --git HexagonBase/includes/include_vars.inc HexagonBase/includes/include_vars.inc
deleted file mode 100644
index 33ecf5d..0000000
--- HexagonBase/includes/include_vars.inc
+++ /dev/null
@@ -1,63 +0,0 @@
-<?php
-
-/**
- * @file include_vars.inc
- * Does the work of including hook.vars.inc files.
- *
- * When any of the following files are detected for a specific hook, this file
- * will be included in the theme registry:
- *
- * - [ HOOK ].vars.inc
- * - [ HOOK ].[ ACTIVE-THEME ].vars.inc
- * - [ HOOK ].[ func | tpl ].vars.inc
- * - [ HOOK ].[ ACTIVE-THEME ].[ func | tpl ].vars.inc
- * - [ HOOK--PATTERN ].vars.inc
- * - [ HOOK--PATTERN ].[ ACTIVE-THEME ].vars.inc
- * - [ HOOK--PATTERN ].[ func | tpl ].vars.inc
- * - [ HOOK--PATTERN ].[ ACTIVE-THEME ].[ func | tpl ].vars.inc
- */
-
-/**
- * A custom variable process function with the sole purpose of including
- * hook.vars.inc and/or hook--suggestion.vars.inc files.
- */
-function hex_variable_include_process(&$variables, $hook) {
-
-  // Checking suggestions to work around a core limitation of preventing
-  // preprocess functions *specific to a suggestion* from being processed,
-  // e.g. mytheme_preprocess_hook__suggestion(). Although this does not
-  // allow the functions itself, hook--suggestion.vars.inc files will be
-  // loaded and processed in addition to a base hook.vars.inc when available.
-
-  $suggestions = array();
-  if (!empty($variables['theme_hook_suggestions'])) {
-    $suggestions = $variables['theme_hook_suggestions'];
-  }
-  if (!empty($variables['theme_hook_suggestion'])) {
-    $suggestions[] = $variables['theme_hook_suggestion'];
-  }
-  if (!empty($suggestions)) {
-    foreach (array_reverse($suggestions) as $suggestion) {
-      // hex_theme_hook_info() has access to all the hooks.
-      // Used here to check for its existence.
-      if (hex_theme_hook_info($suggestion)) {
-        $hook = $suggestion;
-        break;
-      }
-    }
-  }
-  foreach (hex_theme_hook_info($hook)->variable_includes as $variable_include) {
-    _hex_var_include($variables, $hook, $variable_include);
-  }
-}
-
-/**
- * Includes the hook.vars.inc file and extracts the variables.
- */
-function _hex_var_include(&$variables, $hook, $variable_include) {
-  // Allow both common spellings.
-  $vars = &$variables;
-  // Extract the variables to a local namespace. This is not expensive.
-  extract($variables, EXTR_REFS + EXTR_SKIP);
-  include DRUPAL_ROOT . '/' . $variable_include;
-}
diff --git HexagonBase/includes/meta_theme.inc HexagonBase/includes/meta_theme.inc
index ebe9167..d24d924 100644
--- HexagonBase/includes/meta_theme.inc
+++ HexagonBase/includes/meta_theme.inc
@@ -107,16 +107,27 @@ function hex_theme_info($info_key, $default = NULL, $theme = HEX_ACTIVE) {
 }
 
 /**
- * Returns information about a theming hook.
+ * Returns meta information for a given theme hook.
+ * 
+ * @param $hook
+ *  The hook to target.
+ * @param $info
+ *  Optional sub-key for the hook. If not set, it will return all the meta
+ *  info available.
  */
-function hex_theme_hook_info($hook) {
+function hex_theme_hook_info($hook, $info = NULL) {
   static $hooks;
 
   if (!isset($hooks)) {
     $hooks = theme_get_registry();
   }
 
-  return isset($hooks[$hook]['hex_info']) ? $hooks[$hook]['hex_info'] : NULL;
+  if ($info) {
+    return isset($hooks[$hook][$info]) ? $hooks[$hook][$info] : NULL;
+  }
+  else {
+    return isset($hooks[$hook]) ? $hooks[$hook] : NULL;
+  }
 }
 
 /**
diff --git HexagonBase/includes/vars_processors.inc HexagonBase/includes/vars_processors.inc
new file mode 100644
index 0000000..d2acef4
--- /dev/null
+++ HexagonBase/includes/vars_processors.inc
@@ -0,0 +1,201 @@
+<?php
+
+// Used to flag processed suggestions.
+define('HEX_SUGGESTION_PROCESSED', 100);
+
+/**
+ * When any of the following files are detected for a specific hook, they will
+ * be included and processed:
+ *
+ * - [ HOOK ].vars.inc
+ * - [ HOOK ].[ ACTIVE-THEME ].vars.inc
+ * - [ HOOK ].[ func | tpl ].vars.inc
+ * - [ HOOK ].[ ACTIVE-THEME ].[ func | tpl ].vars.inc
+ * - [ HOOK--PATTERN ].vars.inc
+ * - [ HOOK--PATTERN ].[ ACTIVE-THEME ].vars.inc
+ * - [ HOOK--PATTERN ].[ func | tpl ].vars.inc
+ * - [ HOOK--PATTERN ].[ ACTIVE-THEME ].[ func | tpl ].vars.inc
+ */
+function hex_variable_include_process(&$variables, $hook) {
+  $hook_target = $hook;
+  // Check for hook suggestion.
+  if ($suggestion = hex_find_theme_hook_suggestion($variables)) {
+    $hook_target = $suggestion;
+  }
+
+  if ($variable_includes = hex_theme_hook_info($hook_target, 'vars includes')) {
+    // Allow both common spellings.
+    $vars = &$variables;
+    // Extract the variables to a local namespace. This is not expensive.
+    extract($variables, EXTR_REFS + EXTR_SKIP);
+    // Include files.
+    foreach ($variable_includes as $variable_include) {
+      include DRUPAL_ROOT . '/' . $variable_include;
+    }
+  }
+}
+
+/**
+ * This is only used for base hooks and a suggestion is made by other variable
+ * processors. Setting a suggestion prevents the processors connected to the
+ * suggestion from running. This effectively fills the gap by allowing the
+ * processors specific to the suggestion to run.
+ *
+ * @see hex_suggestion_processors()
+ */
+
+function hex_variable_preprocess_suggestion(&$variables, $hook) {
+  static $processors;
+
+  if ($suggestion = hex_find_theme_hook_suggestion($variables)) {
+    if (!isset($processors[$suggestion])) {
+      $processors[$suggestion] = hex_suggestion_processors($hook, $suggestion, 'preprocess');
+    }
+    foreach ($processors[$suggestion] as $processor) {
+      $processor($variables, $suggestion);
+    }
+  }
+}
+
+/**
+ * This is only used for base hooks and a suggestion is made by other variable
+ * processors. Setting a suggestion prevents the processors connected to the
+ * suggestion from running. This effectively fills the gap by allowing the
+ * processors specific to the suggestion to run.
+ *
+ * @see hex_suggestion_processors()
+ */
+function hex_variable_process_suggestion(&$variables, $hook) {
+  static $processors;
+
+  if ($suggestion = hex_find_theme_hook_suggestion($variables)) {
+    if (!isset($processors[$suggestion])) {
+      $processors[$suggestion] = hex_suggestion_processors($hook, $suggestion, 'process');
+    }
+    foreach ($processors[$suggestion] as $processor) {
+      $processor($variables, $suggestion);
+    }
+  }
+}
+
+/**
+ * When variable processors for a hook suggestion is detected, it will return
+ * the remaining processor functions. The caller will fill in the gaps
+ * effectively running the full set of processors.
+ *
+ * @see hex_variable_preprocess_suggestion()
+ * @see hex_variable_process_suggestion()
+ */
+function hex_suggestion_processors($hook, $suggestion, $phase) {
+  $processor_list = array();
+
+  if ($hook !== $suggestion) {
+    foreach ((array) hex_theme_hook_info($suggestion, "{$phase} functions") as $processor) {
+      if ($processor !== "hex_variable_{$phase}_base" && function_exists($processor)) {
+        $processor_list[] = $processor;
+      }
+    }
+  }
+
+  return $processor_list;
+}
+
+/**
+ * This is only used for pattern based hooks or "hook suggestions" since they
+ * do not carry a full set of variable processor functions.
+ *
+ * @see hex_base_processors()
+ */
+function hex_variable_preprocess_base(&$variables, $hook) {
+  static $processors;
+
+  if (!isset($processors[$hook])) {
+    $processors[$hook] = hex_base_processors($hook, 'preprocess');
+  }
+  foreach ($processors[$hook] as $processor) {
+    $processor($variables, $hook);
+  }
+}
+
+/**
+ * This is only used for pattern based hooks or "hook suggestions" since they
+ * do not carry a full set of variable processor functions.
+ *
+ * @see hex_base_processors()
+ */
+function hex_variable_process_base(&$variables, $hook) {
+  static $processors;
+
+  if (!isset($processors[$hook])) {
+    $processors[$hook] = hex_base_processors($hook, 'process');
+  }
+  foreach ($processors[$hook] as $processor) {
+    $processor($variables, $hook);
+  }
+}
+
+/**
+ * When the variable processors for the base hook is detected, it will return
+ * the difference between the base and the suggestion. The caller will fill in
+ * the gaps effectively running the full set of processors.
+ *
+ * @see hex_variable_preprocess_base()
+ * @see hex_variable_process_base()
+ */
+function hex_base_processors($hook, $phase) {
+  $processor_list = array();
+  $base = hex_theme_hook_info($hook, 'base');
+
+  if (hex_theme_hook_info($hook, "{$phase} base diff")
+  &&  $processors = hex_theme_hook_info($base, "{$phase} functions")) {
+
+    foreach (hex_theme_hook_info($hook, "{$phase} base diff") as $i) {
+      if (function_exists($processors[$i])) {
+        $processor_list[] = $processors[$i];
+      }
+    }
+  }
+
+  return $processor_list;
+}
+
+/**
+ * Finds a theming hook from suggestions set from variable processors.
+ * 
+ * This will strip 'theme_hook_suggestion' of any suggestions that are not
+ * registered in the theme registry. Two new variables will be introduced,
+ * 'available_suggestions' and 'unavailable_suggestions'. The latter is useful
+ * for getting context on what suggestions are available that never caught on.
+ */
+function hex_find_theme_hook_suggestion(&$variables) {
+  $suggestions = array();
+  if (!empty($variables['theme_hook_suggestions'])) {
+    $suggestions = &$variables['theme_hook_suggestions'];
+  }
+  if (!empty($variables['theme_hook_suggestion'])) {
+    $suggestions[] = $variables['theme_hook_suggestion'];
+    unset($variables['theme_hook_suggestion']);
+  }
+  if (!isset($variables['available_suggestions'])) {
+    $variables['available_suggestions'] = array();
+  }
+  if (!isset($variables['unavailable_suggestions'])) {
+    $variables['unavailable_suggestions'] = array();
+  }
+  foreach (array_reverse($suggestions, TRUE) as $i => $suggestion) {
+    if ($i >= HEX_SUGGESTION_PROCESSED) {
+      continue;
+    }
+    unset($suggestions[$i]);
+
+    if (hex_theme_hook_info($suggestion)) {
+      $suggestions[HEX_SUGGESTION_PROCESSED + $i] = $suggestion;
+      $variables['available_suggestions'][$i] = $suggestion;
+    }
+    else {
+      $variables['unavailable_suggestions'][$i] = $suggestion;
+    }
+  }
+  // Return first item.
+  return reset($variables['available_suggestions']);
+}