docs: function boot() {
          // load dependencies
          cli = cli || define.cache.get(MODULE_ID_CLI, "minor").factory();
  
          var nw;
          var ui;
          try {
              // listen for OS open file event
              nw = require("nw");
              ui = require("nw.gui");
          }
          catch(e) {
              // ignore
          }
  
          // specify cli options
          if (nw) {
              cli.option("--ui", "Opens the selector in nw.js.");
          }
          else if (!host.isRuntimeBrowserFamily()) {
              cli.option("--ui", MSG_UI_UNAVAILABLE);
          }
          if (host.runtime == host.RUNTIME_NODEJS) {
              cli.option("--debug [port]", "Starts node.js in debug mode.");
          }
          else {
              cli.option("--debug [port]", MSG_DEBUG_UNAVAILABLE);
          }
          cli.option("--repo <url>", "Overrides the main repository for the active profile.");
          if (host.isRuntimeBrowserFamily()) {
              cli.option("--theme <url>", "Loads the specified css theme.");
          }
          cli.option("--config <json>", "A JSON object with parameters for the package module loaded.");
          cli.option("--profile <name>", "Overrides the active profile.");
          cli.option("--gh-username <username>", "Overrides the global configuration GitHub username key.");
          cli.option("--gh-password <password>", "Overrides the global configuration GitHub password key.");
          cli.option("--gh-token <token>", "Overrides the global configuration GitHub token key.");
          cli.option("--gh-branch <branch>", "Overrides the global configuration GitHub branch key.");
          cli.option("--gh-enable-pre-release <enable>", "Overrides the global configuration GitHub enable pre-release key.");
          cli.command("profile", "Performs configuration profile operations.")
              .command("list", "Lists all of the profiles available in the configuration.")
              .action(profileList);
          cli.command("profile")
              .command("add <name>", "Add a new profile.")
              .action(profileAdd);
          cli.command("profile")
              .command("copy <name>", "Creates a copy of the current profile with the given name.")
              .action(profileCopy);
          cli.command("profile")
              .command("remove <name>", "Removes the profile with the given name.")
              .action(profileRemove);
          cli.command("profile")
              .command("current", "Displays the name of the active profile.")
              .action(profileCurrent);
          cli.command("profile")
              .command("switch <name>", "Activates the profile with the given name.")
              .action(profileSwitch);
          cli.command("profile")
              .command("set <section> <key> <value>", "Sets the key value combination in the active profile.")
              .action(profileSet);
          cli.parameter("allume <selector>");
          var p = cli.parse(allume.parameters);
  
          //
          // start the loading process for the specified selector
          //
          function open(selector) {
              if (p["--debug"] && host.runtime == host.RUNTIME_NODEJS) {
                  return debug(p);
              }
              if (p["--ui"] && !ui) {
                  if (!nw) {
                      allume.update(allume.STATUS_ERROR, MSG_UI_UNAVAILABLE);
                      return;
                  }
  
                  // spawn nw.js process for allume with parameters
                  var findpath = nw.findpath;
                  childProcess = childProcess || require("child_process");
                  path = path || require("path");
  
                  var PATH_NW = findpath();
                  var PATH_APP = path.join(__dirname, "..");
                  var PATH_CWD = process.cwd();
                  var env = Object.create(process.env);
                  env.PWD = process.cwd();
  
                  process.argv.splice(1, 1);
                  process.argv[0] = PATH_APP;
                  for (var a in process.argv) {
                      process.argv[a] = process.argv[a].replace(/"/g, "\"");
                  }
  
                  var ls = childProcess.spawn(PATH_NW, process.argv, {"cwd": PATH_CWD, "env" : env});
  
                  ls.stdout.on("data", function(data) {
                      console.log(data.toString().trim());
                  });
  
                  ls.stderr.on("data", function(data) {
                      console.error(data.toString().trim());
                  });
  
                  return;
              }
  
              var requests = [];
              var request = selector;
              if (p["--config"]) {
                  var json;
                  try {
                      json = JSON.parse(p["--config"].json);
                  }
                  catch(e) {
                      var e = new Error("Make sure the data you pass to the --config switch is valid JSON data.");
                      e.name = "error-invalid-configuration";
                      if (typeof document !== "undefined" && firstOpen) {
                          allume.update(e);
                      }
                      else {
                          console.error(e);
                      }
                      firstOpen = false;
                      return;
                  }
                  request = { "package" : selector, "configuration" : json };
              }
              requests.push(request);
  
              if (requests) {
                  using.apply(using, requests).then(function () {
                      if (firstOpen) {
                          allume.hide();
                          firstOpen = false;
                      }
                  }, function (loader) {
                      usingFailed(loader);
                      var e = new Error(err);
                      e.name = errName;
                      if (typeof document !== "undefined" && firstOpen) {
                          allume.update(e);
                          firstOpen = false;
                      }
                      else {
                          console.error(e);
                      }
                  });
              }
          }
  
          if (p) {
              // attach config function to allume
              allume.config = config;
  
              // process commands and options
              if (p.repo) {
                  repo = p.repo;
              }
              if (p["--profile"]) {
                  allume.update(allume.STATUS_ERROR, MSG_MISSING_FEATURE);
                  profile = p.profile;
              }
              if (p["--theme"] && typeof document !== "undefined") {
                  var theme = document.createElement("link");
                  theme.rel = "stylesheet";
                  theme.href = p["--theme"].url;
                  document.head.appendChild(theme);
              }
              if (p["--gh-username"]) {
                  config.github = config.github || {};
                  config.github.username = p["--gh-username"].username;
              }
              if (p["--gh-password"]) {
                  config.github = config.github || {};
                  config.github.password = p["--gh-password"].password;
              }
              if (p["--gh-token"]) {
                  config.github = config.github || {};
                  config.github.token = p["--gh-token"].token;
              }
              if (p["--gh-branch"]) {
                  config.github = config.github || {};
                  config.github.branch = p["--gh-branch"].branch;
              }
              if (p["--gh-enable-pre-release"]) {
                  var val = p["--gh-enable-pre-release"].enable;
                  config.github = config.github || {};
                  config.github.enablePreRelease = !(val == "false" || !val);
              }
              if (p["--help"]) {
                  if (typeof document !== "undefined") {
                      var e = new Error(p["--help"]);
                      e.name = "help";
                      allume.update(e);
                  }
              }
              else if (!p.selector && !p.profile && (!p["--ui"] || ui)) {
                  if (host.isRuntimeBrowserFamily() && !host.isRuntimeNodeFamily()) {
                      //debug
                      window.location = "../about.html";
                  }
                  else {
                      var e = new Error("The boot sequence can't start because no package was specified. If you are the developer of the app using allume, then please make sure you specify the package to load.");
                      e.name = "error-invalid-package";
                      if (typeof document !== "undefined") {
                          allume.update(e);
                      }
                      else {
                          console.error(e);
                      }
                  }
              }
              else if (p.selector || p["--ui"]) {
                  if (ui) {
                      // listen for OS open file event
                      ui.App.on("open", function(cmdline) {
                          cmdline = cmdline.replace(/"([^"]+)"/g, function(a) {
                              return a.replace(/\s/g, "&nbsp;");
                          }).split(" ");
                          for (var i = 0, length = cmdline.length, arg = "", args = []; i < length; ++i) {
                              arg = cmdline[i].replace(/&nbsp;/g, " ");
                              // filter by exe file and exe args.
                              if (arg === "\"" + process.execPath + "\"" || arg.search(/^\-\-/) === 0) continue;
                              args.push(arg);
                          }
                          console.log("OPEN", args);
                          open(args[args.length -1]);
                      });
                  }
  
                  open(p.selector);
              }
          }
          else {
              if (typeof document !== "undefined") {
                  var e = new Error("Parameters where missing or invalid. Please check your browser javascript console.");
                  e.name = "error-invalid-parameter";
                  allume.update(e);
              }
          }
      }