diff --git a/Source/CursesDialog/cmCursesCacheEntryComposite.cxx b/Source/CursesDialog/cmCursesCacheEntryComposite.cxx
index 249137f..06b3543 100644
--- a/Source/CursesDialog/cmCursesCacheEntryComposite.cxx
+++ b/Source/CursesDialog/cmCursesCacheEntryComposite.cxx
@@ -100,6 +100,8 @@ cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
       break;
     }
 
+    // TODO: Keep this up to date and allow unset / revert to default.
+    this->Entry->setBold(it.NonDefault());
 }
 
 cmCursesCacheEntryComposite::~cmCursesCacheEntryComposite()
diff --git a/Source/CursesDialog/cmCursesMainForm.cxx b/Source/CursesDialog/cmCursesMainForm.cxx
index 4fee0bb..cee3899 100644
--- a/Source/CursesDialog/cmCursesMainForm.cxx
+++ b/Source/CursesDialog/cmCursesMainForm.cxx
@@ -507,7 +507,7 @@ void cmCursesMainForm::UpdateStatusBar(const char* message)
       this->CMakeInstance->GetCacheManager()->GetCacheIterator(curField);
     if (!it.IsAtEnd())
       {
-      const char* hs = it.GetProperty("HELPSTRING");
+      const char* hs = it.GetProperty("DEFAULT"); //HELPSTRING
       if ( hs )
         {
         strncpy(help, hs, 127);
diff --git a/Source/CursesDialog/cmCursesStringWidget.h b/Source/CursesDialog/cmCursesStringWidget.h
index e939049..9992022 100644
--- a/Source/CursesDialog/cmCursesStringWidget.h
+++ b/Source/CursesDialog/cmCursesStringWidget.h
@@ -48,6 +48,8 @@ public:
   void SetInEdit(bool inedit) { this->InEdit = inedit; }
   bool GetInEdit() { return this->InEdit; }
 
+  void setBold(bool value) { set_field_fore(this->Field, value ? A_BOLD : A_NORMAL); }
+
   /**
    * This method is called when different keys are pressed. The
    * subclass can have a special implementation handler for this.
diff --git a/Source/CursesDialog/cmCursesWidget.h b/Source/CursesDialog/cmCursesWidget.h
index 952c67a..9078794 100644
--- a/Source/CursesDialog/cmCursesWidget.h
+++ b/Source/CursesDialog/cmCursesWidget.h
@@ -43,6 +43,8 @@ public:
   virtual void SetValue(const char* value);
   virtual const char* GetValue();
 
+  void setBold(bool value) { set_field_fore(this->Field, value ? A_BOLD : A_NORMAL); }
+
   /**
    * Get the type of the widget (STRING, PATH etc...)
    */
diff --git a/Source/cmCacheManager.cxx b/Source/cmCacheManager.cxx
index a2baa80..d5e9def 100644
--- a/Source/cmCacheManager.cxx
+++ b/Source/cmCacheManager.cxx
@@ -137,6 +137,9 @@ bool cmCacheManager::ParseEntry(const char* entry,
                                 std::string& value,
                                 CacheEntryType& type)
 {
+  // TODO: Handle CACHE defaults properly.
+  //if (entry[0] == '#')
+  //  entry++;
   // input line is:         key:type=value
   static cmsys::RegularExpression reg(
     "^([^:]*):([^=]*)=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$");
@@ -158,7 +161,6 @@ bool cmCacheManager::ParseEntry(const char* entry,
     value = reg.match(3);
     flag = true;
     }
-
   // if value is enclosed in single quotes ('foo') then remove them
   // it is used to enclose trailing space or tab
   if (flag &&
@@ -224,6 +226,9 @@ bool cmCacheManager::LoadCache(const char* path,
     // Format is key:type=value
     std::string helpString;
     CacheEntry e;
+
+AGAIN:
+
     e.Properties.SetCMakeInstance(this->CMakeInstance);
     cmSystemTools::GetLineFromStream(fin, buffer);
     realbuffer = buffer.c_str();
@@ -259,7 +264,20 @@ bool cmCacheManager::LoadCache(const char* path,
         }
       }
     e.SetProperty("HELPSTRING", helpString.c_str());
-    if(cmCacheManager::ParseEntry(realbuffer, entryKey, e.Value, e.Type))
+
+    // TODO: Handle CACHE defaults properly.
+    // FIXME: CMakeCache.txt not stable between 1st and 2nd run.
+    bool isComment = false;
+
+    if (*realbuffer == '#') {
+      realbuffer++;
+      isComment = true;
+    } else {
+      isComment = false;
+    }
+
+    std::string parsedValue;
+    if(cmCacheManager::ParseEntry(realbuffer, entryKey, parsedValue, e.Type))
       {
       if ( excludes.find(entryKey) == excludes.end() )
         {
@@ -284,9 +302,23 @@ bool cmCacheManager::LoadCache(const char* path,
             helpString += "/CMakeCache.txt"   ;
             e.SetProperty("HELPSTRING", helpString.c_str());
             }
+
+          if(isComment)
+            {
+            // FIXME: This won't insert the entry unless the variable is user-defined!
+            e.SetProperty("DEFAULT", parsedValue.c_str());
+            e.Value = parsedValue;
+            e.Initialized = 2;
+            }
+          else
+            {
+            e.Value = parsedValue;
+            e.Initialized = 1;
+            }
+
+          //if (!isComment)
           if(!this->ReadPropertyEntry(entryKey, e))
             {
-            e.Initialized = true;
             this->Cache[entryKey] = e;
             }
           }
@@ -297,7 +329,11 @@ bool cmCacheManager::LoadCache(const char* path,
       cmSystemTools::Error("Parse error in cache file ", cacheFile.c_str(),
                            ". Offending entry: ", realbuffer);
       }
+
+      if (isComment)
+        goto AGAIN;
     }
+
   this->CacheMajorVersion = 0;
   this->CacheMinorVersion = 0;
   if(const char* cmajor = this->GetCacheValue("CMAKE_CACHE_MAJOR_VERSION"))
@@ -357,6 +393,8 @@ const char* cmCacheManager::PersistentProperties[] =
   "ADVANCED",
   "MODIFIED",
   "STRINGS",
+  // TODO: Bettor to custom-handle this like HELPSTRING?
+  //"DEFAULT",
   0
 };
 
@@ -505,8 +543,11 @@ bool cmCacheManager::SaveCache(const char* path)
     {
     const CacheEntry& ce = (*i).second;
     CacheEntryType t = ce.Type;
-    if(!ce.Initialized)
+    if(!ce.Initialized && !ce.GetProperty("DEFAULT"))
       {
+        // It may still have a default.
+        // FIXME: What to do here?
+        //continue;
       /*
         // This should be added in, but is not for now.
       cmSystemTools::Error("Cache entry \"", (*i).first.c_str(),
@@ -524,11 +565,27 @@ bool cmCacheManager::SaveCache(const char* path)
         {
         cmCacheManager::OutputHelpString(fout, "Missing description");
         }
-      this->OutputKey(fout, i->first);
-      fout << ":" << cmCacheManagerTypes[t] << "=";
-      this->OutputValue(fout, ce.Value);
-      fout << "\n\n";
+
+      if(const char* defaultValue = ce.GetProperty("DEFAULT"))
+        {
+        fout << "#";
+        this->OutputKey(fout, i->first);
+        fout << ":" << cmCacheManagerTypes[t] << "=";
+        this->OutputValue(fout, defaultValue);
+        fout << "\n";
+        }
+
+      if(ce.Initialized == 1)
+        {
+        this->OutputKey(fout, i->first);
+        fout << ":" << cmCacheManagerTypes[t] << "=";
+        this->OutputValue(fout, ce.Value);
+        fout << "\n";
+        }
+
+      fout << "\n";
       }
+
     }
 
   fout << "\n";
@@ -711,18 +768,30 @@ void cmCacheManager::PrintCache(std::ostream& out) const
 void cmCacheManager::AddCacheEntry(const char* key,
                                    const char* value,
                                    const char* helpString,
-                                   CacheEntryType type)
+                                   CacheEntryType type,
+                                   const char* defaultValue)
 {
+  // TODO: Improve this check
+  bool isDefaultValue = defaultValue && (value == defaultValue);
+
   CacheEntry& e = this->Cache[key];
   e.Properties.SetCMakeInstance(this->CMakeInstance);
+
+  if (defaultValue)
+    {
+    e.SetProperty("DEFAULT", defaultValue);
+    }
+
   if ( value )
     {
     e.Value = value;
-    e.Initialized = true;
+    // FIXME XXX: Make Initialized optional?
+    e.Initialized = isDefaultValue ? 2 : 1;
     }
   else
     {
     e.Value = "";
+    // TODO: Store the default value still in this case, like above.
     }
   e.Type = type;
   // make sure we only use unix style paths
diff --git a/Source/cmCacheManager.h b/Source/cmCacheManager.h
index 4b8c07d..b9a6884 100644
--- a/Source/cmCacheManager.h
+++ b/Source/cmCacheManager.h
@@ -43,8 +43,8 @@ private:
     void SetProperty(const char* property, const char* value);
     void AppendProperty(const char* property, const char* value,
                         bool asString=false);
-    bool Initialized;
-    CacheEntry() : Value(""), Type(UNINITIALIZED), Initialized(false)
+    int Initialized;
+    CacheEntry() : Value(""), Type(UNINITIALIZED), Initialized(0)
       {}
   };
 
@@ -71,6 +71,8 @@ public:
     CacheEntryType GetType() const { return this->GetEntry().Type; }
     void SetType(CacheEntryType ty) { this->GetEntry().Type = ty; }
     bool Initialized() { return this->GetEntry().Initialized; }
+    // TODO: Return Initialized false in this case instead?
+    bool NonDefault() const { return this->GetEntry().Initialized == 1; }
     cmCacheManager &Container;
     std::map<cmStdString, CacheEntry>::iterator Position;
     CacheIterator(cmCacheManager &cm) : Container(cm) {
@@ -152,7 +154,8 @@ public:
 protected:
   ///! Add an entry into the cache
   void AddCacheEntry(const char* key, const char* value,
-                     const char* helpString, CacheEntryType type);
+                     const char* helpString, CacheEntryType type,
+                     const char* defaultValue = 0);
 
   ///! Get a cache entry object for a key
   CacheEntry *GetCacheEntry(const char *key);
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index c18a7eb..da3f58a 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -1765,12 +1765,12 @@ void cmMakefile::AddDefinition(const char* name, const char* value)
 }
 
 
-void cmMakefile::AddCacheDefinition(const char* name, const char* value,
+void cmMakefile::AddCacheDefinition(const char* name, const char* defaultValue,
                                     const char* doc,
                                     cmCacheManager::CacheEntryType type,
                                     bool force)
 {
-  const char* val = value;
+  const char* val = defaultValue;
   cmCacheManager::CacheIterator it =
     this->GetCacheManager()->GetCacheIterator(name);
   if(!it.IsAtEnd() && (it.GetType() == cmCacheManager::UNINITIALIZED) &&
@@ -1806,7 +1806,8 @@ void cmMakefile::AddCacheDefinition(const char* name, const char* value,
       }
 
     }
-  this->GetCacheManager()->AddCacheEntry(name, val, doc, type);
+    // XXX
+  this->GetCacheManager()->AddCacheEntry(name, val, doc, type, defaultValue);
   // if there was a definition then remove it
   this->Internal->VarStack.top().Set(name, 0);
 }
diff --git a/Source/cmSetCommand.cxx b/Source/cmSetCommand.cxx
index 20f38be..0c0fc46 100644
--- a/Source/cmSetCommand.cxx
+++ b/Source/cmSetCommand.cxx
@@ -147,7 +147,7 @@ bool cmSetCommand
   // see if this is already in the cache
   cmCacheManager::CacheIterator it =
     this->Makefile->GetCacheManager()->GetCacheIterator(variable);
-  if(!it.IsAtEnd() && (it.GetType() != cmCacheManager::UNINITIALIZED))
+  if(!it.IsAtEnd() && (it.GetType() != cmCacheManager::UNINITIALIZED) && it.NonDefault())
     {
     // if the set is trying to CACHE the value but the value
     // is already in the cache and the type is not internal
@@ -162,6 +162,7 @@ bool cmSetCommand
   // if it is meant to be in the cache then define it in the cache
   if(cache)
     {
+      // XXX
     this->Makefile->AddCacheDefinition(variable,
                                    value.c_str(),
                                    docstring,
diff --git a/Source/cmake.cxx b/Source/cmake.cxx
index f786691..8e57bf1 100644
--- a/Source/cmake.cxx
+++ b/Source/cmake.cxx
@@ -339,6 +339,7 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
         const char *cachedValue =
                               this->CacheManager->GetCacheValue(var.c_str());
 
+        // XXX
         this->CacheManager->AddCacheEntry(var.c_str(), value.c_str(),
           "No help, variable specified on the command line.", type);
         if(this->WarnUnusedCli)