diff --git a/includes/cache-install.inc b/includes/cache-install.inc
index d9bb0f9..d8e19b9 100644
--- a/includes/cache-install.inc
+++ b/includes/cache-install.inc
@@ -14,7 +14,7 @@
  * any persistent storage. Obviously, using this cache implementation during
  * normal operations would have a negative impact on performance.
  */
-class DrupalFakeCache extends DrupalDatabaseCache implements DrupalCacheInterface {
+class DrupalInstallCache extends DrupalDatabaseCache implements DrupalCacheInterface {
   function get($cid) {
     return FALSE;
   }
diff --git a/includes/cache.inc b/includes/cache.inc
index 8666874..72e769a 100644
--- a/includes/cache.inc
+++ b/includes/cache.inc
@@ -17,13 +17,38 @@
 function _cache_get_object($bin) {
   // We do not use drupal_static() here because we do not want to change the
   // storage of a cache bin mid-request.
-  static $cache_objects;
+  static $cache_objects, $default_class;
+
+  if (!isset($default_class)) {
+    $default_class = variable_get('cache_default_class', 'DrupalDatabaseCache');
+    // User provided default could be broken.
+    // FIXME: Forcing the system not to use the autoloader, with PHP 5.3
+    // class_exists() seems to fail when using it.
+    if (!class_exists($default_class, FALSE)) {
+      $default_class = 'DrupalDatabaseCache';
+    }
+  }
+
   if (!isset($cache_objects[$bin])) {
+    // Fetch the specialized instance.
     $class = variable_get('cache_class_' . $bin);
-    if (!isset($class)) {
-      $class = variable_get('cache_default_class', 'DrupalDatabaseCache');
+    if (!isset($class) || !class_exists($class, FALSE)) {
+      $class = $default_class;
     }
-    $cache_objects[$bin] = new $class($bin);
+    $instance = new $class($bin);
+
+    // Backend sanity runtime check.
+    if ($instance instanceof DrupalCriticalBackendInterface && !$instance->isHealthy()) {
+      if ($class === $default_class) {
+        // This implies that misconfigured sites will suffer from performance
+        // problems. This is probably good enough for downgraded critical
+        // situations.
+        $default_class = 'DrupalFakeCache';
+      }
+      $instance = new $default_class($bin);
+    }
+
+    $cache_objects[$bin] = $instance;
   }
   return $cache_objects[$bin];
 }
@@ -302,12 +327,75 @@ interface DrupalCacheInterface {
 }
 
 /**
+ * Neutral cache backend implementation.
+ * 
+ * This implements the Null Object pattern, it allows sites to fully disable
+ * one or more cache bin using this instance instead of a working one.
+ * 
+ * This is also the last resort implementation if no other backend can work
+ * on the underlaying environment.
+ */
+class DrupalFakeCache implements DrupalCacheInterface {
+  function __construct($bin) {}
+
+  function get($cid) {
+    return FALSE;
+  }
+
+  function getMultiple(&$cids) {
+    return array();
+  }
+
+  function set($cid, $data, $expire = CACHE_PERMANENT) {}
+
+  function clear($cid = NULL, $wildcard = FALSE) {}
+
+  function isEmpty() {
+    return TRUE;
+  }
+}
+
+/**
+ * Defines an strongly environment related plugin.
+ * 
+ * Every plugin that relies on optional external, system, PHP library should
+ * implement this interface in order for core to be able to proceed to runtime
+ * graceful downgrade if the environment does meet the required dependencies
+ * for the plugin to run.
+ * 
+ * @see DrupalDatabaseCache
+ *   For a functional plugin example.
+ * @see _cache_get_object
+ *   For a sample usage by core.
+ */
+interface DrupalCriticalBackendInterface {
+  /**
+   * Check if environment is ready to run this plugin or backend.
+   * 
+   * For cache backends, this method implementation should probably use static
+   * shared cache among all instances so that costy environment checks wouldn't
+   * be done more than once.
+   * 
+   * This is the right place to test if system libraries are present, e.g. for
+   * memcache backend, this is the right place to check if the PEAR memcache or
+   * memcached library are here by doing extension_loaded() or function_exists()
+   * calls.
+   * 
+   * Avoid any remote service calls here, except if you don't have any other
+   * solution.
+   * 
+   * @return bool
+   */
+  public function isHealthy();
+}
+
+/**
  * Default cache implementation.
  *
  * This is Drupal's default cache implementation. It uses the database to store
  * cached data. Each cache bin corresponds to a database table by the same name.
  */
-class DrupalDatabaseCache implements DrupalCacheInterface {
+class DrupalDatabaseCache implements DrupalCacheInterface, DrupalCriticalBackendInterface {
   protected $bin;
 
   function __construct($bin) {
@@ -505,4 +593,16 @@ class DrupalDatabaseCache implements DrupalCacheInterface {
       ->fetchField();
     return empty($result);
   }
+
+  /**
+   * Basically, this backend must be able to run on every system. No database
+   * means the site is down.
+   * 
+   * This is a foo sample implementation of DrupalEnvRelatedPlugin::checkEnv().
+   * 
+   * @see DrupalEnvRelatedPlugin::checkEnv()
+   */
+  public function isHealthy() {
+    return TRUE;
+  }
 }
diff --git a/includes/install.core.inc b/includes/install.core.inc
index a74dfdf..73f02a0 100644
--- a/includes/install.core.inc
+++ b/includes/install.core.inc
@@ -272,7 +272,7 @@ function install_begin_request(&$install_state) {
   // suspect, due to the fact that Drupal is not fully set up yet.
   require_once DRUPAL_ROOT . '/includes/cache.inc';
   require_once DRUPAL_ROOT . '/includes/cache-install.inc';
-  $conf['cache_default_class'] = 'DrupalFakeCache';
+  $conf['cache_default_class'] = 'DrupalInstallCache';
 
   // Prepare for themed output. We need to run this at the beginning of the
   // page request to avoid a different theme accidentally getting set. (We also