diff --git a/jspwiki-main/src/main/java/org/apache/wiki/auth/AuthenticationManager.java b/jspwiki-main/src/main/java/org/apache/wiki/auth/AuthenticationManager.java
index 143c180..72a93f9 100644
--- a/jspwiki-main/src/main/java/org/apache/wiki/auth/AuthenticationManager.java
+++ b/jspwiki-main/src/main/java/org/apache/wiki/auth/AuthenticationManager.java
@@ -18,9 +18,8 @@
  */
 package org.apache.wiki.auth;
 
-import org.apache.wiki.api.core.Engine;
 import org.apache.wiki.api.core.Session;
-import org.apache.wiki.api.exceptions.WikiException;
+import org.apache.wiki.api.engine.Initializable;
 import org.apache.wiki.auth.authorize.Role;
 import org.apache.wiki.event.WikiEventListener;
 import org.apache.wiki.event.WikiEventManager;
@@ -32,7 +31,6 @@
 import javax.servlet.http.HttpServletRequest;
 import java.security.Principal;
 import java.util.Map;
-import java.util.Properties;
 import java.util.Set;
 
 
@@ -47,7 +45,7 @@
  * 
  * @since 2.3
  */
-public interface AuthenticationManager {
+public interface AuthenticationManager extends Initializable {
 
     /** If this jspwiki.properties property is <code>true</code>, logs the IP address of the editor on saving. */
     String PROP_STOREIPADDRESS = "jspwiki.storeIPAddress";
@@ -68,16 +66,6 @@
     String PROP_LOGIN_MODULE = "jspwiki.loginModule.class";
 
     /**
-     * Creates an AuthenticationManager instance for the given Engine and
-     * the specified set of properties. All initialization for the modules is
-     * done here.
-     * @param engine the wiki engine
-     * @param props the properties used to initialize the wiki engine
-     * @throws WikiException if the AuthenticationManager cannot be initialized
-     */
-    void initialize( Engine engine, Properties props ) throws WikiException;
-
-    /**
      * Returns true if this Engine uses container-managed authentication. This method is used primarily for cosmetic purposes in the
      * JSP tier, and performs no meaningful security function per se. Delegates to
      * {@link org.apache.wiki.auth.authorize.WebContainerAuthorizer#isContainerAuthorized()},
diff --git a/jspwiki-main/src/main/java/org/apache/wiki/auth/AuthorizationManager.java b/jspwiki-main/src/main/java/org/apache/wiki/auth/AuthorizationManager.java
index 328d266..74e11de 100644
--- a/jspwiki-main/src/main/java/org/apache/wiki/auth/AuthorizationManager.java
+++ b/jspwiki-main/src/main/java/org/apache/wiki/auth/AuthorizationManager.java
@@ -19,9 +19,8 @@
 package org.apache.wiki.auth;
 
 import org.apache.wiki.api.core.Context;
-import org.apache.wiki.api.core.Engine;
 import org.apache.wiki.api.core.Session;
-import org.apache.wiki.api.exceptions.WikiException;
+import org.apache.wiki.api.engine.Initializable;
 import org.apache.wiki.auth.authorize.Role;
 import org.apache.wiki.event.WikiEventListener;
 import org.apache.wiki.event.WikiEventManager;
@@ -32,7 +31,6 @@
 import java.security.AccessController;
 import java.security.Permission;
 import java.security.Principal;
-import java.util.Properties;
 
 
 /**
@@ -59,7 +57,7 @@
  * @since 2.3
  * @see AuthenticationManager
  */
-public interface AuthorizationManager {
+public interface AuthorizationManager extends Initializable {
 
     /** The default external Authorizer is the {@link org.apache.wiki.auth.authorize.WebContainerAuthorizer} */
     String DEFAULT_AUTHORIZER = "org.apache.wiki.auth.authorize.WebContainerAuthorizer";
@@ -198,16 +196,6 @@
     boolean hasAccess( final Context context, final HttpServletResponse response, final boolean redirect ) throws IOException;
 
     /**
-     * Initializes AuthorizationManager with an engine and set of properties. Expects to find property 'jspwiki.authorizer' with a valid
-     * Authorizer implementation name to take care of role lookup operations.
-     *
-     * @param engine the wiki engine
-     * @param properties the set of properties used to initialize the wiki engine
-     * @throws WikiException if the AuthorizationManager cannot be initialized
-     */
-    void initialize( final Engine engine, final Properties properties ) throws WikiException;
-
-    /**
      * Checks to see if the local security policy allows a particular static Permission.
      * Do not use this method for normal permission checks; use {@link #checkPermission(Session, Permission)} instead.
      *
diff --git a/jspwiki-main/src/main/java/org/apache/wiki/auth/DefaultAuthorizationManager.java b/jspwiki-main/src/main/java/org/apache/wiki/auth/DefaultAuthorizationManager.java
index fef2949..3e5de32 100644
--- a/jspwiki-main/src/main/java/org/apache/wiki/auth/DefaultAuthorizationManager.java
+++ b/jspwiki-main/src/main/java/org/apache/wiki/auth/DefaultAuthorizationManager.java
@@ -225,7 +225,11 @@
         return allowed;
     }
 
-    /** {@inheritDoc} */
+    /**
+     * {@inheritDoc}
+     *
+     * Expects to find property 'jspwiki.authorizer' with a valid Authorizer implementation name to take care of role lookup operations.
+     */
     @Override
     public void initialize( final Engine engine, final Properties properties ) throws WikiException {
         m_engine = engine;
diff --git a/jspwiki-main/src/main/java/org/apache/wiki/auth/UserManager.java b/jspwiki-main/src/main/java/org/apache/wiki/auth/UserManager.java
index 266cbe4..953f811 100644
--- a/jspwiki-main/src/main/java/org/apache/wiki/auth/UserManager.java
+++ b/jspwiki-main/src/main/java/org/apache/wiki/auth/UserManager.java
@@ -19,8 +19,8 @@
 package org.apache.wiki.auth;
 
 import org.apache.wiki.api.core.Context;
-import org.apache.wiki.api.core.Engine;
 import org.apache.wiki.api.core.Session;
+import org.apache.wiki.api.engine.Initializable;
 import org.apache.wiki.api.exceptions.WikiException;
 import org.apache.wiki.auth.user.DuplicateUserException;
 import org.apache.wiki.auth.user.UserDatabase;
@@ -30,7 +30,6 @@
 import org.apache.wiki.event.WikiSecurityEvent;
 
 import java.security.Principal;
-import java.util.Properties;
 
 
 /**
@@ -38,7 +37,7 @@
  *
  * @since 2.3
  */
-public interface UserManager {
+public interface UserManager extends Initializable {
 
     /** Message key for the "save profile" message. */
     String PROP_DATABASE = "jspwiki.userdatabase";
@@ -46,14 +45,6 @@
     String JSON_USERS = "users";
 
     /**
-     * Initializes the engine for its nefarious purposes.
-     *
-     * @param engine the current wiki engine
-     * @param props the wiki engine initialization properties
-     */
-    void initialize( final Engine engine, final Properties props );
-
-    /**
      * Returns the UserDatabase employed by this Engine. The UserDatabase is lazily initialized by this method, if it does
      * not exist yet. If the initialization fails, this method will use the inner class DummyUserDatabase as a default (which
      * is enough to get JSPWiki running).
diff --git a/jspwiki-main/src/main/java/org/apache/wiki/auth/acl/AclManager.java b/jspwiki-main/src/main/java/org/apache/wiki/auth/acl/AclManager.java
index 357db2e..d6f2825 100644
--- a/jspwiki-main/src/main/java/org/apache/wiki/auth/acl/AclManager.java
+++ b/jspwiki-main/src/main/java/org/apache/wiki/auth/acl/AclManager.java
@@ -19,26 +19,16 @@
 package org.apache.wiki.auth.acl;
 
 import org.apache.wiki.api.core.Acl;
-import org.apache.wiki.api.core.Engine;
 import org.apache.wiki.api.core.Page;
+import org.apache.wiki.api.engine.Initializable;
 import org.apache.wiki.auth.WikiSecurityException;
 
-import java.util.Properties;
-
 /**
  *  Specifies how to parse and return ACLs from wiki pages.
  *
  *  @since 2.3
  */
-public interface AclManager {
-
-    /**
-     * Initializes the AclManager with a supplied wiki engine and properties.
-     *
-     * @param engine the wiki engine
-     * @param props the initialization properties
-     */
-    void initialize( Engine engine, Properties props );
+public interface AclManager extends Initializable {
 
     /**
      * A helper method for parsing textual AccessControlLists. The line is in form
diff --git a/jspwiki-main/src/main/java/org/apache/wiki/auth/authorize/GroupManager.java b/jspwiki-main/src/main/java/org/apache/wiki/auth/authorize/GroupManager.java
index 3deea3a..e2816eb 100644
--- a/jspwiki-main/src/main/java/org/apache/wiki/auth/authorize/GroupManager.java
+++ b/jspwiki-main/src/main/java/org/apache/wiki/auth/authorize/GroupManager.java
@@ -20,6 +20,7 @@
 
 import org.apache.wiki.api.core.Context;
 import org.apache.wiki.api.core.Session;
+import org.apache.wiki.api.engine.Initializable;
 import org.apache.wiki.auth.Authorizer;
 import org.apache.wiki.auth.NoSuchPrincipalException;
 import org.apache.wiki.auth.WikiSecurityException;
@@ -41,7 +42,7 @@
  * </p>
  * @since 2.4.19
  */
-public interface GroupManager extends Authorizer, WikiEventListener {
+public interface GroupManager extends Initializable, Authorizer, WikiEventListener {
 
     /** Key used for adding UI messages to a user's Session. */
     String MESSAGES_KEY = "group";
diff --git a/jspwiki-main/src/main/java/org/apache/wiki/render/DefaultRenderingManager.java b/jspwiki-main/src/main/java/org/apache/wiki/render/DefaultRenderingManager.java
index 9578916..a140f3a 100644
--- a/jspwiki-main/src/main/java/org/apache/wiki/render/DefaultRenderingManager.java
+++ b/jspwiki-main/src/main/java/org/apache/wiki/render/DefaultRenderingManager.java
@@ -98,6 +98,9 @@
 
     /**
      *  {@inheritDoc}
+     *
+     *  Checks for cache size settings, initializes the document cache. Looks for alternative WikiRenderers, initializes one, or the
+     *  default XHTMLRenderer, for use.
      */
     @Override
     public void initialize( final Engine engine, final Properties properties ) throws WikiException {
diff --git a/jspwiki-main/src/main/java/org/apache/wiki/render/RenderingManager.java b/jspwiki-main/src/main/java/org/apache/wiki/render/RenderingManager.java
index d049ea7..36ecc32 100644
--- a/jspwiki-main/src/main/java/org/apache/wiki/render/RenderingManager.java
+++ b/jspwiki-main/src/main/java/org/apache/wiki/render/RenderingManager.java
@@ -21,9 +21,8 @@
 import org.apache.log4j.Logger;
 import org.apache.wiki.StringTransmutator;
 import org.apache.wiki.api.core.Context;
-import org.apache.wiki.api.core.Engine;
 import org.apache.wiki.api.core.Page;
-import org.apache.wiki.api.exceptions.WikiException;
+import org.apache.wiki.api.engine.Initializable;
 import org.apache.wiki.api.providers.PageProvider;
 import org.apache.wiki.event.WikiEventListener;
 import org.apache.wiki.modules.InternalModule;
@@ -31,7 +30,6 @@
 import org.apache.wiki.parser.WikiDocument;
 
 import java.io.IOException;
-import java.util.Properties;
 
 
 /**
@@ -44,7 +42,7 @@
  *
  *  @since  2.4
  */
-public interface RenderingManager extends WikiEventListener, InternalModule {
+public interface RenderingManager extends WikiEventListener, InternalModule, Initializable {
 
     /** markup parser property. */
     String PROP_PARSER = "jspwiki.renderingManager.markupParser";
@@ -61,18 +59,6 @@
     String DOCUMENTCACHE_NAME = "jspwiki.renderingCache";
 
     /**
-     *  Initializes the RenderingManager.
-     *  Checks for cache size settings, initializes the document cache.
-     *  Looks for alternative WikiRenderers, initializes one, or the default
-     *  XHTMLRenderer, for use.
-     *
-     *  @param engine A Engine instance.
-     *  @param properties A list of properties to get parameters from.
-     *  @throws WikiException If the manager could not be initialized.
-     */
-    void initialize( Engine engine, Properties properties ) throws WikiException;
-
-    /**
      *  Beautifies the title of the page by appending spaces in suitable places, if the user has so decreed in the properties when
      *  constructing this Engine.  However, attachment names are only beautified by the name.
      *
diff --git a/jspwiki-main/src/main/java/org/apache/wiki/rss/DefaultRSSGenerator.java b/jspwiki-main/src/main/java/org/apache/wiki/rss/DefaultRSSGenerator.java
index 12ee384..c0fa0cd 100644
--- a/jspwiki-main/src/main/java/org/apache/wiki/rss/DefaultRSSGenerator.java
+++ b/jspwiki-main/src/main/java/org/apache/wiki/rss/DefaultRSSGenerator.java
@@ -76,7 +76,11 @@
         m_rssFile = TextUtil.getStringProperty( properties, DefaultRSSGenerator.PROP_RSSFILE, "rss.rdf" );
     }
 
-    /** {@inheritDoc} */
+    /**
+     * {@inheritDoc}
+     *
+     * Start the RSS generator & generator thread
+     */
     @Override
     public void initialize( final Engine engine, final Properties properties ) {
         final File rssFile;
diff --git a/jspwiki-main/src/main/java/org/apache/wiki/rss/RSSGenerator.java b/jspwiki-main/src/main/java/org/apache/wiki/rss/RSSGenerator.java
index e44a7ff..a501a4b 100644
--- a/jspwiki-main/src/main/java/org/apache/wiki/rss/RSSGenerator.java
+++ b/jspwiki-main/src/main/java/org/apache/wiki/rss/RSSGenerator.java
@@ -19,12 +19,11 @@
 package org.apache.wiki.rss;
 
 import org.apache.wiki.api.core.Context;
-import org.apache.wiki.api.core.Engine;
 import org.apache.wiki.api.core.Page;
+import org.apache.wiki.api.engine.Initializable;
 import org.apache.wiki.util.TextUtil;
 
 import java.util.List;
-import java.util.Properties;
 
 /**
  *  The master class for generating different kinds of Feeds (including RSS1.0, 2.0 and Atom).
@@ -40,7 +39,7 @@
  *
  *  @since  1.7.5.
  */
-public interface RSSGenerator {
+public interface RSSGenerator extends Initializable {
 
     /** Parameter value to represent RSS 1.0 feeds.  Value is <tt>{@value}</tt>. */
     String RSS10 = "rss10";
@@ -105,14 +104,6 @@
     String PROP_RSS_AUTHOREMAIL = "jspwiki.rss.author.email";
 
     /**
-     * Start the RSS generator & generator thread
-     *
-     * @param engine the engine
-     * @param properties the properties
-     */
-    void initialize( Engine engine, Properties properties );
-
-    /**
      *  Generates the RSS resource.  You probably want to output this result into a file or something, or serve as output from a servlet.
      *
      *  @return A RSS 1.0 feed in the "full" mode.
diff --git a/jspwiki-main/src/main/java/org/apache/wiki/ui/DefaultEditorManager.java b/jspwiki-main/src/main/java/org/apache/wiki/ui/DefaultEditorManager.java
index 77d42e3..9d74621 100644
--- a/jspwiki-main/src/main/java/org/apache/wiki/ui/DefaultEditorManager.java
+++ b/jspwiki-main/src/main/java/org/apache/wiki/ui/DefaultEditorManager.java
@@ -66,7 +66,11 @@
         super( engine );
     }
 
-    /** {@inheritDoc} */
+    /**
+     * {@inheritDoc}
+     *
+     * Initializes the EditorManager.  It also registers any editors it can find.
+     */
     @Override
     public void initialize( final Engine engine, final Properties props ) {
         registerEditors();
diff --git a/jspwiki-main/src/main/java/org/apache/wiki/ui/EditorManager.java b/jspwiki-main/src/main/java/org/apache/wiki/ui/EditorManager.java
index 706ab3d..3c1236a 100644
--- a/jspwiki-main/src/main/java/org/apache/wiki/ui/EditorManager.java
+++ b/jspwiki-main/src/main/java/org/apache/wiki/ui/EditorManager.java
@@ -19,11 +19,10 @@
 package org.apache.wiki.ui;
 
 import org.apache.wiki.api.core.Context;
-import org.apache.wiki.api.core.Engine;
+import org.apache.wiki.api.engine.Initializable;
 import org.apache.wiki.modules.ModuleManager;
 
 import javax.servlet.jsp.PageContext;
-import java.util.Properties;
 
 
 /**
@@ -44,7 +43,7 @@
  *
  *  @since 2.4
  */
-public interface EditorManager extends ModuleManager {
+public interface EditorManager extends ModuleManager, Initializable {
 
     /** The property name for setting the editor. Current value is "jspwiki.editor" - not used anymore: replaced by defaultpref.template.editor */
     String PROP_EDITORTYPE = "jspwiki.editor";
@@ -65,14 +64,6 @@
     String ATTR_EDITEDTEXT = REQ_EDITEDTEXT;
 
     /**
-     * Initializes the EditorManager.  It also registers any editors it can find.
-     *
-     * @param engine engine performing the initialization.
-     * @param props  Properties for setup.
-     */
-    void initialize( Engine engine, Properties props );
-
-    /**
      *  Returns an editor for the current context.  The editor names are matched in a case insensitive manner.  At the moment, the only
      *  place that this method looks in is the property file, but in the future this will also look at user preferences.
      *  <p>
diff --git a/jspwiki-main/src/main/java/org/apache/wiki/url/URLConstructor.java b/jspwiki-main/src/main/java/org/apache/wiki/url/URLConstructor.java
index e41f140..8853394 100644
--- a/jspwiki-main/src/main/java/org/apache/wiki/url/URLConstructor.java
+++ b/jspwiki-main/src/main/java/org/apache/wiki/url/URLConstructor.java
@@ -18,12 +18,11 @@
  */
 package org.apache.wiki.url;
 
-import org.apache.wiki.api.core.Engine;
+import org.apache.wiki.api.engine.Initializable;
 
 import javax.servlet.http.HttpServletRequest;
 import java.io.IOException;
 import java.nio.charset.Charset;
-import java.util.Properties;
 
 
 /**
@@ -33,15 +32,7 @@
  *
  *  @since 2.2
  */
-public interface URLConstructor {
-    /**
-     *  Initializes.  Note that the engine is not fully initialized at this
-     *  point, so don't do anything fancy here - use lazy init, if you have to.
-     *
-     *  @param  engine The Engine that this URLConstructor belongs to
-     *  @param properties Properties used to initialize
-     */
-    void initialize( Engine engine, Properties properties );
+public interface URLConstructor extends Initializable {
 
     /**
      *  Constructs the URL with a bunch of parameters.
diff --git a/jspwiki-main/src/main/java/org/apache/wiki/workflow/DefaultWorkflowManager.java b/jspwiki-main/src/main/java/org/apache/wiki/workflow/DefaultWorkflowManager.java
index 8ba0838..4703763 100644
--- a/jspwiki-main/src/main/java/org/apache/wiki/workflow/DefaultWorkflowManager.java
+++ b/jspwiki-main/src/main/java/org/apache/wiki/workflow/DefaultWorkflowManager.java
@@ -92,6 +92,12 @@
 
     /**
      * {@inheritDoc}
+     *
+     * Any properties that begin with {@link #PROPERTY_APPROVER_PREFIX} will be assumed to be Decisions that require approval. For a given
+     * property key, everything after the prefix denotes the Decision's message key. The property value indicates the Principal (Role,
+     * GroupPrincipal, WikiPrincipal) that must approve the Decision. For example, if the property key/value pair is
+     * {@code jspwiki.approver.workflow.saveWikiPage=Admin}, the Decision's message key is <code>workflow.saveWikiPage</code>. The Principal
+     * <code>Admin</code> will be resolved via {@link org.apache.wiki.auth.AuthorizationManager#resolvePrincipal(String)}.
      */
     @Override
     public void initialize( final Engine engine, final Properties props ) {
diff --git a/jspwiki-main/src/main/java/org/apache/wiki/workflow/WorkflowManager.java b/jspwiki-main/src/main/java/org/apache/wiki/workflow/WorkflowManager.java
index 6e803c0..a0cfdd2 100644
--- a/jspwiki-main/src/main/java/org/apache/wiki/workflow/WorkflowManager.java
+++ b/jspwiki-main/src/main/java/org/apache/wiki/workflow/WorkflowManager.java
@@ -18,14 +18,13 @@
  */
 package org.apache.wiki.workflow;
 
-import org.apache.wiki.api.core.Engine;
 import org.apache.wiki.api.core.Session;
+import org.apache.wiki.api.engine.Initializable;
 import org.apache.wiki.api.exceptions.WikiException;
 import org.apache.wiki.event.WikiEventListener;
 
 import java.security.Principal;
 import java.util.List;
-import java.util.Properties;
 import java.util.Set;
 
 
@@ -35,7 +34,7 @@
  * particular Workflows.
  * </p>
  */
-public interface WorkflowManager extends WikiEventListener {
+public interface WorkflowManager extends WikiEventListener, Initializable {
 
     /** The workflow attribute which stores the wikiContext. */
     String WF_WP_SAVE_ATTR_PRESAVE_WIKI_CONTEXT = "wikiContext";
@@ -98,19 +97,6 @@
     List< Workflow > getCompletedWorkflows();
 
     /**
-     * Initializes the WorkflowManager using a specfied Engine and properties. Any properties that begin with
-     * {@link #PROPERTY_APPROVER_PREFIX} will be assumed to be Decisions that require approval. For a given property key, everything
-     * after the prefix denotes the Decision's message key. The property value indicates the Principal (Role, GroupPrincipal, WikiPrincipal)
-     * that must approve the Decision. For example, if the property key/value pair is {@code jspwiki.approver.workflow.saveWikiPage=Admin},
-     * the Decision's message key is <code>workflow.saveWikiPage</code>. The Principal <code>Admin</code> will be resolved via
-     * {@link org.apache.wiki.auth.AuthorizationManager#resolvePrincipal(String)}.
-     *
-     * @param engine the wiki engine to associate with this WorkflowManager
-     * @param props the wiki engine's properties
-     */
-    void initialize( Engine engine, Properties props );
-
-    /**
      * Returns <code>true</code> if a workflow matching a particular key contains an approval step.
      *
      * @param messageKey the name of the workflow; corresponds to the value returned by {@link Workflow#getMessageKey()}.
