diff --git a/cuesubmit/cuesubmit/Config.py b/cuesubmit/cuesubmit/Config.py
index 3bfb443a7..b06a07ec8 100644
--- a/cuesubmit/cuesubmit/Config.py
+++ b/cuesubmit/cuesubmit/Config.py
@@ -35,19 +35,61 @@
 
 def getConfigValues():
     """Reads the config file from disk and returns the values it defines."""
-    configData = {}
-    configFile = os.environ.get(CONFIG_FILE_ENV_VAR)
-    if not configFile:
-        configFile = os.path.join(opencue.config.config_base_directory(), 'cuesubmit.yaml')
-    if os.path.exists(configFile):
-        with open(configFile, 'r', encoding='utf-8') as data:
-            try:
-                configData = yaml.load(data, Loader=yaml.SafeLoader)
-            except yaml.YAMLError:
-                raise CuesubmitConfigError("Could not load yaml file: {}. Please check its "
-                                           "formatting".format(configFile))
+    configFile = os.environ.get(CONFIG_FILE_ENV_VAR)\
+                 or os.path.join(opencue.config.config_base_directory(),
+                                 'cuesubmit.yaml')
+    if not os.path.exists(configFile):
+        return {}
+    configData = _loadYamlFile(yaml_file=configFile)
+    if 'RENDER_CMDS' in configData:
+        # look for any sub-config files and load them
+        configData['RENDER_CMDS'] = _expandRenderConfigValues(configData['RENDER_CMDS'])
     return configData
 
 
+def _loadYamlFile(yaml_file):
+    """ Load config yaml as dict
+    :param yaml_file: path to a config.yaml file (path can be an env var)
+    :type yaml_file: str
+    :returns: yaml content
+    :rtype: dict
+    """
+    _yaml_file = os.path.expandvars(yaml_file)
+    if not os.path.exists(_yaml_file):
+        raise FileNotFoundError(f"yaml_file:{_yaml_file} not found")
+    config_data = {}
+    with open(_yaml_file, 'r', encoding='utf-8') as data:
+        try:
+            config_data = yaml.load(data, Loader=yaml.SafeLoader)
+        except yaml.YAMLError:
+            raise CuesubmitConfigError("Could not load yaml file: {}. Please check its "
+                                       "formatting".format(_yaml_file))
+    return config_data
+
+
+def _expandRenderConfigValues(RENDER_CMDS):
+    """ Looks through each render command and loads their 'config_file' if any
+    If 'config_file' is set but does not exist, replace its content with error for proper feedback
+
+    :param RENDER_CMDS: all render commands from the cuesubmit_config.yaml file
+    :type RENDER_CMDS: dict
+    :returns: Updated RENDER_CMDS
+    :rtype: dict
+    """
+    for job_type, _options in RENDER_CMDS.items():
+        _sub_config_file = _options.get('config_file')
+        if not _sub_config_file:
+            continue
+        try:
+            RENDER_CMDS[job_type] = _loadYamlFile(yaml_file=_sub_config_file)
+        except FileNotFoundError as error:
+            RENDER_CMDS[job_type] = {
+                'command': 'error',
+                'options': {
+                    '{ERROR}': error}
+            }
+    return RENDER_CMDS
+
+
 class CuesubmitConfigError(Exception):
     """Thrown when an error occurs reading the config file."""
diff --git a/cuesubmit/cuesubmit/Constants.py b/cuesubmit/cuesubmit/Constants.py
index 89bbbea51..832e8fe25 100644
--- a/cuesubmit/cuesubmit/Constants.py
+++ b/cuesubmit/cuesubmit/Constants.py
@@ -36,6 +36,10 @@
 MAYA_RENDER_CMD = config.get('MAYA_RENDER_CMD', 'Render')
 NUKE_RENDER_CMD = config.get('NUKE_RENDER_CMD', 'nuke')
 BLENDER_RENDER_CMD = config.get('BLENDER_RENDER_CMD', 'blender')
+RENDER_CMDS = config.get('RENDER_CMDS', {})
+
+DEFAULT_SHOW = config.get('DEFAULT_SHOW') or os.environ.get('PROJECT', 'default')
+
 FRAME_TOKEN = config.get('FRAME_TOKEN', '#IFRAME#')
 FRAME_START_TOKEN = config.get('FRAME_START', '#FRAME_START#')
 FRAME_END_TOKEN = config.get('FRAME_END', '#FRAME_END#')
@@ -68,6 +72,16 @@
 BLENDER_OUTPUT_OPTIONS_URL = \
     'https://docs.blender.org/manual/en/latest/advanced/command_line/arguments.html#render-options'
 
+REGEX_CUETOKEN = r'^#.*#$' #FRAME_START#
+REGEX_COMMAND_OPTIONS = (r'(?P<command_flag>-+\w*)?'   # -optionFlag
+                         r'(?P<hidden>\~)?'            # -hiddenFlag~
+                         r'\s?'
+                         r'({'
+                           r'(?P<mandatory>\!)?'      # {!Mandatory argument}
+                           r'(?P<label>[^{}\*\/\!]+)' # {Nice name}
+                           r'(?P<browsable>\*?\/?)'   # {browseFile*} or {browseFolder/}
+                         r'})?')
+
 DIR_PATH = os.path.dirname(__file__)
 
 # Dropdown label to specify the default Facility, i.e. let Cuebot decide.
diff --git a/cuesubmit/cuesubmit/JobTypes.py b/cuesubmit/cuesubmit/JobTypes.py
index 3c867b921..eeaa2b3a0 100644
--- a/cuesubmit/cuesubmit/JobTypes.py
+++ b/cuesubmit/cuesubmit/JobTypes.py
@@ -24,7 +24,8 @@
 
 from builtins import object
 from cuesubmit.ui import SettingsWidgets
-
+from cuesubmit import Constants
+from cuesubmit import Util
 
 class JobTypes(object):
     """Base Job Types available in the UI.
@@ -36,6 +37,7 @@ class JobTypes(object):
     MAYA = 'Maya'
     NUKE = 'Nuke'
     BLENDER = 'Blender'
+    FROM_CONFIG_FILE = Constants.RENDER_CMDS.keys()
 
     SETTINGS_MAP = {
         SHELL: SettingsWidgets.ShellSettings,
@@ -43,6 +45,8 @@ class JobTypes(object):
         NUKE: SettingsWidgets.BaseNukeSettings,
         BLENDER: SettingsWidgets.BaseBlenderSettings,
     }
+    for jobType in FROM_CONFIG_FILE:
+        SETTINGS_MAP[jobType] = SettingsWidgets.DynamicSettingsWidget
 
     def __init__(self):
         pass
@@ -50,9 +54,24 @@ def __init__(self):
     @classmethod
     def build(cls, jobType, *args, **kwargs):
         """Factory method for creating a settings widget."""
+        if jobType in cls.FROM_CONFIG_FILE:
+            jobOptions = Constants.RENDER_CMDS[jobType].get('options')
+            parameters = Util.convertCommandOptions(options=jobOptions)
+            kwargs.update({'tool_name': jobType,
+                           'parameters': parameters})
         return cls.SETTINGS_MAP[jobType](*args, **kwargs)
 
     @classmethod
     def types(cls):
-        """return a list of types available."""
-        return [cls.SHELL, cls.MAYA, cls.NUKE, cls.BLENDER]
+        """return a list of available types."""
+        return list(cls.SETTINGS_MAP.keys())
+
+    @classmethod
+    def services(cls, jobType):
+        """return a list of services for a given jobType. (the "services" key in your yaml file)"""
+        return Constants.RENDER_CMDS[jobType].get('services', [])
+
+    @classmethod
+    def limits(cls, jobType):
+        """return a list of limits for a given jobType. (the "limits" key in your yaml file)"""
+        return Constants.RENDER_CMDS[jobType].get('limits', [])
diff --git a/cuesubmit/cuesubmit/Layer.py b/cuesubmit/cuesubmit/Layer.py
index ccb0e034f..8b6b44ce7 100644
--- a/cuesubmit/cuesubmit/Layer.py
+++ b/cuesubmit/cuesubmit/Layer.py
@@ -41,6 +41,7 @@ def __init__(self):
         self.cmd = {}
         self.layerRange = ''
         self.chunk = '1'
+        self.overrideCores = False
         self.cores = '1'
         self.env = {}
         self.services = []
@@ -59,6 +60,7 @@ def toDict(self):
             'cmd': self.cmd,
             'layerRange': self.layerRange,
             'chunk': self.chunk,
+            'overrideCores': self.overrideCores,
             'cores': self.cores,
             'env': self.env,
             'services': self.services,
@@ -68,15 +70,19 @@ def toDict(self):
         }
 
     @staticmethod
-    def buildFactory(name=None, layerType=None, cmd=None, layerRange=None, chunk=None, cores=None,
-                     env=None, services=None, limits=None, dependType=None, dependsOn=None):
+    def buildFactory(name=None, layerType=None, cmd=None, layerRange=None, chunk=None,
+                     overrideCores=None, cores=None, env=None, services=None, limits=None,
+                     dependType=None, dependsOn=None):
         """Build a new LayerData object with the given settings."""
         layerData = LayerData()
-        layerData.update(name, layerType, cmd, layerRange, chunk, cores, env, services, limits,
-                         dependType, dependsOn)
+        layerData.update(name=name, layerType=layerType, cmd=cmd, layerRange=layerRange,
+                         chunk=chunk, overrideCores=overrideCores, cores=cores, env=env,
+                         services=services, limits=limits,
+                         dependType=dependType, dependsOn=dependsOn)
         return layerData
 
-    def update(self, name=None, layerType=None, cmd=None, layerRange=None, chunk=None, cores=None,
+    def update(self, name=None, layerType=None, cmd=None, layerRange=None, chunk=None,
+               overrideCores=None, cores=None,
                env=None, services=None, limits=None, dependType=None, dependsOn=None):
         """Update this Layer with the provided settings."""
         if name is not None:
@@ -91,6 +97,8 @@ def update(self, name=None, layerType=None, cmd=None, layerRange=None, chunk=Non
             self.chunk = chunk
         if cores is not None:
             self.cores = cores
+        if overrideCores is not None:
+            self.overrideCores = overrideCores
         if env is not None:
             self.env = env
         if services is not None:
diff --git a/cuesubmit/cuesubmit/Submission.py b/cuesubmit/cuesubmit/Submission.py
index f064b4cd3..33a547d2c 100644
--- a/cuesubmit/cuesubmit/Submission.py
+++ b/cuesubmit/cuesubmit/Submission.py
@@ -29,6 +29,49 @@
 
 from cuesubmit import Constants
 from cuesubmit import JobTypes
+from cuesubmit import Util
+
+
+def isSoloFlag(flag):
+    """ Check if the flag is solo, meaning it has no associated value
+     solo flags are marked with a ~ (ex: --background~)
+     """
+    return re.match(r"^-+\w+~$", flag)
+
+
+def isFlag(flag):
+    """ Check if the provided string is a flag (starts with a -)"""
+    return re.match(r"^-+\w+$", flag)
+
+
+def formatValue(flag, value, isPath, isMandatory):
+    """ Adds quotes around file/folder path variables
+     and provide an error value to display for missing mandatory values.
+    """
+    if isPath and value:
+        value = f'"{value}"'
+    if isMandatory and value in ('', None):
+        value = f'!!missing value for {flag}!!'
+    return value
+
+
+def buildDynamicCmd(layerData):
+    """From a layer, builds a customized render command."""
+    renderCommand = Constants.RENDER_CMDS[layerData.layerType].get('command')
+    for (flag, isPath, isMandatory), value in layerData.cmd.items():
+        if isSoloFlag(flag):
+            renderCommand += f' {flag[:-1]}'
+            continue
+        value = formatValue(flag, value, isPath, isMandatory)
+        if isFlag(flag) and value not in ('', None):
+            # flag and value
+            renderCommand += f' {flag} {value}'
+            continue
+        # solo argument without flag
+        if value not in ('', None):
+            renderCommand += f' {value}'
+
+    return renderCommand
 
 
 def buildMayaCmd(layerData, silent=False):
@@ -97,10 +140,17 @@ def buildLayer(layerData, command, lastLayer=None):
     @type lastLayer: outline.layer.Layer
     @param lastLayer: layer that this new layer should be dependent on if dependType is set.
     """
-    threadable = float(layerData.cores) >= 2 or float(layerData.cores) <= 0
+    threadable = False
+    if layerData.overrideCores:
+        threadable = float(layerData.cores) >= 2 or float(layerData.cores) <= 0
+    elif layerData.services and layerData.services[0] in Util.getServices():
+        threadable = Util.getServiceOption(layerData.services[0], 'threadable')
+
+    cores = layerData.cores if layerData.overrideCores else None
     layer = outline.modules.shell.Shell(
         layerData.name, command=command.split(), chunk=layerData.chunk,
-        threads=float(layerData.cores), range=str(layerData.layerRange), threadable=threadable)
+        cores=cores,
+        range=str(layerData.layerRange), threadable=threadable)
     if layerData.services:
         layer.set_service(layerData.services[0])
     if layerData.limits:
@@ -112,9 +162,12 @@ def buildLayer(layerData, command, lastLayer=None):
             layer.depend_on(lastLayer)
     return layer
 
+
 def buildLayerCommand(layerData, silent=False):
     """Builds the command to be sent per jobType"""
-    if layerData.layerType == JobTypes.JobTypes.MAYA:
+    if layerData.layerType in JobTypes.JobTypes.FROM_CONFIG_FILE:
+        command = buildDynamicCmd(layerData)
+    elif layerData.layerType == JobTypes.JobTypes.MAYA:
         command = buildMayaCmd(layerData, silent)
     elif layerData.layerType == JobTypes.JobTypes.SHELL:
         command = layerData.cmd.get('commandTextBox') if silent else layerData.cmd['commandTextBox']
@@ -129,6 +182,7 @@ def buildLayerCommand(layerData, silent=False):
             raise ValueError('unrecognized layer type {}'.format(layerData.layerType))
     return command
 
+
 def submitJob(jobData):
     """Submits the job using the PyOutline API."""
     ol = outline.Outline(
diff --git a/cuesubmit/cuesubmit/Util.py b/cuesubmit/cuesubmit/Util.py
index 1b25da8ef..5b6680da8 100644
--- a/cuesubmit/cuesubmit/Util.py
+++ b/cuesubmit/cuesubmit/Util.py
@@ -21,6 +21,7 @@
 from __future__ import absolute_import
 
 import os
+import re
 
 import opencue
 from cuesubmit import Constants
@@ -33,7 +34,22 @@ def getLimits():
 
 def getServices():
     """Returns a list of service names from cuebot."""
-    return [service.name() for service in opencue.api.getDefaultServices()]
+    try:
+        services = opencue.api.getDefaultServices()
+    except opencue.exception.ConnectionException:
+        return []
+    else:
+        return [service.name() for service in services]
+
+
+def getServiceOption(serviceName, option):
+    """Returns the value of a service property."""
+    service = next(iter(service for service in opencue.api.getDefaultServices()
+                        if service.name() == serviceName))
+    if service and hasattr(service, option):
+        return getattr(service, option)()
+    print(f'{service.name()} service has no {option} option.')
+    return None
 
 
 def getShows():
@@ -41,6 +57,14 @@ def getShows():
     return [show.name() for show in opencue.api.getShows()]
 
 
+def getDefaultShow():
+    """Returns the default show defined via environment variable or config file, if set."""
+    default_show = next(iter([show for show in getShows()
+                              if re.match(show, Constants.DEFAULT_SHOW, re.IGNORECASE)]),
+                        'no default show')
+    return default_show
+
+
 def getAllocations():
     """Returns a list of Allocations from cuebot."""
     return opencue.api.getAllocations()
@@ -60,3 +84,40 @@ def getFacilities(allocations):
     default_facilities = [Constants.DEFAULT_FACILITY_TEXT]
     facilities = set(alloc.data.facility for alloc in allocations)
     return default_facilities + list(facilities)
+
+
+def convertCommandOptions(options):
+    """ Parse command options from the config file
+    and return parameters to feed the UI (name, type, value)
+
+    :param options: All options for a given command (ex:{"-flag {Nice Name}": "default_value"})
+    :type options: dict
+    :return: list of dict of parameters
+    """
+    parameters = []
+    for option_line, value in options.items():
+        parse_option = re.search(Constants.REGEX_COMMAND_OPTIONS,
+                                 option_line)
+        options = {
+            'option_line': option_line,
+            'label': parse_option.group('label'),
+            'command_flag': parse_option.group('command_flag'),
+            'value': value,
+            'type': type(value),
+            'hidden': bool(parse_option.group('hidden'))
+                      or re.match(Constants.REGEX_CUETOKEN, str(value)),
+            'mandatory': bool(parse_option.group('mandatory')),
+            'browsable': parse_option.group('browsable'),
+            }
+        if isinstance(value, (tuple, list))\
+                and len(value) in (3, 4)\
+                and isinstance(value[0], (int, float)):
+            options.update({
+                'type': range,
+                'min': value[0],
+                'max': value[1],
+                'value': value[2],
+                'float_precision': value[3] if len(value)==4 else None
+                })
+        parameters.append(options)
+    return parameters
diff --git a/cuesubmit/cuesubmit/Validators.py b/cuesubmit/cuesubmit/Validators.py
index 0b0bfb6f8..f865b1110 100644
--- a/cuesubmit/cuesubmit/Validators.py
+++ b/cuesubmit/cuesubmit/Validators.py
@@ -58,6 +58,13 @@ def matchNumbersOnly(value):
     return False
 
 
+def matchIntegers(value):
+    """Matches positive and negative integers."""
+    if re.match(r'^-?[0-9]+$', value):
+        return True
+    return False
+
+
 def matchPositiveIntegers(value):
     """Matches integers greater than 0."""
     if re.match(r'^[0-9]+$', value) and int(value) >= 1:
@@ -70,3 +77,9 @@ def moreThan3Chars(value):
     if len(value) >= 3:
         return True
     return False
+
+def notEmptyString(value):
+    """String must contain at least 1 character."""
+    if len(value) == 0:
+        return False
+    return True
diff --git a/cuesubmit/cuesubmit/__main__.py b/cuesubmit/cuesubmit/__main__.py
index d712f30a7..a07871c4d 100644
--- a/cuesubmit/cuesubmit/__main__.py
+++ b/cuesubmit/cuesubmit/__main__.py
@@ -38,6 +38,8 @@ class CueSubmitApp(QtWidgets.QApplication):
     def __init__(self, args):
         super(CueSubmitApp, self).__init__(args)
         self.mainWindow = CueSubmitMainWindow(Constants.SUBMIT_APP_WINDOW_TITLE)
+        self.icon = QtGui.QPixmap('{}/images/OpenCue.png'.format(Constants.DIR_PATH))
+        self.setWindowIcon(self.icon)
 
     def startup(self):
         """Initializes the application and makes it appear on screen."""
diff --git a/cuesubmit/cuesubmit/ui/Command.py b/cuesubmit/cuesubmit/ui/Command.py
index ac0afb1a6..c57ccc7ce 100644
--- a/cuesubmit/cuesubmit/ui/Command.py
+++ b/cuesubmit/cuesubmit/ui/Command.py
@@ -36,6 +36,9 @@ def __init__(self, parent=None):
         super(CueCommandWidget, self).__init__(parent)
         self.commandTextBox = CueCommandTextBox(None)
         self.contentLayout.addWidget(self.commandTextBox)
+        self.signals = [self.textChanged]
+        self.getter = self.text
+        self.setter = self.setText
         self.setupConnections()
 
     def setupConnections(self):
diff --git a/cuesubmit/cuesubmit/ui/Job.py b/cuesubmit/cuesubmit/ui/Job.py
index fc15d5536..69c4193c5 100644
--- a/cuesubmit/cuesubmit/ui/Job.py
+++ b/cuesubmit/cuesubmit/ui/Job.py
@@ -36,6 +36,8 @@ def __init__(self, parent=None):
         super(CueJobWidget, self).__init__(parent=parent)
 
         self.table = CueJobTree()
+        self.table.setSizePolicy(QtWidgets.QSizePolicy.Preferred,
+                                 QtWidgets.QSizePolicy.MinimumExpanding)
         self.model = CueJobModel()
         self.jobRow = QtGui.QStandardItem('')
         self.jobRow.setEditable(False)
@@ -64,9 +66,9 @@ def setupUi(self):
         header.setStyleSheet(Style.HEADER_VIEW)
         self.model.appendRow(self.jobRow)
         self.mainLayout.addWidget(self.table)
-        self.buttonLayout.addWidget(self.downButton)
-        self.buttonLayout.addWidget(self.deleteLayerButton)
         self.buttonLayout.addWidget(self.addLayerButton)
+        self.buttonLayout.addWidget(self.deleteLayerButton)
+        self.buttonLayout.addWidget(self.downButton)
         self.buttonLayout.addWidget(self.upButton)
         self.mainLayout.addLayout(self.buttonLayout)
         self.table.expandAll()
diff --git a/cuesubmit/cuesubmit/ui/SettingsWidgets.py b/cuesubmit/cuesubmit/ui/SettingsWidgets.py
index d3062c594..ba377d394 100644
--- a/cuesubmit/cuesubmit/ui/SettingsWidgets.py
+++ b/cuesubmit/cuesubmit/ui/SettingsWidgets.py
@@ -20,11 +20,15 @@
 from __future__ import division
 from __future__ import absolute_import
 
+from collections import OrderedDict
+
 from qtpy import QtCore, QtWidgets
 
 from cuesubmit import Constants
+from cuesubmit import Validators
 from cuesubmit.ui import Command
 from cuesubmit.ui import Widgets
+from cuesubmit.ui import Style
 
 
 class BaseSettingsWidget(QtWidgets.QWidget):
@@ -261,3 +265,121 @@ def getCommandData(self):
             'outputPath': self.outputPath.text(),
             'outputFormat': self.outputSelector.text()
         }
+
+class DynamicSettingsWidget(BaseSettingsWidget):
+    """Dynamic settings widget to be used with the cuesubmit_config.yaml file.
+    See `buildDynamicWidgets` for the widgets creation
+    """
+
+    def __init__(self, parent=None, tool_name=None, parameters=None):
+        super(DynamicSettingsWidget, self).__init__(parent=parent)
+        self.groupBox.setTitle(f'{tool_name} options')
+        self.widgets = buildDynamicWidgets(parameters)
+        self.setupUi()
+        self.setSizePolicy(QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Maximum)
+        self.setupConnections()
+
+    def setupUi(self):
+        """Creates the custom widget layout."""
+        for eachWidget in self.widgets:
+            self.groupLayout.addWidget(eachWidget)
+
+    def setupConnections(self):
+        """Sets up widget signals."""
+        for eachWidget in self.widgets:
+            for eachSignal in eachWidget.signals:
+                if isinstance(eachWidget, Command.CueCommandWidget):
+                    eachSignal.connect(lambda: self.dataChanged.emit(None))
+                    continue
+                eachSignal.connect(self.dataChanged.emit)
+
+    def setCommandData(self, commandData):
+        """ Pass command data to each widget """
+        for eachWidget in self.widgets:
+            eachWidget.setter(commandData.get(eachWidget.command_id))
+
+    def getCommandData(self):
+        """ Query each widget's data """
+        options = OrderedDict()
+        for eachWidget in self.widgets:
+            options[eachWidget.command_id] = eachWidget.getter()
+        return options
+
+def buildDynamicWidgets(parameters):
+    """ Associates a widget to each parameter type
+    :param parameters: list of parameters (see Util.convertCommandOptions())
+    :type parameters: list<dict>
+    :returns: all newly created widgets
+    :rtype: list<QWidget>
+    """
+    widgets = []
+    for option in parameters:
+        label = option.get('label') or option.get('command_flag')
+        validators = None
+        if option.get('mandatory'):
+            validators = [Validators.notEmptyString]
+
+        if option['type'] is FileNotFoundError:
+            widget = Widgets.CueLabelLineEdit( labelText='Error:' )
+            widget.disable()
+            widget.setText(str(option.get('value')))
+            widget.label.setStyleSheet(Style.INVALID_TEXT)
+
+        elif option['type'] in (range, int):
+            widget = Widgets.CueLabelSlider(label=f'{label}:',
+                                            default_value=option.get('value', 0),
+                                            min_value=option.get('min', 0),
+                                            max_value=option.get('max', 999),
+                                            float_precision=option.get('float_precision'))
+
+        elif option['type'] == bool:
+            widget = Widgets.CueLabelToggle(label=f'{label}:',
+                                            default_value=option.get('value', False))
+
+        elif option.get('browsable'):
+            default_text = option['value']
+            if isinstance(option['value'], (list, tuple)):
+                default_text = ''
+            widget = Widgets.CueLabelLineEdit(labelText=f'{label}:',
+                                              defaultText=default_text,
+                                              validators=validators)
+            # Folder browser (ex: outputFolder/)
+            if option.get('browsable') == '/':
+                widget.setFolderBrowsable()
+            # File browser (ex: sceneFile*)
+            elif option.get('browsable') == '*':
+                widget.setFileBrowsable(fileFilter=option['value'])
+
+        elif option['type'] == str:
+            if option['value'] == '\n':
+                widget = Command.CueCommandWidget()
+            else:
+                widget = Widgets.CueLabelLineEdit(labelText=f'{label}:',
+                                                  defaultText=option.get('value', ''),
+                                                  validators=validators)
+
+        elif option['type'] in (list, tuple):
+            _options = option.get('value', ['No options'])
+            widget = Widgets.CueSelectPulldown(labelText=f'{label}:',
+                                               options=_options,
+                                               multiselect=False)
+        else:
+            continue
+
+        # Hide widgets containing tokens (#IFRAME#, etc..) or solo flags
+        if option['hidden']:
+            widget.setDisabled(True)
+            widget.setHidden(True)
+
+        # Register widget common attributes
+        widget.mandatory = option.get('mandatory')
+        widget.default_value = option['value']
+        widget.command_flag = option.get('command_flag') # can be None for non flagged options
+        # command_id 3-tuple is used in Submission.buildDynamicCmd()
+        # it contains (flag, isPath, isMandatory)
+        widget.command_id = (option.get('command_flag') or option['option_line'],
+                             bool(option.get('browsable')),
+                             bool(option.get('mandatory')))
+        widgets.append(widget)
+
+    return widgets
diff --git a/cuesubmit/cuesubmit/ui/Submit.py b/cuesubmit/cuesubmit/ui/Submit.py
index cd2cbc39f..9b05ce1ef 100644
--- a/cuesubmit/cuesubmit/ui/Submit.py
+++ b/cuesubmit/cuesubmit/ui/Submit.py
@@ -103,13 +103,19 @@ def __init__(
         self.mainLayout.addWidget(self.scrollArea)
         self.jobInfoLayout = QtWidgets.QVBoxLayout()
         self.layerInfoLayout = QtWidgets.QVBoxLayout()
+        self.layerLayout = QtWidgets.QHBoxLayout()
+        self.layerLayout.setSpacing(0)
+        self.framesLayout = QtWidgets.QHBoxLayout()
+        self.framesLayout.setSpacing(0)
         self.submissionDetailsLayout = QtWidgets.QVBoxLayout()
         self.jobInfoLayout.setContentsMargins(20, 0, 0, 0)
+        self.jobInfoLayout.setSpacing(0)
         self.layerInfoLayout.setContentsMargins(20, 0, 0, 0)
         self.submissionDetailsLayout.setContentsMargins(20, 0, 0, 0)
         self.settingsLayout = QtWidgets.QHBoxLayout()
 
         self.coresLayout = QtWidgets.QHBoxLayout()
+        self.coresLayout.setSpacing(10)
         self.servicesLayout = QtWidgets.QHBoxLayout()
         self.showLayout = QtWidgets.QGridLayout()
         self.facilityLayout = QtWidgets.QGridLayout()
@@ -137,7 +143,8 @@ def __init__(
                 "to create one!\nYou won't be able to submit a job for a non-existent show!\n")
             shows = ['']  # to allow building UI
         self.showSelector = Widgets.CueSelectPulldown(
-            'Show:', shows[0],
+            'Show:',
+            emptyText=Util.getDefaultShow(),
             options=shows,
             multiselect=False,
             parent=self)
@@ -155,7 +162,28 @@ def __init__(
             validators=[Validators.matchNoSpecialCharactersOnly, Validators.moreThan3Chars,
                         Validators.matchNoSpaces]
         )
+        self.layerNameInput.setSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding,
+                                          QtWidgets.QSizePolicy.Maximum)
+        self.dependSelector = Widgets.CueSelectPulldown(
+            'Dependency Type:',
+            emptyText='',
+            tooltip='No dependency: start as soon as possible.\n'
+                    'Layer: start after the previous layer.\n'
+                    'Frame: start each frame after the previous layer\'s matching frame finished.',
+            options=[Layer.DependType.Null, Layer.DependType.Layer, Layer.DependType.Frame],
+            multiselect=False)
+
         self.frameBox = Frame.FrameSpecWidget()
+        self.frameBox.setSizePolicy(QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Maximum)
+        self.chunkInput = Widgets.CueLabelLineEdit(
+            'Chunk Size:',
+            '1',
+            tooltip='Chunk frames by this value. Integers equal or greater than 1.',
+            validators=[Validators.matchPositiveIntegers]
+        )
+        self.chunkInput.lineEdit.setFixedWidth(120)
+        self.chunkInput.setSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed)
+
         jobTypes = self.jobTypes.types()
         self.jobTypeSelector = Widgets.CueSelectPulldown(
             'Job Type:',
@@ -165,46 +193,52 @@ def __init__(
         self.jobTypeSelector.setChecked(self.primaryWidgetType)
         self.servicesSelector = Widgets.CueSelectPulldown(
             'Services:',
+            tooltip='A service is a collection of resource requirements'
+                    ' and tags that are associated with a layer.\n'
+                    'It is used to help the farm allocate proper resources to the job.',
             options=Util.getServices()
         )
         self.limitsSelector = Widgets.CueSelectPulldown(
             'Limits:',
+            tooltip='A limit is set to avoid running too many jobs.\n'
+                    'For instance it can be the number of licenses available on the farm.',
             options=Util.getLimits()
         )
         self.coresInput = Widgets.CueLabelLineEdit(
-            'Min Cores:',
+            'Override Cores:',
             '0',
-            tooltip='Minimum number of cores to run. 0 is any',
-            validators=[Validators.matchNumbersOnly]
-        )
-        self.chunkInput = Widgets.CueLabelLineEdit(
-            'Chunk Size:',
-            '1',
-            tooltip='Chunk frames by this value. Integers equal or greater than 1.',
-            validators=[Validators.matchPositiveIntegers]
+            tooltip='Override the number of cores for this layer\n'
+                    'If disabled, use the service settings.\n'
+                    '0: all cores.\n'
+                    '-2: all cores minus 2.\n'
+                    'Values <= 0 force a host to accept only one job.',
+            toggleable=True,
+            toggleValue=False,
+            horizontal=True,
+            validators=[Validators.matchIntegers]
         )
-        self.chunkInput.lineEdit.setFixedWidth(120)
-        self.dependSelector = Widgets.CueSelectPulldown(
-            'Dependency Type:',
-            emptyText='',
-            options=[Layer.DependType.Null, Layer.DependType.Layer, Layer.DependType.Frame],
-            multiselect=False)
+        self.coresInput.lineEdit.setFixedWidth(103)
 
         allocations = Util.getAllocations()
         facilities = Util.getFacilities(allocations)
         preset_facility = Util.getPresetFacility()
         selected_facility = preset_facility if preset_facility else facilities[0]
         self.facilitySelector = Widgets.CueSelectPulldown(
-            'Facility:',
-            facilities[0],
+            labelText='Facility:',
+            emptyText=facilities[0],
             options=facilities,
-            multiselect=False)
+            multiselect=False,
+            tooltip='If you need to specify where your job is submitted.\n'
+                    f'{facilities[0]} means no specific facility.'
+        )
         self.facilitySelector.setChecked(selected_facility)
 
         self.settingsWidget = self.jobTypes.build(self.primaryWidgetType, *args, **kwargs)
         self.commandFeedback = Widgets.CueLabelLineEdit( labelText='Final command:' )
-        self.commandFeedback.greyOut()
+        self.commandFeedback.disable()
         self.jobTreeWidget = Job.CueJobWidget()
+        self.jobTreeWidget.setSizePolicy(QtWidgets.QSizePolicy.Preferred,
+                                         QtWidgets.QSizePolicy.Expanding)
         self.submitButtons = CueSubmitButtons()
         self.setupUi()
         self.setupConnections()
@@ -230,15 +264,17 @@ def setupConnections(self):
         self.submitButtons.cancelled.connect(self.cancel)
         self.submitButtons.submitted.connect(self.submit)
         self.jobTreeWidget.selectionChanged.connect(self.jobLayerSelectionChanged)
-        self.jobNameInput.lineEdit.textChanged.connect(self.jobDataChanged)
-        self.layerNameInput.lineEdit.textChanged.connect(self.jobDataChanged)
-        self.frameBox.frameSpecInput.lineEdit.textChanged.connect(self.jobDataChanged)
+        self.jobNameInput.textChanged.connect(self.jobDataChanged)
+        self.shotInput.textChanged.connect(self.jobDataChanged)
+        self.layerNameInput.textChanged.connect(self.jobDataChanged)
+        self.frameBox.frameSpecInput.textChanged.connect(self.jobDataChanged)
         self.settingsWidget.dataChanged.connect(self.jobDataChanged)
         self.jobTypeSelector.optionsMenu.triggered.connect(self.jobTypeChanged)
         self.servicesSelector.optionsMenu.triggered.connect(self.jobDataChanged)
         self.limitsSelector.optionsMenu.triggered.connect(self.jobDataChanged)
-        self.coresInput.lineEdit.textChanged.connect(self.jobDataChanged)
-        self.chunkInput.lineEdit.textChanged.connect(self.jobDataChanged)
+        self.coresInput.stateChanged.connect(self.jobDataChanged)
+        self.coresInput.textChanged.connect(self.jobDataChanged)
+        self.chunkInput.textChanged.connect(self.jobDataChanged)
         self.dependSelector.optionsMenu.triggered.connect(self.dependencyChanged)
         # pylint: enable=no-member
 
@@ -249,7 +285,6 @@ def setupUi(self):
 
         self.scrollingLayout.addWidget(Widgets.CueLabelLine('Job Info'))
         self.jobInfoLayout.addWidget(self.jobNameInput)
-        self.jobInfoLayout.addWidget(self.userNameInput)
         self.showLayout.setHorizontalSpacing(20)
         self.showLayout.setColumnStretch(1, 1)
         self.showLayout.addWidget(self.showSelector, 0, 0, 1, 1, QtCore.Qt.AlignLeft)
@@ -259,34 +294,35 @@ def setupUi(self):
         self.facilityLayout.setHorizontalSpacing(20)
         self.facilityLayout.setColumnStretch(1, 1)
         self.facilityLayout.addWidget(self.facilitySelector, 0, 0, 1, 1, QtCore.Qt.AlignLeft)
-        self.jobInfoLayout.addLayout(self.facilityLayout, QtCore.Qt.AlignLeft)
+        self.facilityLayout.addWidget(self.userNameInput, 0, 1, 1, 2)
+        self.jobInfoLayout.addLayout(self.facilityLayout)
 
         self.scrollingLayout.addLayout(self.jobInfoLayout)
-
-        self.scrollingLayout.addSpacerItem(Widgets.CueSpacerItem(Widgets.SpacerTypes.VERTICAL))
         self.scrollingLayout.addWidget(Widgets.CueLabelLine('Layer Info'))
-        self.layerInfoLayout.addWidget(self.layerNameInput)
-        self.layerInfoLayout.addSpacerItem(Widgets.CueSpacerItem(Widgets.SpacerTypes.VERTICAL))
-        self.layerInfoLayout.addWidget(self.frameBox)
+
+        self.layerInfoLayout.addLayout(self.layerLayout)
+        self.layerLayout.addWidget(self.layerNameInput)
+        self.layerLayout.addWidget(self.dependSelector)
+
+        self.framesLayout.addWidget(self.frameBox)
+        self.framesLayout.addWidget(self.chunkInput)
+        self.layerInfoLayout.addLayout(self.framesLayout)
 
         self.servicesLayout.addWidget(self.jobTypeSelector)
         self.servicesLayout.addWidget(self.servicesSelector)
         self.servicesLayout.addWidget(self.limitsSelector)
-        self.servicesLayout.addSpacerItem(Widgets.CueSpacerItem(Widgets.SpacerTypes.HORIZONTAL))
+        self.servicesLayout.addStretch(1)
         self.layerInfoLayout.addLayout(self.servicesLayout)
 
         self.coresLayout.addWidget(self.coresInput)
-        self.coresLayout.addWidget(self.chunkInput)
-        self.coresLayout.addWidget(self.dependSelector)
         self.coresLayout.addSpacerItem(Widgets.CueSpacerItem(Widgets.SpacerTypes.HORIZONTAL))
         self.layerInfoLayout.addLayout(self.coresLayout)
+        self.layerInfoLayout.addLayout(self.settingsLayout)
         self.layerInfoLayout.addWidget(self.commandFeedback)
         self.scrollingLayout.addLayout(self.layerInfoLayout)
 
         self.settingsLayout.addWidget(self.settingsWidget)
-        self.layerInfoLayout.addLayout(self.settingsLayout)
 
-        self.scrollingLayout.addSpacerItem(Widgets.CueSpacerItem(Widgets.SpacerTypes.VERTICAL))
         self.scrollingLayout.addWidget(Widgets.CueLabelLine('Submission Details'))
 
         self.submissionDetailsLayout.addWidget(self.jobTreeWidget)
@@ -329,6 +365,7 @@ def jobLayerSelectionChanged(self, layerObject):
         self.limitsSelector.clearChecked()
         self.limitsSelector.setChecked(layerObject.limits)
         self.coresInput.setText(str(layerObject.cores))
+        self.coresInput.label.toggle.setValue(bool(layerObject.overrideCores))
         self.chunkInput.setText(str(layerObject.chunk))
         self.dependSelector.clearChecked()
         self.dependSelector.setChecked([layerObject.dependType])
@@ -348,6 +385,7 @@ def jobDataChanged(self):
             cmd=self.settingsWidget.getCommandData(),
             layerRange=self.frameBox.frameSpecInput.text(),
             chunk=self.chunkInput.text(),
+            overrideCores=self.coresInput.toggleValue,
             cores=self.coresInput.text(),
             env=None,
             services=self.servicesSelector.getChecked(),
@@ -366,7 +404,17 @@ def updateFeedbackCommand(self, layerData):
 
     def jobTypeChanged(self):
         """Action when the job type is changed."""
-        self.updateSettingsWidget(self.jobTypeSelector.text())
+        jobType = self.jobTypeSelector.text()
+        self.updateSettingsWidget(jobType)
+
+        # Add preset from config file
+        services = JobTypes.JobTypes.services(jobType)
+        limits = JobTypes.JobTypes.limits(jobType)
+        self.servicesSelector.clearChecked()
+        self.servicesSelector.setChecked(services)
+        self.limitsSelector.clearChecked()
+        self.limitsSelector.setChecked(limits)
+
         self.jobDataChanged()
 
     def updateJobTypeSelector(self, layerType):
diff --git a/cuesubmit/cuesubmit/ui/Widgets.py b/cuesubmit/cuesubmit/ui/Widgets.py
index fb16400a9..e88240006 100644
--- a/cuesubmit/cuesubmit/ui/Widgets.py
+++ b/cuesubmit/cuesubmit/ui/Widgets.py
@@ -45,40 +45,65 @@ class SpacerTypes(object):
 
 class CueLabelLineEdit(QtWidgets.QWidget):
     """Container widget that contains a lineedit and label."""
+    textChanged = QtCore.Signal()
+    stateChanged = QtCore.Signal()
+
     def __init__(self, labelText=None, defaultText='', tooltip=None, validators=None,
+                 toggleable=False, toggleValue=False, horizontal=False,
                  completers=None, parent=None):
         super(CueLabelLineEdit, self).__init__(parent)
         self.mainLayout = QtWidgets.QGridLayout()
         self.mainLayout.setVerticalSpacing(0)
-        self.label = QtWidgets.QLabel(labelText)
-        self.label.setAlignment(QtCore.Qt.AlignLeft)
-        self.label.setSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed)
+        self.toggleable = toggleable
+        if self.toggleable:
+            self.label = CueLabelToggle(labelText, default_value=toggleValue,
+                                        tooltip=tooltip, parent=self)
+        else:
+            self.label = QtWidgets.QLabel(labelText)
+            self.label.setAlignment(QtCore.Qt.AlignLeft)
         self.lineEdit = CueLineEdit(defaultText, completerStrings=completers)
+        self.lineEdit.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed)
         self.lineEdit.setToolTip(tooltip)
         self.browseButton = QtWidgets.QPushButton(text='Browse')
         self.horizontalLine = CueHLine()
+        self.horizontal = int(horizontal)
         self.validators = validators or []
+        self.signals = [self.lineEdit.textChanged,
+                        self.lineEdit.focusChange]
+        self.getter = self.lineEdit.text
         self.setter = self.setText
         self.setupUi()
         self.setupConnections()
         self.setAutoFillBackground(True)
+        self.validateText()
 
     def setupUi(self):
         """Creates the widget layout."""
         self.setLayout(self.mainLayout)
         self.mainLayout.addWidget(self.label, 0, 0, 1, 1)
-        self.mainLayout.addWidget(self.lineEdit, 1, 0, 1, 4)
+        self.mainLayout.addWidget(self.lineEdit, 1-self.horizontal, self.horizontal, 1, 4)
+        self.mainLayout.addWidget(self.horizontalLine, 2-self.horizontal, self.horizontal, 1, 4)
         self.browseButton.setVisible(False)
-        self.mainLayout.addWidget(self.horizontalLine, 2, 0, 1, 4)
         self.label.setStyleSheet(Style.LABEL_TEXT)
 
     def setupConnections(self):
         """Sets up widget signals."""
         # pylint: disable=no-member
         self.lineEdit.textChanged.connect(self.validateText)
+        self.lineEdit.textChanged.connect(self.textChanged)
         self.lineEdit.focusChange.connect(self.textFocusChange)
+        if self.toggleable:
+            self.label.toggle.valueChanged.connect(self.toggled)
+            self.toggled(self.label.toggle.value())
         # pylint: enable=no-member
 
+    @property
+    def toggleValue(self):
+        """ Return the current toggle value """
+        if self.toggleable:
+            return self.label.toggle.value()
+        return True
+
     def setFileBrowsable(self, fileFilter=None):
         """ Displays the Browse button and hook it to a fileBrowser with optional file filters
 
@@ -137,10 +162,24 @@ def text(self):
         """
         return self.lineEdit.text()
 
-    def greyOut(self):
+    def disable(self):
         """Make widget grey and read-only"""
         self.lineEdit.setReadOnly(True)
         self.lineEdit.setStyleSheet(Style.DISABLED_LINE_EDIT)
+        self.stateChanged.emit()
+
+    def enable(self):
+        """Make widget editable"""
+        self.lineEdit.setReadOnly(False)
+        self.lineEdit.setStyleSheet(Style.LINE_EDIT)
+        self.stateChanged.emit()
+
+    def toggled(self, value):
+        """Action when the toggle is clicked."""
+        if value:
+            self.enable()
+        else:
+            self.disable()
 
 
 class CueLineEdit(QtWidgets.QLineEdit):
@@ -211,7 +250,8 @@ class CueSelectPulldown(QtWidgets.QWidget):
     """A button that acts like a dropdown and supports multiselect."""
 
     def __init__(
-            self, labelText=None, emptyText='[None]', options=None, multiselect=True, parent=None):
+            self, labelText=None, emptyText='[None]', options=None,
+            tooltip=None, multiselect=True, parent=None):
         super(CueSelectPulldown, self).__init__(parent=parent)
         self.multiselect = multiselect
         self.emptyText = emptyText
@@ -222,18 +262,23 @@ def __init__(
         self.optionsMenu = QtWidgets.QMenu(self)
         self.optionsMenu.setStyleSheet(Style.PULLDOWN_LIST)
         self.setOptions(options)
+        self.setToolTip(tooltip)
+        self.signals = [self.optionsMenu.triggered]
+        self.getter = self.text
+        self.setter = self.setCheckedFromText
         if self.multiselect:
             self.toolButton.setText(self.emptyText)
         else:
-            self.setChecked(options[0])
+            default_option = self.emptyText if self.emptyText in options else options[0]
+            self.setChecked([default_option])
         self.setupUi()
         self.setupConnections()
 
     def setupUi(self):
         """Creates the widget layout."""
         self.mainLayout.setVerticalSpacing(1)
-        self.mainLayout.addWidget(self.label, 0, 0, 1, 1)
-        self.mainLayout.addWidget(self.toolButton, 1, 0, 1, 1)
+        self.mainLayout.addWidget(self.label, 0, 0, 1, 2)
+        self.mainLayout.addWidget(self.toolButton, 1, 0, 1, 2)
         self.toolButton.setMenu(self.optionsMenu)
         self.toolButton.setPopupMode(QtWidgets.QToolButton.InstantPopup)
 
@@ -280,6 +325,16 @@ def setChecked(self, actionNames):
                 self.optionsMenu.actions()[0].setChecked(True)
         self.updateLabelText()
 
+    def setCheckedFromText(self, actionsAstext):
+        """Set the given actionNames to be checked and update the label.
+        @type actionNames: str
+        @param actionNames: list of action names to set to checked separated by a comma and a space
+        """
+        if ', ' in actionsAstext and self.multiselect:
+            self.setChecked(actionsAstext.split(', '))
+        else:
+            self.setChecked([actionsAstext])
+
     def text(self):
         """Return the tool button's current text value.
         @rtype: str
@@ -314,6 +369,7 @@ def __init__(self, spacerType, width=20, height=40):
         """
         super(CueSpacerItem, self).__init__(width, height, spacerType[0], spacerType[1])
 
+
 class CueLabelSlider(QtWidgets.QWidget):
     """Container widget that holds a label and an int or float slider.
     Behaves as a float slider when providing a float_precision
@@ -331,7 +387,7 @@ def __init__(self, label=None, parent=None,
                  max_value=999,
                  float_precision=None):
         super(CueLabelSlider, self).__init__(parent=parent)
-        self._labelValue = "%s ({value})" % label
+        self._labelValue = f'{label} ({{value}})'
         self.float_mult = 1
         if float_precision:
             self.float_mult = 10**float_precision
@@ -406,22 +462,33 @@ class CueLabelToggle(QtWidgets.QWidget):
     actionTriggered = QtCore.Signal(int)
     rangeChanged = QtCore.Signal(int, int)
 
-    def __init__(self, label=None, parent=None):
+    def __init__(self, label=None, tooltip=None, default_value=False, parent=None):
         super(CueLabelToggle, self).__init__(parent=parent)
         self.mainLayout = QtWidgets.QHBoxLayout()
+        self.mainLayout.setContentsMargins(0, 0, 0, 0)
+        self.toggle = CueToggle(parent=self)
+        self.toggle.setValue(default_value)
         self.label = QtWidgets.QLabel(label, parent=self)
-        self.label.setMinimumWidth(120)
+        self.label.setSizePolicy(QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Fixed)
         self.label.setAlignment(QtCore.Qt.AlignVCenter)
-        self.toggle = CueToggle(parent=self)
+        self.setToolTip(tooltip)
+        self.signals = [self.toggle.valueChanged]
+        self.getter = self.toggle.value
+        self.setter = self.toggle.setValue
         self.setupUi()
         self.setupConnections()
 
     def setupUi(self):
         """Creates the widget layout."""
         self.setLayout(self.mainLayout)
-        self.mainLayout.addWidget(self.label)
         self.mainLayout.addWidget(self.toggle)
-        self.mainLayout.addSpacerItem(CueSpacerItem(SpacerTypes.HORIZONTAL))
+        self.mainLayout.addWidget(self.label)
+        self.setSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Fixed)
+
+    # pylint: disable=unused-argument
+    def mousePressEvent(self, mouseEvent):
+        """Passes any mousePressEvent to the toggle, this way we can click on the label."""
+        self.toggle.toggle()
 
     def setupConnections(self):
         """Sets up widget signals."""
@@ -445,6 +512,7 @@ def __init__(self, *args, **kwargs):
         self.setMaximum(1)
         self.setSingleStep(1)
         self.setFixedWidth(30)
+        self.setFixedHeight(20)
         self.setupConnections()
         self.setStyleSheet(Style.TOGGLE_DEFAULT)
 
@@ -493,7 +561,6 @@ def __init__(self, parent=None):
         self.mainLayout.addLayout(self.contentLayout, 0, 0, 1, 4)
         self.mainLayout.addWidget(self.helpButton, 0, 4, 1, 1)
         self.mainLayout.addWidget(self.helpTextField, 1, 0, 1, 5)
-        self.mainLayout.addItem(CueSpacerItem(SpacerTypes.VERTICAL), 3, 0, 1, 5)
         self.mainLayout.setVerticalSpacing(0)
         self.mainLayout.setRowStretch(3, 1)
 
@@ -570,14 +637,17 @@ def separatorLine():
 
 def getFile(fileFilter=None):
     """ Opens a file browser and returns the result
-    :param fileFilter: optional filters (ex: "Maya Ascii File (*.ma);;
-                       Maya Binary File (*.mb);;Maya Files (*.ma *.mb)")
+    :param fileFilter: optional filters
+      (ex: "Maya Ascii File (*.ma);;Maya Binary File (*.mb);;Maya Files (*.ma *.mb)")
     :type fileFilter: str
     :returns: Name of the file
     :rtype: str
     """
-    filename, _ = QtWidgets.QFileDialog.getOpenFileName(caption='Select file',
-                                                        dir='.', filter=fileFilter)
+    filename, _ = QtWidgets.QFileDialog.getOpenFileName(
+        caption='Select file',
+        dir='.',
+        filter=fileFilter
+    )
     return filename
 
 def getFolder():
@@ -585,21 +655,25 @@ def getFolder():
     :returns: Name of the folder
     :rtype: str
     """
-    folder = QtWidgets.QFileDialog.getExistingDirectory(caption='Select folder',
-                                                        dir='.', filter='')
+    folder = QtWidgets.QFileDialog.getExistingDirectory(
+        caption='Select folder',
+        dir='.',
+        filter=''
+    )
     return folder
 
 def _setBrowseFileText(widget_setter, fileFilter):
     """ wrapper function to open a fileBrowser and set its result back in the widget
     :param widget_setter: widget's function to set its text
     :type widget_setter: function
-    :param fileFilter: optional filters (ex: "Maya Ascii File (*.ma);;
-                       Maya Binary File (*.mb);;Maya Files (*.ma *.mb)")
+    :param fileFilter: optional filters
+       (ex: "Maya Ascii File (*.ma);;Maya Binary File (*.mb);;Maya Files (*.ma *.mb)")
     :type fileFilter: str
     """
     result = getFile(fileFilter)
     widget_setter(result)
 
+# pylint: disable=keyword-arg-before-vararg,unused-argument
 def _setBrowseFolderText(widget_setter):
     """ wrapper function to open a folderBrowser and set its result back in the widget
     :param widget_setter: widget's function to set its text
diff --git a/cuesubmit/cuesubmit_config.example.yaml b/cuesubmit/cuesubmit_config.example.yaml
index 0a89a9f39..886f67a0c 100644
--- a/cuesubmit/cuesubmit_config.example.yaml
+++ b/cuesubmit/cuesubmit_config.example.yaml
@@ -5,7 +5,151 @@
 
 UI_NAME : "OPENCUESUBMIT"
 SUBMIT_APP_WINDOW_TITLE : "OpenCue Submit"
-MAYA_RENDER_CMD : "Render"
-NUKE_RENDER_CMD : "nuke"
-BLENDER_RENDER_CMD : "blender"
+
+DEFAULT_SHOW : "MyProject" # Can also be set with the "PROJECT" env var
+
 FRAME_TOKEN : "#IFRAME#"
+FRAME_START_TOKEN : "#FRAME_START#"
+FRAME_END_TOKEN : "#FRAME_END#"
+
+RENDER_CMDS:
+  Shell:
+    command: ""
+    options:
+      "{Command to run}": "\n"
+
+  Maya:
+    command: "Render"
+    services:
+      - "maya"
+      - "arnold"
+    limits:
+        - "arnold license limit"
+    options:
+      "-r {Renderer}":
+        - file
+        - default
+        - hw2
+        - sw
+        - arnold
+      "-s {Start Frame}": "#FRAME_START#"
+      "-e {End Frame}": "#FRAME_END#"
+      "{!mayaFile*}":
+          - Maya Ascii file (*.ma)
+          - Maya Binary file (*.mb)
+          - Maya file (*.ma *.mb)
+
+  Blender:
+    command: "blender"
+    options:
+      "--background~": ""
+      "-noaudio~": ""
+      "{!file*}":
+          - Blender file (*.blend)
+      "-s {Start Frame}": "#FRAME_START#"
+      "-e {End Frame}": "#FRAME_END#"
+      "-o {Output Path (Optional)*}": "//render_"
+      "-F {Output Format}": ['', 'AVIJPEG', 'AVIRAW', 'BMP', 'CINEON', 'DPX', 'EXR', 'HDR', 'IRIS', 'IRIZ',
+                   'JP2', 'JPEG', 'MPEG', 'MULTILAYER', 'PNG', 'RAWTGA', 'TGA', 'TIFF']
+
+  Nuke:
+    command: "nuke"
+    services:
+      - "nuke"
+    limits:
+        - "nuke license limit"
+    options:
+      "-X {!Write Nodes}": ""
+      "-F {Frame Range}": "#FRAME_START#-#FRAME_END#"
+      "-x {!Nuke File*}":
+        - Nuke Script File (*.nk)
+
+  Isolated Job Example:
+    config_file: "$MAYA_JOB_CONFIG_FILE"
+
+
+Help: >
+  RENDER_CMDS section describes custom job types that will appear in the UI
+  There are 2 ways to declare a job:
+   - directly in the list
+   - from a separate config file (yaml)
+  You can use environment variables to define paths
+  
+  1) To configure a job directly:
+    Command name:
+      command: "path/to/executable"
+      services:
+        - "service1"
+        - "service2"
+      limits:
+        - "limit1"
+        - "limit2"
+      options:
+        "-strFlag": "default value"
+        "-strFlagB {Nice Name}": "default value"
+        "-boolFlag": false
+        "-intFlag": 10
+                    # Creates a slider from 0 to 999
+        "-intRange": [0, 5, 3]
+                    #[min, max, default]
+        "-floatRange": [0, 1, 0.5, 2]
+                      #[min, max, default, float_precision]
+        "-choiceList":
+          -choiceA
+          -choiceB
+        "-browsableFolder {Output Folder/}": ""
+        "-anyBrowsableFile {Any File*}": ""
+        "-filteredBrowsableFile {Maya File*}":
+          - Maya Ascii file (*.ma)
+          - Maya Binary file (*.mb)
+          - Maya file (*.ma *.mb)
+        "{No flag argument}": ""
+        "{!Mandatory argument}": ""
+        "-hiddenFlag~": ""
+    
+    Note:
+     - arguments order is respected
+     - flags can have double dash (--background)
+     - Syntax:
+  
+     "-flagName"
+       command uses `-flagName`
+       UI displays `-flagName`
+  
+     "-flagName {Nice Name}"
+       command uses `-flagName`
+       UI displays `Nice Name`
+  
+     "{Nice Name}"
+       command uses blank space (no flag)
+       UI displays `Nice Name`
+  
+     "~{Nice Name}": "python"
+       command uses " python"
+       the widget is hidden
+  
+     "-flagName~"
+       command uses '-flagName'
+       the widget is hidden
+  
+     "-f {Frame}": "#IFRAME#"
+       command uses '-f #IFRAME#'
+       the widget is hidden (with any opencue token)
+  
+     "{Nice Name}": "\n"
+       Creates a multiline widget
+  
+     To make string browsable, use:
+       "{Nice Name/}" for folders
+       "{Nice Name*}" for files
+  
+     To make an option mandatory, use:
+       "{!Nice Name}"
+       UI will make it red if empty
+  
+  2) To load a command from another config_file:
+    Command Name:
+      config_file: "path/to/command/config.yaml"
+    
+    Note:
+      see cuesubmit_isolated_job_config.example.yaml
\ No newline at end of file
diff --git a/cuesubmit/cuesubmit_isolated_job_config.example.yaml b/cuesubmit/cuesubmit_isolated_job_config.example.yaml
new file mode 100644
index 000000000..b93d2286a
--- /dev/null
+++ b/cuesubmit/cuesubmit_isolated_job_config.example.yaml
@@ -0,0 +1,16 @@
+#Isolated Maya command example:
+command: "Render"
+options:
+  "-cam {!camera}": "persp"
+  "-s {startFrame}": "#FRAME_START#"
+  "-e {endFrame}": "#FRAME_END#"
+  "-log {logLevel}": [0, 5, 3]
+  "-renderer {engine}":
+      - arnold
+      - default
+      - hw2
+      - sw
+  "{!mayaFile*}":
+      - Maya Ascii file (*.ma)
+      - Maya Binary file (*.mb)
+      - Maya file (*.ma *.mb)
diff --git a/cuesubmit/tests/Config_tests.py b/cuesubmit/tests/Config_tests.py
index 749d3e098..f0c84b74e 100644
--- a/cuesubmit/tests/Config_tests.py
+++ b/cuesubmit/tests/Config_tests.py
@@ -37,6 +37,17 @@
 
 CONFIG_YAML_INVALID = b' " some text in an unclosed quote'
 
+CONFIG_YAML_WITH_RENDER_CMDS_AND_SUB_CONFIG_FILE = b'''
+RENDER_CMDS:
+  Job From Env Var:
+    config_file: "$SUB_JOB_CONFIG_FILE"
+'''
+
+SUB_JOB_CONFIG_YAML = b'''
+command: "Render"
+options:
+  "-cam {camera}": "persp"
+'''
 
 class ConfigTests(pyfakefs.fake_filesystem_unittest.TestCase):
     def setUp(self):
@@ -80,6 +91,51 @@ def test__should_fail_on_invalid_yaml(self):
         with self.assertRaises(cuesubmit.Config.CuesubmitConfigError):
             cuesubmit.Config.getConfigValues()
 
+    def test__should_expand_sub_config_from_env_var(self):
+        config_file_path = '/path/to/config.yaml'
+        sub_config_file_path = '/path/to/sub_config.yaml'
+        self.fs.create_file(
+            config_file_path,
+            contents=CONFIG_YAML_WITH_RENDER_CMDS_AND_SUB_CONFIG_FILE
+        )
+        self.fs.create_file(
+            sub_config_file_path,
+            contents=SUB_JOB_CONFIG_YAML
+        )
+        os.environ['CUESUBMIT_CONFIG_FILE'] = config_file_path
+        os.environ['SUB_JOB_CONFIG_FILE'] = sub_config_file_path
+
+        configData = cuesubmit.Config.getConfigValues()
+
+        self.assertTrue('Job From Env Var' in configData.get('RENDER_CMDS', {}).keys())
+        sub_job_config = configData.get('RENDER_CMDS', {}).get('Job From Env Var', {})
+        self.assertEqual('Render', sub_job_config.get('command'))
+        self.assertEqual(None, sub_job_config.get('config_file'),
+                         '"config_file" should be replaced by the sub_config values')
+        self.assertEqual(None, sub_job_config.get('SOME_UNKNOWN_SETTING'))
+
+    def test__should_feed_error_on_missing_sub_config_from_env_var(self):
+        config_file_path = '/path/to/config.yaml'
+        self.fs.create_file(
+            config_file_path,
+            contents=CONFIG_YAML_WITH_RENDER_CMDS_AND_SUB_CONFIG_FILE
+        )
+        os.environ['CUESUBMIT_CONFIG_FILE'] = config_file_path
+        if 'SUB_JOB_CONFIG_FILE' in os.environ:
+            del os.environ['SUB_JOB_CONFIG_FILE']
+
+        configData = cuesubmit.Config.getConfigValues()
+        sub_job_config = configData.get('RENDER_CMDS', {}).get('Job From Env Var', {})
+
+        self.assertTrue('Job From Env Var' in configData.get('RENDER_CMDS', {}).keys())
+        self.assertEqual('error', sub_job_config.get('command'))
+        self.assertEqual(None, sub_job_config.get('config_file'),
+                         '"config_file" should be replaced by the sub_config values')
+        self.assertTrue(isinstance(sub_job_config.get('options',{}).get('{ERROR}'),
+                                   FileNotFoundError))
+        # note: it does not raise, just feed it to the UI for feedback
+
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/cuesubmit/tests/Layer_tests.py b/cuesubmit/tests/Layer_tests.py
index 7ba737530..b49a2f71d 100644
--- a/cuesubmit/tests/Layer_tests.py
+++ b/cuesubmit/tests/Layer_tests.py
@@ -31,6 +31,7 @@
     'cmd': 'echo #IFRAME#',
     'layerRange': '1-5',
     'limits': [],
+    'overrideCores': True,
     'cores': '6',
     'env': {'fooKey': 'barVal'},
     'services': ['shell', 'maya'],
@@ -47,6 +48,7 @@ def testFactoryAndUpdate(self):
         self.assertEqual('randomType', layer.layerType)
         self.assertEqual('echo #IFRAME#', layer.cmd)
         self.assertEqual('1-5', layer.layerRange)
+        self.assertEqual(True, layer.overrideCores)
         self.assertEqual('6', layer.cores)
         self.assertEqual('1', layer.chunk)
         self.assertEqual(None, layer.dependsOn)
diff --git a/cuesubmit/tests/Validators_tests.py b/cuesubmit/tests/Validators_tests.py
index cbbf0b9cd..f77abed64 100644
--- a/cuesubmit/tests/Validators_tests.py
+++ b/cuesubmit/tests/Validators_tests.py
@@ -30,6 +30,7 @@
                                 matchNumbersOnly,
                                 matchPositiveIntegers,
                                 moreThan3Chars,
+                                notEmptyString,
 )
 
 
@@ -104,6 +105,13 @@ def testMoreThan3Chars(self):
         self.assertFalse(moreThan3Chars(''))
 
         self.assertRaises(TypeError, moreThan3Chars, None)
+    def testNotEmptyString(self):
+        self.assertTrue(notEmptyString('abcd'))
+        self.assertTrue(notEmptyString('1234'))
+        self.assertTrue(notEmptyString('    '))
+        self.assertTrue(notEmptyString('abc'))
+        self.assertFalse(notEmptyString(''))
+        self.assertRaises(TypeError, notEmptyString, None)
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/pyoutline/outline/backend/cue.py b/pyoutline/outline/backend/cue.py
index 1bd34bfb5..5eec12462 100644
--- a/pyoutline/outline/backend/cue.py
+++ b/pyoutline/outline/backend/cue.py
@@ -319,12 +319,18 @@ def _serialize(launcher, use_pycuerun):
 
         # opencue specific options
         # Keeping 'threads' for backward compatibility
-        if layer.get_arg("cores"):
-            if layer.get_arg("threads"):
+        cores = None
+        if layer.is_arg_set("cores"):
+            cores = layer.get_arg("cores")
+        elif layer.is_arg_set("threads"):
+            cores = layer.get_arg("threads")
+        if cores is None:
+            logger.info("%s will use service cores.", layer.get_name())
+        else:
+            logger.info("%s is set to override service cores.", layer.get_name())
+            if layer.is_arg_set("cores") and layer.is_arg_set("threads"):
                 logger.warning("%s has both cores and threads. Use cores.", layer.get_name())
-            sub_element(spec_layer, "cores", "%0.1f" % (layer.get_arg("cores")))
-        elif layer.get_arg("threads"):
-            sub_element(spec_layer, "cores", "%0.1f" % (layer.get_arg("threads")))
+            sub_element(spec_layer, "cores", "%0.1f" % float(cores))
 
         if layer.is_arg_set("threadable"):
             sub_element(spec_layer, "threadable",
diff --git a/pyoutline/tests/backend/cue_test.py b/pyoutline/tests/backend/cue_test.py
index 89c7bcac7..7dfcfe1aa 100644
--- a/pyoutline/tests/backend/cue_test.py
+++ b/pyoutline/tests/backend/cue_test.py
@@ -103,7 +103,7 @@ def create(self):
         ol.add_layer(layer)
         return ol, layer
 
-    def assertCores(self, ol, v):
+    def assertCoresOverride(self, ol, v):
         launcher = outline.cuerun.OutlineLauncher(ol, user=TEST_USER)
         outlineXml = ET.fromstring(outline.backend.cue.serialize(launcher))
         job = outlineXml.find('job')
@@ -113,19 +113,29 @@ def assertCores(self, ol, v):
     def testCores(self):
         ol, layer = self.create()
         layer.set_arg("cores", 42)
-        self.assertCores(ol, "42.0")
+        self.assertCoresOverride(ol, "42.0")
 
     def testThreads(self):
         ol, layer = self.create()
         layer.set_arg("threads", 4)
-        self.assertCores(ol, "4.0")
+        self.assertCoresOverride(ol, "4.0")
 
     def testCoresAndThreads(self):
         ol, layer = self.create()
         layer.set_arg("cores", 8)
         layer.set_arg("threads", 4)
         # cores overrides threads
-        self.assertCores(ol, "8.0")
+        self.assertCoresOverride(ol, "8.0")
+
+    def testNoCoreOverride(self):
+        ol, layer = self.create()
+        layer.set_arg("cores", None)
+
+        launcher = outline.cuerun.OutlineLauncher(ol, user=TEST_USER)
+        outlineXml = ET.fromstring(outline.backend.cue.serialize(launcher))
+        job = outlineXml.find('job')
+        layer = job.find('layers').find('layer')
+        self.assertIsNone(layer.find('cores'))
 
 
 class BuildCommandTest(unittest.TestCase):