docs: function(userConf, template, callback) {
  
          var content = userConf,
          //if nothing to merge.
              newContent = JSON.parse( JSON.stringify(content) );
  
          var isStandalone = true,
              env = self.Env.get(),
              appsPath = "",
              modelsPath = "";
  
  
          //Pushing default app first.
          self.bundles.push(self.startingApp);//This is a JSON.push.
          var root = new _(self.executionPath).toUnixStyle();
          try {
              var pkg = require(_(root + '/project.json')).bundles;
          } catch (err) {
              callback(err);
          } //bundlesPath will be default.
  
  
          //For each app.
          for (var app in content) {
              //Checking if genuine app.
              console.debug('Checking if application [ '+ app +' ]is registered ');
  
              if ( typeof(content[app][env]) != "undefined" ) {
  
                  if (
                      pkg[app] != 'undefined' && pkg[app]['src'] != 'undefined' && env == 'dev'
                      || pkg[app] != 'undefined' && pkg[app]['src'] != 'undefined' && env == 'debug'
                  ) {
                      var p = _(pkg[app].src);
                      content[app][env]['bundlesPath'] = "{executionPath}/"+ p.replace('/' + app, '');
                  } else {
                      var p = ( typeof(pkg[app].release.link) != 'undefined' ) ? _(pkg[app].release.link) : _(pkg[app].release.target);
                      content[app][env]['bundlesPath'] = "{executionPath}/"+ p.replace('/' + app, '');
                  }
  
                  appsPath = (typeof(content[app][env]['bundlesPath']) != "undefined")
                      ? content[app][env].bundlesPath
                      : template["{bundle}"]["{env}"].bundlesPath;
  
  
  
                  modelsPath = (typeof(content[app][env]['modelsPath']) != "undefined")
                      ?  content[app][env].modelsPath
                      :  template["{bundle}"]["{env}"].modelsPath;
  
                  //I had to for this one...
                  appsPath = appsPath.replace(/\{executionPath\}/g, root);
                  //modelsPath = modelsPath.replace(/\{executionPath\}/g, mPath);
  
                  //console.log("My env ", env, self.executionPath, JSON.stringify(template, null, '\t') );
                  //Existing app and port sharing => != standalone.
                  if ( !fs.existsSync(appsPath) ) {
                      new _(appsPath).mkdirSync()
                  }
                  var masterPort = content[self.startingApp][env].port.http;
                  //Check if standalone or shared instance
                  if (content[app][env].port.http != masterPort) {
                      isStandalone = false;
                      self.Host.standaloneMode = isStandalone
                  } else if (app != self.startingApp) {
                      self.bundles.push(app)
                  }
                  self.allBundles.push(app);
  
                  //Mergin user's & template.
                  newContent[app][env] = merge(
                      newContent[app][env],
                      JSON.parse( JSON.stringify(template["{bundle}"]["{env}"]))//only copy of it.
                  );
  
  
                  //Variables replace. Compare with gina/core/template/conf/env.json.
                  var version = undefined, middleware = undefined;
                  try {
                      self.version    = version = require(_(getPath('gina').root +'/package.json' )).version;
                      self.middleware = middleware = fs.readFileSync(_(getPath('gina').root + '/MIDDLEWARE')).toString() || 'none';
  
                      setContext('gina.version', version);
                      setContext('gina.middleware', middleware);
  
                  } catch (err) {
                      console.debug(err.stack)
                  }
  
                  var reps = {
                      "executionPath" : root,
                      "bundlesPath" : appsPath,
                      "modelsPath" : modelsPath,
                      "env" : env,
                      "bundle" : app,
                      "version": version
                  };
  
  
                  //console.error("reps ", reps);
                  newContent = whisper(reps, newContent);
  
  
              }
              //Else not in the scenario.
  
          }//EO for.
  
  
          console.debug('Env configuration loaded \n');
  
          // TRUE means that all apps sharing the same process will merge into one.
          if (!isStandalone) self.Host.standaloneMode = isStandalone;
  
          console.debug('Is server running as a standalone instance ? ' + isStandalone);
  
          callback(false, newContent)
      }