diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/JetCoreEnvironment.java b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/JetCoreEnvironment.java
index e10bba89c98..4351d303f33 100644
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/JetCoreEnvironment.java
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/JetCoreEnvironment.java
@@ -56,8 +56,6 @@ import kotlin.Function1;
 import kotlin.Unit;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.TestOnly;
-import org.jetbrains.jet.lang.resolve.android.AndroidUIXmlParser;
-import org.jetbrains.jet.lang.resolve.android.CliAndroidUIXmlParser;
 import org.jetbrains.kotlin.asJava.JavaElementFinder;
 import org.jetbrains.kotlin.asJava.KotlinLightClassForPackage;
 import org.jetbrains.kotlin.asJava.LightClassGenerationSupport;
@@ -66,6 +64,7 @@ import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation;
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity;
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector;
 import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
+import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar;
 import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.idea.JetFileType;
@@ -295,10 +294,12 @@ public class JetCoreEnvironment {
                 configuration.getList(CommonConfigurationKeys.SCRIPT_DEFINITIONS_KEY)
         );
 
-        String androidResPath = configuration.get(JVMConfigurationKeys.ANDROID_RES_PATH);
-        String androidManifest = configuration.get(JVMConfigurationKeys.ANDROID_MANIFEST);
-        project.registerService(AndroidUIXmlProcessor.class, new CliAndroidUIXmlProcessor(project, androidResPath, androidManifest));
         project.registerService(VirtualFileFinderFactory.class, new CliVirtualFileFinderFactory(classPath));
+
+        for (ComponentRegistrar registrar : configuration.getList(ComponentRegistrar.PLUGIN_COMPONENT_REGISTRARS)) {
+            registrar.registerProjectComponents(project, configuration);
+
+        }
     }
 
     private static void registerProjectExtensionPoints(ExtensionsArea area) {
diff --git a/compiler/plugin-api/src/org/jetbrains/jet/config/CompilerConfiguration.java b/compiler/plugin-api/src/org/jetbrains/jet/config/CompilerConfiguration.java
new file mode 100644
index 00000000000..35a0db766d5
--- /dev/null
+++ b/compiler/plugin-api/src/org/jetbrains/jet/config/CompilerConfiguration.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright 2010-2013 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.config;
+
+import com.intellij.openapi.util.Key;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class CompilerConfiguration {
+    private final Map<Key, Object> map = new HashMap<Key, Object>();
+    private boolean readOnly = false;
+
+    @Nullable
+    public <T> T get(@NotNull CompilerConfigurationKey<T> key) {
+        T data = (T) map.get(key.ideaKey);
+        return data == null ? null : unmodifiable(data);
+    }
+
+    @NotNull
+    public <T> T get(@NotNull CompilerConfigurationKey<T> key, @NotNull T defaultValue) {
+        T data = (T) map.get(key.ideaKey);
+        return data == null ? defaultValue : unmodifiable(data);
+    }
+
+    @NotNull
+    public <T> List<T> getList(@NotNull CompilerConfigurationKey<List<T>> key) {
+        List<T> data = (List<T>) map.get(key.ideaKey);
+        if (data == null) {
+            return Collections.emptyList();
+        }
+        else {
+            return Collections.unmodifiableList(data);
+        }
+    }
+
+    public <T> void put(@NotNull CompilerConfigurationKey<T> key, @Nullable T value) {
+        checkReadOnly();
+        map.put(key.ideaKey, value);
+    }
+
+    public <T> void add(@NotNull CompilerConfigurationKey<List<T>> key, @NotNull T value) {
+        checkReadOnly();
+        Key<List<T>> ideaKey = key.ideaKey;
+        if (map.get(ideaKey) == null) {
+            map.put(ideaKey, new ArrayList<T>());
+        }
+        List<T> list = (List<T>) map.get(ideaKey);
+        list.add(value);
+    }
+
+    public <T> void addAll(@NotNull CompilerConfigurationKey<List<T>> key, @NotNull Collection<T> values) {
+        checkReadOnly();
+        checkForNullElements(values);
+        Key<List<T>> ideaKey = key.ideaKey;
+        if (map.get(ideaKey) == null) {
+            map.put(ideaKey, new ArrayList<T>());
+        }
+        List<T> list = (List<T>) map.get(ideaKey);
+        list.addAll(values);
+    }
+
+    public CompilerConfiguration copy() {
+        CompilerConfiguration copy = new CompilerConfiguration();
+        copy.map.putAll(map);
+        return copy;
+    }
+
+    private void checkReadOnly() {
+        if (readOnly) {
+            throw new IllegalStateException("CompilerConfiguration is read-only");
+        }
+    }
+
+    public void setReadOnly(boolean readOnly) {
+        if (readOnly != this.readOnly) {
+            checkReadOnly();
+            this.readOnly = readOnly;
+        }
+    }
+
+    @NotNull
+    private static <T> T unmodifiable(@NotNull T object) {
+        if (object instanceof List) {
+            return (T) Collections.unmodifiableList((List) object);
+        }
+        else if (object instanceof Map) {
+            return (T) Collections.unmodifiableMap((Map) object);
+        }
+        else if (object instanceof Collection) {
+            return (T) Collections.unmodifiableCollection((Collection) object);
+        }
+        else {
+            return object;
+        }
+    }
+
+    @Override
+    public String toString() {
+        return map.toString();
+    }
+
+    private static <T> void checkForNullElements(Collection<T> values) {
+        int index = 0;
+        for (T value : values) {
+            if (value == null) {
+                throw new IllegalArgumentException("Element " + index
+                                                   + " is null, while null values in compiler configuration are not allowed");
+            }
+            index++;
+        }
+    }
+}
diff --git a/compiler/plugin-api/src/org/jetbrains/jet/config/CompilerConfigurationKey.java b/compiler/plugin-api/src/org/jetbrains/jet/config/CompilerConfigurationKey.java
new file mode 100644
index 00000000000..393c89a9ffb
--- /dev/null
+++ b/compiler/plugin-api/src/org/jetbrains/jet/config/CompilerConfigurationKey.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2010-2013 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.config;
+
+import com.intellij.openapi.util.Key;
+import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.NotNull;
+
+public class CompilerConfigurationKey<T> {
+    Key<T> ideaKey;
+
+    private CompilerConfigurationKey(@NotNull @NonNls String name) {
+        ideaKey = Key.create(name);
+    }
+
+    @NotNull
+    public static <T> CompilerConfigurationKey<T> create(@NotNull @NonNls String name) {
+        return new CompilerConfigurationKey<T>(name);
+    }
+}
diff --git a/compiler/plugin-api/src/org/jetbrains/kotlin/compiler/plugin/ComponentRegistrar.kt b/compiler/plugin-api/src/org/jetbrains/kotlin/compiler/plugin/ComponentRegistrar.kt
new file mode 100644
index 00000000000..e9e8ec8e629
--- /dev/null
+++ b/compiler/plugin-api/src/org/jetbrains/kotlin/compiler/plugin/ComponentRegistrar.kt
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2010-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.compiler.plugin
+
+import org.jetbrains.jet.config.CompilerConfigurationKey
+import org.jetbrains.jet.config.CompilerConfiguration
+import com.intellij.mock.MockProject
+
+public trait ComponentRegistrar {
+    class object {
+        public val PLUGIN_COMPONENT_REGISTRARS: CompilerConfigurationKey<MutableList<ComponentRegistrar>> = CompilerConfigurationKey.create("plugin component registrars")
+    }
+
+    public fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration)
+}