diff --git a/util/dvsim/CfgFactory.py b/util/dvsim/CfgFactory.py
new file mode 100644
index 0000000..a258985
--- /dev/null
+++ b/util/dvsim/CfgFactory.py
@@ -0,0 +1,100 @@
+# Copyright lowRISC contributors.
+# Licensed under the Apache License, Version 2.0, see LICENSE for details.
+# SPDX-License-Identifier: Apache-2.0
+
+import logging as log
+import sys
+
+from CfgJson import load_hjson
+
+import FpvCfg
+import LintCfg
+import SimCfg
+import SynCfg
+
+
+def _load_cfg(path, initial_values):
+    '''Worker function for make_cfg.
+
+    initial_values is passed to load_hjson (see documentation there).
+
+    Returns a pair (cls, hjson_data) on success or raises a RuntimeError on
+    failure.
+
+    '''
+    # Start by loading up the hjson file and any included files
+    hjson_data = load_hjson(path, initial_values)
+
+    # Look up the value of flow in the loaded data. This is a required field,
+    # and tells us what sort of FlowCfg to make.
+    flow = hjson_data.get('flow')
+    if flow is None:
+        raise RuntimeError('{!r}: No value for the "flow" key. Are you sure '
+                           'this is a dvsim configuration file?'
+                           .format(path))
+
+    classes = [
+        LintCfg.LintCfg,
+        SynCfg.SynCfg,
+        FpvCfg.FpvCfg,
+        SimCfg.SimCfg
+    ]
+    found_cls = None
+    known_types = []
+    for cls in classes:
+        assert cls.flow is not None
+        known_types.append(cls.flow)
+        if cls.flow == flow:
+            found_cls = cls
+            break
+    if found_cls is None:
+        raise RuntimeError('{}: Configuration file sets "flow" to {!r}, but '
+                           'this is not a known flow (known: {}).'
+                           .format(path, flow, ', '.join(known_types)))
+
+    return (found_cls, hjson_data)
+
+
+def _make_child_cfg(path, args, initial_values):
+    try:
+        cls, hjson_data = _load_cfg(path, initial_values)
+    except RuntimeError as err:
+        log.error(str(err))
+        sys.exit(1)
+
+    # Since this is a child configuration (from some primary configuration),
+    # make sure that we aren't ourselves a primary configuration. We don't need
+    # multi-level hierarchies and this avoids circular dependencies.
+    if 'use_cfgs' in hjson_data:
+        raise RuntimeError('{}: Configuration file has use_cfgs, but is '
+                           'itself included from another configuration.'
+                           .format(path))
+
+    # Call cls as a constructor. Note that we pass None as the mk_config
+    # argument: this is not supposed to load anything else.
+    return cls(path, hjson_data, args, None)
+
+
+def make_cfg(path, args, proj_root):
+    '''Make a flow config by loading the config file at path
+
+    args is the arguments passed to the dvsim.py tool and proj_root is the top
+    of the project.
+
+    '''
+    initial_values = {'proj_root': proj_root}
+    if args.tool is not None:
+        initial_values['tool'] = args.tool
+
+    try:
+        cls, hjson_data = _load_cfg(path, initial_values)
+    except RuntimeError as err:
+        log.error(str(err))
+        sys.exit(1)
+
+    def factory(child_path):
+        child_ivs = initial_values.copy()
+        child_ivs['flow'] = hjson_data['flow']
+        return _make_child_cfg(child_path, args, child_ivs)
+
+    return cls(path, hjson_data, args, factory)
diff --git a/util/dvsim/CfgJson.py b/util/dvsim/CfgJson.py
new file mode 100644
index 0000000..049e0c3
--- /dev/null
+++ b/util/dvsim/CfgJson.py
@@ -0,0 +1,172 @@
+# Copyright lowRISC contributors.
+# Licensed under the Apache License, Version 2.0, see LICENSE for details.
+# SPDX-License-Identifier: Apache-2.0
+
+'''A wrapper for loading hjson files as used by dvsim's FlowCfg'''
+
+from utils import parse_hjson, subst_wildcards
+
+
+# A set of fields that can be overridden on the command line and shouldn't be
+# loaded from the hjson in that case.
+_CMDLINE_FIELDS = {'tool'}
+
+
+def load_hjson(path, initial_values):
+    '''Load an hjson file and any includes
+
+    Combines them all into a single dictionary, which is then returned. This
+    does wildcard substitution on include names (since it might be needed to
+    find included files), but not otherwise.
+
+    initial_values is a starting point for the dictionary to be returned (which
+    is not modified). It needs to contain values for anything needed to resolve
+    include files (typically, this is 'proj_root' and 'tool' (if set)).
+
+    '''
+    worklist = [path]
+    seen = {path}
+    ret = initial_values.copy()
+    is_first = True
+
+    # Figure out a list of fields that had a value from the command line. These
+    # should have been passed in as part of initial_values and we need to know
+    # that we can safely ignore updates.
+    arg_keys = _CMDLINE_FIELDS & initial_values.keys()
+
+    while worklist:
+        next_path = worklist.pop()
+        new_paths = _load_single_file(ret, next_path, is_first, arg_keys)
+        if set(new_paths) & seen:
+            raise RuntimeError('{!r}: The file {!r} appears more than once '
+                               'when processing includes.'
+                               .format(path, next_path))
+        seen |= set(new_paths)
+        worklist += new_paths
+        is_first = False
+
+    return ret
+
+
+def _load_single_file(target, path, is_first, arg_keys):
+    '''Load a single hjson file, merging its keys into target
+
+    Returns a list of further includes that should be loaded.
+
+    '''
+    hjson = parse_hjson(path)
+    if not isinstance(hjson, dict):
+        raise RuntimeError('{!r}: Top-level hjson object is not a dictionary.'
+                           .format(path))
+
+    import_cfgs = []
+    for key, dict_val in hjson.items():
+        # If this key got set at the start of time and we want to ignore any
+        # updates: ignore them!
+        if key in arg_keys:
+            continue
+
+        # If key is 'import_cfgs', this should be a list. Add each item to the
+        # list of cfgs to process
+        if key == 'import_cfgs':
+            if not isinstance(dict_val, list):
+                raise RuntimeError('{!r}: import_cfgs value is {!r}, but '
+                                   'should be a list.'
+                                   .format(path, dict_val))
+            import_cfgs += dict_val
+            continue
+
+        # 'use_cfgs' is a bit like 'import_cfgs', but is only used for primary
+        # config files (where it is a list of the child configs). This
+        # shouldn't be used except at top-level (the first configuration file
+        # to be loaded).
+        #
+        # If defined, check that it's a list, but then allow it to be set in
+        # the target dictionary as usual.
+        if key == 'use_cfgs':
+            if not is_first:
+                raise RuntimeError('{!r}: File is included by another one, '
+                                   'but defines "use_cfgs".'
+                                   .format(path))
+            if not isinstance(dict_val, list):
+                raise RuntimeError('{!r}: use_cfgs must be a list. Saw {!r}.'
+                                   .format(path, dict_val))
+
+        # Otherwise, update target with this attribute
+        set_target_attribute(path, target, key, dict_val)
+
+    # Expand the names of imported configuration files as we return them
+    return [subst_wildcards(cfg_path,
+                            target,
+                            ignored_wildcards=[],
+                            ignore_error=False)
+            for cfg_path in import_cfgs]
+
+
+def set_target_attribute(path, target, key, dict_val):
+    '''Set an attribute on the target dictionary
+
+    This performs checks for conflicting values and merges lists /
+    dictionaries.
+
+    '''
+    old_val = target.get(key)
+    if old_val is None:
+        # A new attribute (or the old value was None, in which case it's
+        # just a placeholder and needs writing). Set it and return.
+        target[key] = dict_val
+        return
+
+    if isinstance(old_val, list):
+        if not isinstance(dict_val, list):
+            raise RuntimeError('{!r}: Conflicting types for key {!r}: was '
+                               '{!r}, a list, but loaded value is {!r}, '
+                               'of type {}.'
+                               .format(path, key, old_val, dict_val,
+                                       type(dict_val).__name__))
+
+        # Lists are merged by concatenation
+        target[key] += dict_val
+        return
+
+    # The other types we support are "scalar" types.
+    scalar_types = [(str, [""]), (int, [0, -1]), (bool, [False])]
+    defaults = None
+    for st_type, st_defaults in scalar_types:
+        if isinstance(dict_val, st_type):
+            defaults = st_defaults
+            break
+    if defaults is None:
+        raise RuntimeError('{!r}: Value for key {!r} is {!r}, of '
+                           'unknown type {}.'
+                           .format(path, key, dict_val,
+                                   type(dict_val).__name__))
+    if not isinstance(old_val, st_type):
+        raise RuntimeError('{!r}: Value for key {!r} is {!r}, but '
+                           'we already had the value {!r}, of an '
+                           'incompatible type.'
+                           .format(path, key, dict_val, old_val))
+
+    # The types are compatible. If the values are equal, there's nothing more
+    # to do
+    if old_val == dict_val:
+        return
+
+    old_is_default = old_val in defaults
+    new_is_default = dict_val in defaults
+
+    # Similarly, if new value looks like a default, ignore it (regardless
+    # of whether the current value looks like a default).
+    if new_is_default:
+        return
+
+    # If the existing value looks like a default and the new value doesn't,
+    # take the new value.
+    if old_is_default:
+        target[key] = dict_val
+        return
+
+    # Neither value looks like a default. Raise an error.
+    raise RuntimeError('{!r}: Value for key {!r} is {!r}, but '
+                       'we already had a conflicting value of {!r}.'
+                       .format(path, key, dict_val, old_val))
diff --git a/util/dvsim/FlowCfg.py b/util/dvsim/FlowCfg.py
index 6d1a58f..88ccc36 100644
--- a/util/dvsim/FlowCfg.py
+++ b/util/dvsim/FlowCfg.py
@@ -12,25 +12,39 @@
 
 import hjson
 
+from CfgJson import set_target_attribute
 from Deploy import Deploy
-from utils import VERBOSE, md_results_to_html, parse_hjson, subst_wildcards
-
-# A set of fields that can be overridden on the command line.
-_CMDLINE_FIELDS = {'tool', 'verbosity'}
+from utils import (VERBOSE, md_results_to_html,
+                   subst_wildcards, find_and_substitute_wildcards)
 
 
 # Interface class for extensions.
 class FlowCfg():
+    '''Base class for the different flows supported by dvsim.py
+
+    The constructor expects some parsed hjson data. Create these objects with
+    the factory function in CfgFactory.py, which loads the hjson data and picks
+    a subclass of FlowCfg based on its contents.
+
+    '''
+
+    # Set in subclasses. This is the key that must be used in an hjson file to
+    # tell dvsim.py which subclass to use.
+    flow = None
+
+    # Can be overridden in subclasses to configure which wildcards to ignore
+    # when expanding hjson.
+    ignored_wildcards = []
+
     def __str__(self):
         return pprint.pformat(self.__dict__)
 
-    def __init__(self, flow_cfg_file, proj_root, args):
+    def __init__(self, flow_cfg_file, hjson_data, args, mk_config):
         # Options set from command line
         self.items = args.items
         self.list_items = args.list
         self.select_cfgs = args.select_cfgs
         self.flow_cfg_file = flow_cfg_file
-        self.proj_root = proj_root
         self.args = args
         self.scratch_root = args.scratch_root
         self.branch = args.branch
@@ -40,9 +54,6 @@
         self.project = ""
         self.scratch_path = ""
 
-        # Imported cfg files using 'import_cfgs' keyword
-        self.imported_cfg_files = [flow_cfg_file]
-
         # Add exports using 'exports' keyword - these are exported to the child
         # process' environment.
         self.exports = []
@@ -95,7 +106,68 @@
         self.email_summary_md = ""
         self.results_summary_md = ""
 
-    def __post_init__(self):
+        # Merge in the values from the loaded hjson file. If subclasses want to
+        # add other default parameters that depend on the parameters above,
+        # they can override _merge_hjson and add their parameters at the start
+        # of that.
+        self._merge_hjson(hjson_data)
+
+        # Is this a primary config? If so, we need to load up all the child
+        # configurations at this point. If not, we place ourselves into
+        # self.cfgs and consider ourselves a sort of "degenerate primary
+        # configuration".
+        self.is_primary_cfg = 'use_cfgs' in hjson_data
+
+        if not self.is_primary_cfg:
+            self.cfgs.append(self)
+        else:
+            for entry in self.use_cfgs:
+                self._load_child_cfg(entry, mk_config)
+
+        # Process overrides before substituting wildcards
+        self._process_overrides()
+
+        # Expand wildcards. If subclasses need to mess around with parameters
+        # after merging the hjson but before expansion, they can override
+        # _expand and add the code at the start.
+        self._expand()
+
+        if self.rel_path == "":
+            self.rel_path = os.path.dirname(self.flow_cfg_file).replace(
+                self.proj_root + '/', '')
+
+        # Run any final checks
+        self._post_init()
+
+    def _merge_hjson(self, hjson_data):
+        '''Take hjson data and merge it into self.__dict__
+
+        Subclasses that need to do something just before the merge should
+        override this method and call super()._merge_hjson(..) at the end.
+
+        '''
+        for key, value in hjson_data.items():
+            set_target_attribute(self.flow_cfg_file,
+                                 self.__dict__,
+                                 key,
+                                 value)
+
+    def _expand(self):
+        '''Called to expand wildcards after merging hjson
+
+        Subclasses can override this to do something just before expansion.
+
+        '''
+        # If this is a primary configuration, it doesn't matter if we don't
+        # manage to expand everything.
+        partial = self.is_primary_cfg
+
+        self.__dict__ = find_and_substitute_wildcards(self.__dict__,
+                                                      self.__dict__,
+                                                      self.ignored_wildcards,
+                                                      ignore_error=partial)
+
+    def _post_init(self):
         # Run some post init checks
         if not self.is_primary_cfg:
             # Check if self.cfgs is a list of exactly 1 item (self)
@@ -103,11 +175,27 @@
                 log.error("Parse error!\n%s", self.cfgs)
                 sys.exit(1)
 
-    def create_instance(self, flow_cfg_file):
+    def create_instance(self, mk_config, flow_cfg_file):
         '''Create a new instance of this class for the given config file.
 
+        mk_config is a factory method (passed explicitly to avoid a circular
+        dependency between this file and CfgFactory.py).
+
         '''
-        return type(self)(flow_cfg_file, self.proj_root, self.args)
+        new_instance = mk_config(flow_cfg_file)
+
+        # Sanity check to make sure the new object is the same class as us: we
+        # don't yet support heterogeneous primary configurations.
+        if type(self) is not type(new_instance):
+            log.error("{}: Loading child configuration at {!r}, but the "
+                      "resulting flow types don't match: ({} vs. {})."
+                      .format(self.flow_cfg_file,
+                              flow_cfg_file,
+                              type(self).__name__,
+                              type(new_instance).__name__))
+            sys.exit(1)
+
+        return new_instance
 
     def kill(self):
         '''kill running processes and jobs gracefully
@@ -115,187 +203,38 @@
         for item in self.deploy:
             item.kill()
 
-    def _parse_cfg(self, path, is_entry_point):
-        '''Load an hjson config file at path and update self accordingly.
+    def _load_child_cfg(self, entry, mk_config):
+        '''Load a child configuration for a primary cfg'''
+        if type(entry) is str:
+            # Treat this as a file entry. Substitute wildcards in cfg_file
+            # files since we need to process them right away.
+            cfg_file = subst_wildcards(entry,
+                                       self.__dict__,
+                                       ignore_error=True)
+            self.cfgs.append(self.create_instance(mk_config, cfg_file))
 
-        If is_entry_point is true, this is the top-level configuration file, so
-        it's possible that this is a primary config.
+        elif type(entry) is dict:
+            # Treat this as a cfg expanded in-line
+            temp_cfg_file = self._conv_inline_cfg_to_hjson(entry)
+            if not temp_cfg_file:
+                return
+            self.cfgs.append(self.create_instance(mk_config, temp_cfg_file))
 
-        '''
-        hjson_dict = parse_hjson(path)
+            # Delete the temp_cfg_file once the instance is created
+            try:
+                log.log(VERBOSE, "Deleting temp cfg file:\n%s",
+                        temp_cfg_file)
+                os.system("/bin/rm -rf " + temp_cfg_file)
+            except IOError:
+                log.error("Failed to remove temp cfg file:\n%s",
+                          temp_cfg_file)
 
-        # Check if this is the primary cfg, if this is the entry point cfg file
-        if is_entry_point:
-            self.is_primary_cfg = self.check_if_primary_cfg(hjson_dict)
-
-            # If not a primary cfg, then register self with self.cfgs
-            if self.is_primary_cfg is False:
-                self.cfgs.append(self)
-
-        # Resolve the raw hjson dict to build this object
-        self.resolve_hjson_raw(path, hjson_dict)
-
-    def _parse_flow_cfg(self, path):
-        '''Parse the flow's hjson configuration.
-
-        This is a private API which should be called by the __init__ method of
-        each subclass.
-
-        '''
-        self._parse_cfg(path, True)
-        if self.rel_path == "":
-            self.rel_path = os.path.dirname(self.flow_cfg_file).replace(
-                self.proj_root + '/', '')
-
-    def check_if_primary_cfg(self, hjson_dict):
-        # This is a primary cfg only if it has a single key called "use_cfgs"
-        # which contains a list of actual flow cfgs.
-        hjson_cfg_dict_keys = hjson_dict.keys()
-        return ("use_cfgs" in hjson_cfg_dict_keys and type(hjson_dict["use_cfgs"]) is list)
-
-    def _set_attribute(self, path, key, dict_val):
-        '''Set an attribute from an hjson file
-
-        The path argument is the path for the hjson file that we're reading.
-
-        '''
-        # Is this value overridden on the command line? If so, use the override
-        # instead.
-        args_val = None
-        if key in _CMDLINE_FIELDS:
-            args_val = getattr(self.args, key, None)
-        override_msg = ''
-        if args_val is not None:
-            dict_val = args_val
-            override_msg = ' from command-line override'
-
-        self_val = getattr(self, key, None)
-        if self_val is None:
-            # A new attribute (or the old value was None, in which case it's
-            # just a placeholder and needs writing). Set it and return.
-            setattr(self, key, dict_val)
-            return
-
-        # This is already an attribute. Firstly, we need to make sure the types
-        # are compatible.
-        if type(dict_val) != type(self_val):
-            log.error("Conflicting types for key {!r} when loading {!r}. "
-                      "Cannot override value {!r} with {!r} (which is of "
-                      "type {}{})."
-                      .format(key, path, self_val, dict_val,
-                              type(dict_val).__name__, override_msg))
+        else:
+            log.error(
+                "Type of entry \"%s\" in the \"use_cfgs\" key is invalid: %s",
+                entry, str(type(entry)))
             sys.exit(1)
 
-        # Looks like the types are compatible. If they are lists, concatenate
-        # them.
-        if isinstance(self_val, list):
-            setattr(self, key, self_val + dict_val)
-            return
-
-        # Otherwise, check whether this is a type we know how to deal with.
-        scalar_types = {str: [""], int: [0, -1], bool: [False]}
-
-        defaults = scalar_types.get(type(dict_val))
-        if defaults is None:
-            log.error("When loading {!r} and setting key {!r}, found a value "
-                      "of {!r}{} with unsupported type {}."
-                      .format(path, key, dict_val,
-                              override_msg, type(dict_val).__name__))
-            sys.exit(1)
-
-        # If the values are equal, there's nothing more to do
-        if self_val == dict_val:
-            return
-
-        old_is_default = self_val in defaults
-        new_is_default = dict_val in defaults
-
-        # Similarly, if new value looks like a default, ignore it (regardless
-        # of whether the current value looks like a default).
-        if new_is_default:
-            return
-
-        # If the existing value looks like a default and the new value doesn't,
-        # take the new value.
-        if old_is_default:
-            setattr(self, key, dict_val)
-            return
-
-        # Neither value looks like a default. Raise an error.
-        log.error("When loading {!r}, key {!r} is given a value of "
-                  "{!r}{}, but the key is already set to {!r}."
-                  .format(path, key, dict_val, override_msg, self_val))
-        sys.exit(1)
-
-    def resolve_hjson_raw(self, path, hjson_dict):
-        import_cfgs = []
-        use_cfgs = []
-        for key, dict_val in hjson_dict.items():
-            # If key is 'import_cfgs' then add to the list of cfgs to process
-            if key == 'import_cfgs':
-                import_cfgs.extend(dict_val)
-                continue
-
-            # If the key is 'use_cfgs', we're only allowed to take effect for a
-            # primary config list. If we are in a primary config list, add it.
-            if key == 'use_cfgs':
-                if not self.is_primary_cfg:
-                    log.error("Key 'use_cfgs' encountered in the non-primary "
-                              "cfg file list {!r}."
-                              .format(path))
-                    sys.exit(1)
-
-                use_cfgs.extend(dict_val)
-                continue
-
-            # Otherwise, set an attribute on self.
-            self._set_attribute(path, key, dict_val)
-
-        # Parse imported cfgs
-        for cfg_file in import_cfgs:
-            if cfg_file not in self.imported_cfg_files:
-                self.imported_cfg_files.append(cfg_file)
-                # Substitute wildcards in cfg_file files since we need to process
-                # them right away.
-                cfg_file = subst_wildcards(cfg_file, self.__dict__)
-                self._parse_cfg(cfg_file, False)
-            else:
-                log.error("Cfg file \"%s\" has already been parsed", cfg_file)
-
-        # Parse primary cfg files
-        if self.is_primary_cfg:
-            for entry in use_cfgs:
-                if type(entry) is str:
-                    # Treat this as a file entry
-                    # Substitute wildcards in cfg_file files since we need to process
-                    # them right away.
-                    cfg_file = subst_wildcards(entry,
-                                               self.__dict__,
-                                               ignore_error=True)
-                    self.cfgs.append(self.create_instance(cfg_file))
-
-                elif type(entry) is dict:
-                    # Treat this as a cfg expanded in-line
-                    temp_cfg_file = self._conv_inline_cfg_to_hjson(entry)
-                    if not temp_cfg_file:
-                        continue
-                    self.cfgs.append(self.create_instance(temp_cfg_file))
-
-                    # Delete the temp_cfg_file once the instance is created
-                    try:
-                        log.log(VERBOSE, "Deleting temp cfg file:\n%s",
-                                temp_cfg_file)
-                        os.system("/bin/rm -rf " + temp_cfg_file)
-                    except IOError:
-                        log.error("Failed to remove temp cfg file:\n%s",
-                                  temp_cfg_file)
-
-                else:
-                    log.error(
-                        "Type of entry \"%s\" in the \"use_cfgs\" key is invalid: %s",
-                        entry, str(type(entry)))
-                    sys.exit(1)
-
     def _conv_inline_cfg_to_hjson(self, idict):
         '''Dump a temp hjson file in the scratch space from input dict.
         This method is to be called only by a primary cfg'''
diff --git a/util/dvsim/FpvCfg.py b/util/dvsim/FpvCfg.py
index ba0143e..1add68a 100644
--- a/util/dvsim/FpvCfg.py
+++ b/util/dvsim/FpvCfg.py
@@ -15,14 +15,14 @@
 class FpvCfg(OneShotCfg):
     """Derivative class for FPV purposes.
     """
-    def __init__(self, flow_cfg_file, proj_root, args):
-        super().__init__(flow_cfg_file, proj_root, args)
+
+    flow = 'fpv'
+
+    def __init__(self, flow_cfg_file, hjson_data, args, mk_config):
+        super().__init__(flow_cfg_file, hjson_data, args, mk_config)
         self.header = ["name", "errors", "warnings", "proven", "cex", "undetermined",
                        "covered", "unreachable", "pass_rate", "cov_rate"]
         self.summary_header = ["name", "pass_rate", "stimuli_cov", "coi_cov", "prove_cov"]
-
-    def __post_init__(self):
-        super().__post_init__()
         self.results_title = self.name.upper() + " FPV Results"
 
     def parse_dict_to_str(self, input_dict, excl_keys = []):
diff --git a/util/dvsim/LintCfg.py b/util/dvsim/LintCfg.py
index 75cf485..7854bb4 100644
--- a/util/dvsim/LintCfg.py
+++ b/util/dvsim/LintCfg.py
@@ -18,13 +18,13 @@
 class LintCfg(OneShotCfg):
     """Derivative class for linting purposes.
     """
-    def __init__(self, flow_cfg_file, proj_root, args):
+
+    flow = 'lint'
+
+    def __init__(self, flow_cfg_file, hjson_data, args, mk_config):
         # This is a lint-specific attribute
         self.is_style_lint = ""
-        super().__init__(flow_cfg_file, proj_root, args)
-
-    def __post_init__(self):
-        super().__post_init__()
+        super().__init__(flow_cfg_file, hjson_data, args, mk_config)
 
         # Convert to boolean
         if self.is_style_lint == "True":
@@ -53,7 +53,6 @@
         results_str += "### Branch: " + self.branch + "\n"
         results_str += "\n"
 
-
         header = [
             "Name", "Tool Warnings", "Tool Errors", "Lint Warnings",
             "Lint Errors"
@@ -186,7 +185,6 @@
                              ("Lint Warnings", "lint_warnings"),
                              ("Lint Errors", "lint_errors")]
 
-
             # Lint fails if any warning or error message has occurred
             self.errors_seen = False
             for _, key in hdr_key_pairs:
diff --git a/util/dvsim/OneShotCfg.py b/util/dvsim/OneShotCfg.py
index 5687729..1612734 100644
--- a/util/dvsim/OneShotCfg.py
+++ b/util/dvsim/OneShotCfg.py
@@ -13,18 +13,17 @@
 from Deploy import CompileOneShot
 from FlowCfg import FlowCfg
 from Modes import BuildModes, Modes
-from utils import VERBOSE, find_and_substitute_wildcards
 
 
 class OneShotCfg(FlowCfg):
     """Simple one-shot build flow for non-simulation targets like
     linting, synthesis and FPV.
     """
-    def __init__(self, flow_cfg_file, proj_root, args):
-        super().__init__(flow_cfg_file, proj_root, args)
 
-        assert args.tool is not None
+    ignored_wildcards = (FlowCfg.ignored_wildcards +
+                         ['build_mode', 'index', 'test'])
 
+    def __init__(self, flow_cfg_file, hjson_data, args, mk_config):
         # Options set from command line
         self.tool = args.tool
         self.verbose = args.verbose
@@ -75,22 +74,18 @@
         self.build_list = []
         self.deploy = []
         self.cov = args.cov
-        # Parse the cfg_file file tree
-        self._parse_flow_cfg(flow_cfg_file)
 
+        super().__init__(flow_cfg_file, hjson_data, args, mk_config)
+
+    def _merge_hjson(self, hjson_data):
         # If build_unique is set, then add current timestamp to uniquify it
         if self.build_unique:
             self.build_dir += "_" + self.timestamp
 
-        # Process overrides before substituting the wildcards.
-        self._process_overrides()
+        super()._merge_hjson(hjson_data)
 
-        # Make substitutions, while ignoring the following wildcards
-        # TODO: Find a way to set these in sim cfg instead
-        ignored_wildcards = ["build_mode", "index", "test"]
-        self.__dict__ = find_and_substitute_wildcards(self.__dict__,
-                                                      self.__dict__,
-                                                      ignored_wildcards)
+    def _expand(self):
+        super()._expand()
 
         # Stuff below only pertains to individual cfg (not primary cfg).
         if not self.is_primary_cfg:
@@ -113,13 +108,6 @@
             # tests and regressions, only if not a primary cfg obj
             self._create_objects()
 
-        # Post init checks
-        self.__post_init__()
-
-    def __post_init__(self):
-        # Run some post init checks
-        super().__post_init__()
-
     # Purge the output directories. This operates on self.
     def _purge(self):
         if self.scratch_path:
diff --git a/util/dvsim/SimCfg.py b/util/dvsim/SimCfg.py
index 575a881..bad908d 100644
--- a/util/dvsim/SimCfg.py
+++ b/util/dvsim/SimCfg.py
@@ -17,7 +17,7 @@
 from FlowCfg import FlowCfg
 from Modes import BuildModes, Modes, Regressions, RunModes, Tests
 from tabulate import tabulate
-from utils import VERBOSE, find_and_substitute_wildcards
+from utils import VERBOSE
 
 from testplanner import class_defs, testplan_utils
 
@@ -48,8 +48,16 @@
     A simulation configuration class holds key information required for building a DV
     regression framework.
     """
-    def __init__(self, flow_cfg_file, proj_root, args):
-        super().__init__(flow_cfg_file, proj_root, args)
+
+    flow = 'sim'
+
+    # TODO: Find a way to set these in sim cfg instead
+    ignored_wildcards = [
+        "build_mode", "index", "test", "seed", "uvm_test", "uvm_test_seq",
+        "cov_db_dirs", "sw_images", "sw_build_device"
+    ]
+
+    def __init__(self, flow_cfg_file, hjson_data, args, mk_config):
         # Options set from command line
         self.tool = args.tool
         self.build_opts = []
@@ -73,10 +81,7 @@
         self.profile = args.profile or '(cfg uses profile without --profile)'
         self.xprop_off = args.xprop_off
         self.no_rerun = args.no_rerun
-        # Single-character verbosity setting (n, l, m, h, d). args.verbosity
-        # might be None, in which case we'll pick up a default value from
-        # configuration files.
-        self.verbosity = args.verbosity
+        self.verbosity = None  # set in _expand
         self.verbose = args.verbose
         self.dry_run = args.dry_run
         self.map_full_testplan = args.map_full_testplan
@@ -139,9 +144,9 @@
         # Maintain an array of those in cov_deploys.
         self.cov_deploys = []
 
-        # Parse the cfg_file file tree
-        self._parse_flow_cfg(flow_cfg_file)
+        super().__init__(flow_cfg_file, hjson_data, args, mk_config)
 
+    def _expand(self):
         # Choose a wave format now. Note that this has to happen after parsing
         # the configuration format because our choice might depend on the
         # chosen tool.
@@ -151,19 +156,15 @@
         if self.build_unique:
             self.build_dir += "_" + self.timestamp
 
-        # Process overrides before substituting the wildcards.
-        self._process_overrides()
+        # If the user specified a verbosity on the command line then
+        # self.args.verbosity will be n, l, m, h or d. Set self.verbosity now.
+        # We will actually have loaded some other verbosity level from the
+        # config file, but that won't have any effect until expansion so we can
+        # safely switch it out now.
+        if self.args.verbosity is not None:
+            self.verbosity = self.args.verbosity
 
-        # Make substitutions, while ignoring the following wildcards
-        # TODO: Find a way to set these in sim cfg instead
-        ignored_wildcards = [
-            "build_mode", "index", "test", "seed", "uvm_test", "uvm_test_seq",
-            "cov_db_dirs", "sw_images", "sw_build_device"
-        ]
-        self.__dict__ = find_and_substitute_wildcards(self.__dict__,
-                                                      self.__dict__,
-                                                      ignored_wildcards,
-                                                      self.is_primary_cfg)
+        super()._expand()
 
         # Set the title for simulation results.
         self.results_title = self.name.upper() + " Simulation Results"
@@ -202,13 +203,6 @@
             # tests and regressions, only if not a primary cfg obj
             self._create_objects()
 
-        # Post init checks
-        self.__post_init__()
-
-    def __post_init__(self):
-        # Run some post init checks
-        super().__post_init__()
-
     def _resolve_waves(self):
         '''Choose and return a wave format, if waves are enabled.
 
diff --git a/util/dvsim/SynCfg.py b/util/dvsim/SynCfg.py
index f0bf107..9a11841 100644
--- a/util/dvsim/SynCfg.py
+++ b/util/dvsim/SynCfg.py
@@ -18,11 +18,11 @@
 class SynCfg(OneShotCfg):
     """Derivative class for synthesis purposes.
     """
-    def __init__(self, flow_cfg_file, proj_root, args):
-        super().__init__(flow_cfg_file, proj_root, args)
 
-    def __post_init__(self):
-        super().__post_init__()
+    flow = 'syn'
+
+    def __init__(self, flow_cfg_file, hjson_data, args, mk_config):
+        super().__init__(flow_cfg_file, hjson_data, args, mk_config)
         # Set the title for synthesis results.
         self.results_title = self.name.upper() + " Synthesis Results"
 
diff --git a/util/dvsim/dvsim.py b/util/dvsim/dvsim.py
index 6c3dd38..801e427 100755
--- a/util/dvsim/dvsim.py
+++ b/util/dvsim/dvsim.py
@@ -28,11 +28,8 @@
 import textwrap
 from signal import SIGINT, signal
 
+from CfgFactory import make_cfg
 import Deploy
-import FpvCfg
-import LintCfg
-import SimCfg
-import SynCfg
 import utils
 
 # TODO: add dvsim_cfg.hjson to retrieve this info
@@ -136,26 +133,6 @@
     return branch
 
 
-def make_config(args, proj_root):
-    '''A factory method for FlowCfg objects'''
-
-    # Look up the tool in a dictionary, defaulting to SimCfg.
-    #
-    # If --tool was not passed (so args.tool is None), we have to figure out
-    # the tool by reading the config file. At the moment, this forces a
-    # simulation target (TODO?)
-    factories = {
-        'ascentlint': LintCfg.LintCfg,
-        'veriblelint': LintCfg.LintCfg,
-        'verilator': LintCfg.LintCfg,
-        'dc': SynCfg.SynCfg,
-        'jaspergold': FpvCfg.FpvCfg
-    }
-
-    factory = factories.get(args.tool, SimCfg.SimCfg)
-    return factory(args.cfg, proj_root, args)
-
-
 # Get the project root directory path - this is used to construct the full paths
 def get_proj_root():
     cmd = ["git", "rev-parse", "--show-toplevel"]
@@ -590,7 +567,7 @@
         proj_root = get_proj_root()
 
     global cfg
-    cfg = make_config(args, proj_root)
+    cfg = make_cfg(args.cfg, args, proj_root)
 
     # Handle Ctrl-C exit.
     signal(SIGINT, sigint_handler)