diff --git a/Demo/imputil/importers.py b/Demo/imputil/importers.py
new file mode 100644
index 0000000..cfb2daf
--- /dev/null
+++ b/Demo/imputil/importers.py
@@ -0,0 +1,248 @@
+#
+# importers.py
+#
+# Demonstration subclasses of imputil.Importer
+#
+
+# There should be consideration for the imports below if it is desirable
+# to have "all" modules be imported through the imputil system.
+
+# these are C extensions
+import sys
+import imp
+import struct
+import marshal
+
+# these are .py modules
+import imputil
+import os
+
+######################################################################
+
+_TupleType = type(())
+_StringType = type('')
+
+######################################################################
+
+# byte-compiled file suffic character
+_suffix_char = __debug__ and 'c' or 'o'
+
+# byte-compiled file suffix
+_suffix = '.py' + _suffix_char
+
+# the C_EXTENSION suffixes
+_c_suffixes = filter(lambda x: x[2] == imp.C_EXTENSION, imp.get_suffixes())
+
+def _timestamp(pathname):
+  "Return the file modification time as a Long."
+  try:
+    s = os.stat(pathname)
+  except OSError:
+    return None
+  return long(s[8])
+
+def _fs_import(dir, modname, fqname):
+  "Fetch a module from the filesystem."
+
+  pathname = os.path.join(dir, modname)
+  if os.path.isdir(pathname):
+    values = { '__pkgdir__' : pathname, '__path__' : [ pathname ] }
+    ispkg = 1
+    pathname = os.path.join(pathname, '__init__')
+  else:
+    values = { }
+    ispkg = 0
+
+    # look for dynload modules
+    for desc in _c_suffixes:
+      file = pathname + desc[0]
+      try:
+        fp = open(file, desc[1])
+      except IOError:
+        pass
+      else:
+        module = imp.load_module(fqname, fp, file, desc)
+        values['__file__'] = file
+        return 0, module, values
+
+  t_py = _timestamp(pathname + '.py')
+  t_pyc = _timestamp(pathname + _suffix)
+  if t_py is None and t_pyc is None:
+    return None
+  code = None
+  if t_py is None or (t_pyc is not None and t_pyc >= t_py):
+    file = pathname + _suffix
+    f = open(file, 'rb')
+    if f.read(4) == imp.get_magic():
+      t = struct.unpack('<I', f.read(4))[0]
+      if t == t_py:
+        code = marshal.load(f)
+    f.close()
+  if code is None:
+    file = pathname + '.py'
+    code = _compile(file, t_py)
+
+  values['__file__'] = file
+  return ispkg, code, values
+
+######################################################################
+#
+# Simple function-based importer
+#
+class FuncImporter(imputil.Importer):
+  "Importer subclass to use a supplied function rather than method overrides."
+  def __init__(self, func):
+    self.func = func
+  def get_code(self, parent, modname, fqname):
+    return self.func(parent, modname, fqname)
+
+def install_with(func):
+  FuncImporter(func).install()
+
+
+######################################################################
+#
+# Base class for archive-based importing
+#
+class PackageArchiveImporter(imputil.Importer):
+  """Importer subclass to import from (file) archives.
+
+  This Importer handles imports of the style <archive>.<subfile>, where
+  <archive> can be located using a subclass-specific mechanism and the
+  <subfile> is found in the archive using a subclass-specific mechanism.
+
+  This class defines two hooks for subclasses: one to locate an archive
+  (and possibly return some context for future subfile lookups), and one
+  to locate subfiles.
+  """
+
+  def get_code(self, parent, modname, fqname):
+    if parent:
+      # the Importer._finish_import logic ensures that we handle imports
+      # under the top level module (package / archive).
+      assert parent.__importer__ == self
+
+      # if a parent "package" is provided, then we are importing a sub-file
+      # from the archive.
+      result = self.get_subfile(parent.__archive__, modname)
+      if result is None:
+        return None
+      if isinstance(result, _TupleType):
+        assert len(result) == 2
+        return (0,) + result
+      return 0, result, {}
+
+    # no parent was provided, so the archive should exist somewhere on the
+    # default "path".
+    archive = self.get_archive(modname)
+    if archive is None:
+      return None
+    return 1, "", {'__archive__':archive}
+
+  def get_archive(self, modname):
+    """Get an archive of modules.
+
+    This method should locate an archive and return a value which can be
+    used by get_subfile to load modules from it. The value may be a simple
+    pathname, an open file, or a complex object that caches information
+    for future imports.
+
+    Return None if the archive was not found.
+    """
+    raise RuntimeError, "get_archive not implemented"
+
+  def get_subfile(self, archive, modname):
+    """Get code from a subfile in the specified archive.
+
+    Given the specified archive (as returned by get_archive()), locate
+    and return a code object for the specified module name.
+
+    A 2-tuple may be returned, consisting of a code object and a dict
+    of name/values to place into the target module.
+
+    Return None if the subfile was not found.
+    """
+    raise RuntimeError, "get_subfile not implemented"
+
+
+class PackageArchive(PackageArchiveImporter):
+  "PackageArchiveImporter subclass that refers to a specific archive."
+
+  def __init__(self, modname, archive_pathname):
+    self.__modname = modname
+    self.__path = archive_pathname
+
+  def get_archive(self, modname):
+    if modname == self.__modname:
+      return self.__path
+    return None
+
+  # get_subfile is passed the full pathname of the archive
+
+
+######################################################################
+#
+# Emulate the standard directory-based import mechanism
+#
+class DirectoryImporter(imputil.Importer):
+  "Importer subclass to emulate the standard importer."
+
+  def __init__(self, dir):
+    self.dir = dir
+
+  def get_code(self, parent, modname, fqname):
+    if parent:
+      dir = parent.__pkgdir__
+    else:
+      dir = self.dir
+
+    # Return the module (and other info) if found in the specified
+    # directory. Otherwise, return None.
+    return _fs_import(dir, modname, fqname)
+
+  def __repr__(self):
+    return '<%s.%s for "%s" at 0x%x>' % (self.__class__.__module__,
+                                         self.__class__.__name__,
+                                         self.dir,
+                                         id(self))
+
+
+######################################################################
+#
+# Emulate the standard path-style import mechanism
+#
+class PathImporter(imputil.Importer):
+  def __init__(self, path=sys.path):
+    self.path = path
+
+  def get_code(self, parent, modname, fqname):
+    if parent:
+      # we are looking for a module inside of a specific package
+      return _fs_import(parent.__pkgdir__, modname, fqname)
+
+    # scan sys.path, looking for the requested module
+    for dir in self.path:
+      if isinstance(dir, _StringType):
+        result = _fs_import(dir, modname, fqname)
+        if result:
+          return result
+
+    # not found
+    return None
+
+######################################################################
+
+def _test_dir():
+  "Debug/test function to create DirectoryImporters from sys.path."
+  imputil.ImportManager().install()
+  path = sys.path[:]
+  path.reverse()
+  for d in path:
+    sys.path.insert(0, DirectoryImporter(d))
+  sys.path.insert(0, imputil.BuiltinImporter())
+
+def _test_revamp():
+  "Debug/test function for the revamped import system."
+  imputil.ImportManager().install()
+  sys.path.insert(0, PathImporter())
+  sys.path.insert(0, imputil.BuiltinImporter())