There are 3 main interfaces in fuel:


This is implemented by a coclass that builds a certain type of project. The coclass will also implement it's own (dual) interface which derives from IBuild which consists of properties for configuring that specific kind of build

IBuild consists of:

  • a name property
  • a build method
  • a target files collection which lists all the files that a successful build will produce
  • a loggers collection - all messages that the build produces will be logged to all of these logs
  • ILogger

    Implemented by a coclass that logs messages (eg to a text file, database etc). As with IBuild, the coclass implements its own interface that derives from ILogger

    ILogger consists of:

  • a log method that logs the given message
  • lowest_severity property - a message must have at least this severity in order to be logged
  • highest_severity property - messages with severity greater than this will not be logged
  • a clear method that clears the log
  • IConfig

    This is implemented by coclasses that store configuration information for a bunch of builds, the dependencies between them, and a collection of loggers. IConfig derives from IBuilds, an interface to a standard Visual Basic-like collection of IBuild objects

    IConfig consists of:

  • A standard collection of IBuilds
  • load method - for loading the configuration information from storage
  • save method - for saving the configuration information back to storage
  • dependent_relationship - an indexed property for describing the dependency relationship betweem two builds
  • clear_dependencies method - removes all dependencies
  • loggers property - a collection of loggers
  • build method - builds all the IBuilds, in the correct order with respect to their dependencies
  • Component categories

    Coclasses implementing these interfaces also belong to the respective component category, viewable by using the oleview.exe program. This allows the ConfigUI programs to offer the user the choice of all coclasses on the system that implement IBuild, ILogger or IConfig.

    There are also some support libraries containing useful components:


    Used mainly for parsing type libraries


    Implements collections of strings, IBuilds, ILoggers etc.

    The Universal Property Page

    Serves as a property page to any IDispatch-implementing coclass. In order to provide a good UI, it needs extra hints as to the nature of the properties. For example, a string-type property could represent a filename or an OLEDB connection string These hints are provided in the shape of idl custom attributes

    User interface

    Finally, there are some ConfigUI programs - these provide an easy way to add builds, dependencies and loggers to an IConfig. They are very thin wrappers around IConfig implementations