diff --git a/idea/src/org/jetbrains/jet/plugin/run/JetRunConfiguration.java b/idea/src/org/jetbrains/jet/plugin/run/JetRunConfiguration.java
index b9e2adc1c94..0aa71ffcd12 100644
--- a/idea/src/org/jetbrains/jet/plugin/run/JetRunConfiguration.java
+++ b/idea/src/org/jetbrains/jet/plugin/run/JetRunConfiguration.java
@@ -26,12 +26,11 @@ import com.intellij.openapi.components.PathMacroManager;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.module.ModuleManager;
 import com.intellij.openapi.options.SettingsEditor;
-import com.intellij.openapi.util.DefaultJDOMExternalizer;
 import com.intellij.openapi.util.InvalidDataException;
 import com.intellij.openapi.util.WriteExternalException;
+import com.intellij.util.xmlb.XmlSerializer;
 import org.jdom.Element;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.resolve.FqName;
 
 import java.util.Arrays;
 import java.util.Collection;
@@ -41,14 +40,14 @@ import java.util.Map;
 /**
  * @author yole
  */
-public class JetRunConfiguration extends ModuleBasedConfiguration<RunConfigurationModule> implements CommonJavaRunConfigurationParameters {
-    public FqName MAIN_CLASS_NAME;
-    public String VM_PARAMETERS;
-    public String PROGRAM_PARAMETERS;
-    public String WORKING_DIRECTORY;
+public class JetRunConfiguration extends ModuleBasedConfiguration<RunConfigurationModule>
+    implements CommonJavaRunConfigurationParameters {
+
+    private JetRunConfigurationSettings settings = new JetRunConfigurationSettings();
+
     public boolean ALTERNATIVE_JRE_PATH_ENABLED;
     public String ALTERNATIVE_JRE_PATH;
-    private Map<String,String> myEnvs = new LinkedHashMap<String, String>();
+    private Map<String, String> myEnvs = new LinkedHashMap<String, String>();
     public boolean PASS_PARENT_ENVS = true;
 
     public JetRunConfiguration(String name, RunConfigurationModule runConfigurationModule, ConfigurationFactory factory) {
@@ -71,69 +70,94 @@ public class JetRunConfiguration extends ModuleBasedConfiguration<RunConfigurati
         return new JetRunConfigurationEditor(getProject());
     }
 
+    @Override
     public void readExternal(final Element element) throws InvalidDataException {
         PathMacroManager.getInstance(getProject()).expandPaths(element);
         super.readExternal(element);
 
         JavaRunConfigurationExtensionManager.getInstance().readExternal(this, element);
-        DefaultJDOMExternalizer.readExternal(this, element);
         readModule(element);
         EnvironmentVariablesComponent.readExternal(element, getEnvs());
+
+        Element settingsElement = element.getChild(JetRunConfigurationSettings.class.getSimpleName());
+        if (settingsElement != null) {
+            JetRunConfigurationSettings readSettings = XmlSerializer.deserialize(settingsElement, JetRunConfigurationSettings.class);
+            if (readSettings != null) {
+                settings = readSettings;
+            }
+        }
     }
 
+    @Override
     public void writeExternal(final Element element) throws WriteExternalException {
         super.writeExternal(element);
         JavaRunConfigurationExtensionManager.getInstance().writeExternal(this, element);
-        DefaultJDOMExternalizer.writeExternal(this, element);
+
         writeModule(element);
         EnvironmentVariablesComponent.writeExternal(element, getEnvs());
         PathMacroManager.getInstance(getProject()).collapsePathsRecursively(element);
+
+        element.addContent(XmlSerializer.serialize(settings()));
     }
 
+    @Override
     public void setVMParameters(String value) {
-      VM_PARAMETERS = value;
+        settings().setVmParameters(value);
     }
 
+    @Override
     public String getVMParameters() {
-      return VM_PARAMETERS;
+        return settings().getVmParameters();
     }
 
+    @Override
     public void setProgramParameters(String value) {
-      PROGRAM_PARAMETERS = value;
+        settings().setProgramParameters(value);
     }
 
+    @Override
     public String getProgramParameters() {
-      return PROGRAM_PARAMETERS;
+        return settings().getProgramParameters();
     }
 
+    @Override
     public void setWorkingDirectory(String value) {
-      WORKING_DIRECTORY = ExternalizablePath.urlValue(value);
+        settings().setWorkingDirectory(ExternalizablePath.urlValue(value));
     }
 
+    @Override
     public String getWorkingDirectory() {
-      return ExternalizablePath.localPathValue(WORKING_DIRECTORY);
+        return ExternalizablePath.localPathValue(settings().getWorkingDirectory());
     }
 
+    @Override
     public void setPassParentEnvs(boolean passParentEnvs) {
-      PASS_PARENT_ENVS = passParentEnvs;
+        PASS_PARENT_ENVS = passParentEnvs;
     }
 
+    @Override
     @NotNull
     public Map<String, String> getEnvs() {
-      return myEnvs;
+        return myEnvs;
     }
 
+    @Override
     public void setEnvs(@NotNull final Map<String, String> envs) {
-      this.myEnvs = envs;
+        this.myEnvs = envs;
     }
 
+    @Override
     public boolean isPassParentEnvs() {
-      return PASS_PARENT_ENVS;
+        return PASS_PARENT_ENVS;
     }
 
     @Override
     public String getRunClass() {
-        return MAIN_CLASS_NAME.getFqName();
+        return settings().getMainClassName();
+    }
+
+    public void setRunClass(String value) {
+        settings().setMainClassName(value);
     }
 
     @Override
@@ -141,24 +165,34 @@ public class JetRunConfiguration extends ModuleBasedConfiguration<RunConfigurati
         return null;
     }
 
+    @Override
     public boolean isAlternativeJrePathEnabled() {
-       return ALTERNATIVE_JRE_PATH_ENABLED;
-     }
-
-     public void setAlternativeJrePathEnabled(boolean enabled) {
-       ALTERNATIVE_JRE_PATH_ENABLED = enabled;
-     }
-
-     public String getAlternativeJrePath() {
-       return ALTERNATIVE_JRE_PATH;
-     }
-
-     public void setAlternativeJrePath(String path) {
-       ALTERNATIVE_JRE_PATH = path;
-     }
+        return ALTERNATIVE_JRE_PATH_ENABLED;
+    }
 
     @Override
-    public RunProfileState getState(@NotNull Executor executor, @NotNull ExecutionEnvironment executionEnvironment) throws ExecutionException {
+    public void setAlternativeJrePathEnabled(boolean enabled) {
+        ALTERNATIVE_JRE_PATH_ENABLED = enabled;
+    }
+
+    @Override
+    public String getAlternativeJrePath() {
+        return ALTERNATIVE_JRE_PATH;
+    }
+
+    @Override
+    public void setAlternativeJrePath(String path) {
+        ALTERNATIVE_JRE_PATH = path;
+    }
+
+    @NotNull
+    public JetRunConfigurationSettings settings() {
+        return settings;
+    }
+
+    @Override
+    public RunProfileState getState(@NotNull Executor executor, @NotNull ExecutionEnvironment executionEnvironment)
+        throws ExecutionException {
         final JavaCommandLineState state = new MyJavaCommandLineState(this, executionEnvironment);
         state.setConsoleBuilder(TextConsoleBuilderFactory.getInstance().createBuilder(getProject()));
         return state;
@@ -169,24 +203,27 @@ public class JetRunConfiguration extends ModuleBasedConfiguration<RunConfigurati
         private final JetRunConfiguration myConfiguration;
 
         public MyJavaCommandLineState(@NotNull final JetRunConfiguration configuration,
-                                               final ExecutionEnvironment environment) {
+                                      final ExecutionEnvironment environment) {
             super(environment);
             myConfiguration = configuration;
         }
 
+        @Override
         protected JavaParameters createJavaParameters() throws ExecutionException {
             final JavaParameters params = new JavaParameters();
             final RunConfigurationModule module = myConfiguration.getConfigurationModule();
 
-            final int classPathType = JavaParametersUtil.getClasspathType(module,
-                                                                          myConfiguration.MAIN_CLASS_NAME.getFqName(),
-                                                                          false);
+            final int classPathType = JavaParametersUtil.getClasspathType(
+                    module,
+                    myConfiguration.settings().getMainClassName(),
+                    false);
+
             final String jreHome = myConfiguration.ALTERNATIVE_JRE_PATH_ENABLED ? myConfiguration.ALTERNATIVE_JRE_PATH
                                                                                 : null;
             JavaParametersUtil.configureModule(module, params, classPathType, jreHome);
             JavaParametersUtil.configureConfiguration(params, myConfiguration);
 
-            params.setMainClass(myConfiguration.MAIN_CLASS_NAME.getFqName());
+            params.setMainClass(myConfiguration.settings().getMainClassName());
 
             return params;
         }
diff --git a/idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationEditor.java b/idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationEditor.java
index 2ef4f2acf48..1a0165f4a92 100644
--- a/idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationEditor.java
+++ b/idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationEditor.java
@@ -23,7 +23,6 @@ import com.intellij.openapi.options.SettingsEditor;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.ui.LabeledComponent;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.resolve.FqName;
 
 import javax.swing.*;
 import java.awt.*;
@@ -46,6 +45,7 @@ public class JetRunConfigurationEditor extends SettingsEditor<JetRunConfiguratio
         myModuleSelector = new ConfigurationModuleSelector(project, moduleChooser.getComponent());
         myCommonProgramParameters.setModuleContext(myModuleSelector.getModule());
         moduleChooser.getComponent().addActionListener(new ActionListener() {
+            @Override
             public void actionPerformed(ActionEvent e) {
                 myCommonProgramParameters.setModuleContext(myModuleSelector.getModule());
             }
@@ -55,7 +55,7 @@ public class JetRunConfigurationEditor extends SettingsEditor<JetRunConfiguratio
     @Override
     protected void resetEditorFrom(JetRunConfiguration configuration) {
         myCommonProgramParameters.reset(configuration);
-        myMainClassField.setText(configuration.MAIN_CLASS_NAME == null ? null : configuration.MAIN_CLASS_NAME.getFqName());
+        myMainClassField.setText(configuration.getRunClass() == null ? null : configuration.getRunClass());
         myModuleSelector.reset(configuration);
     }
 
@@ -63,7 +63,7 @@ public class JetRunConfigurationEditor extends SettingsEditor<JetRunConfiguratio
     protected void applyEditorTo(JetRunConfiguration configuration) throws ConfigurationException {
         myModuleSelector.applyTo(configuration);
         myCommonProgramParameters.applyTo(configuration);
-        configuration.MAIN_CLASS_NAME = new FqName(myMainClassField.getText());
+        configuration.setRunClass(myMainClassField.getText());
     }
 
     @NotNull
diff --git a/idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationProducer.java b/idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationProducer.java
index 267bf370fa2..e1e772f448b 100644
--- a/idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationProducer.java
+++ b/idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationProducer.java
@@ -78,7 +78,7 @@ public class JetRunConfigurationProducer extends RuntimeConfigurationProducer im
         JetRunConfiguration configuration = (JetRunConfiguration) settings.getConfiguration();
         configuration.setModule(module);
         configuration.setName(StringUtil.trimEnd(fqName.getFqName(), "." + JvmAbi.PACKAGE_CLASS));
-        configuration.MAIN_CLASS_NAME = fqName;
+        configuration.setRunClass(fqName.getFqName());
         return settings;
     }
 
diff --git a/idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationSettings.java b/idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationSettings.java
new file mode 100644
index 00000000000..c7aec401225
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationSettings.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2010-2012 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.plugin.run;
+
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Should be serializable.
+ *
+ * @author Nikolay Krasko
+ */
+public class JetRunConfigurationSettings {
+    public static String DEFAULT_MAIN_CLASS_NAME = "";
+    public static String DEFAULT_VM_PARAMETERS = "";
+    public static String DEFAULT_PROGRAM_PARAMETERS = "";
+    public static String DEFAULT_WORKING_DIRECTORY = "";
+
+    @Nullable
+    private String mainClassName = DEFAULT_MAIN_CLASS_NAME;
+
+    @Nullable
+    private String vmParameters = DEFAULT_VM_PARAMETERS;
+
+    @Nullable
+    private String programParameters = DEFAULT_PROGRAM_PARAMETERS;
+
+    @Nullable
+    private String workingDirectory = DEFAULT_WORKING_DIRECTORY;
+
+    @Nullable
+    public String getMainClassName() {
+        return mainClassName;
+    }
+
+    public void setMainClassName(@Nullable String mainClassName) {
+        this.mainClassName = mainClassName;
+    }
+
+    @Nullable
+    public String getVmParameters() {
+        return vmParameters;
+    }
+
+    public void setVmParameters(@Nullable String vmParameters) {
+        this.vmParameters = vmParameters;
+    }
+
+    @Nullable
+    public String getProgramParameters() {
+        return programParameters;
+    }
+
+    public void setProgramParameters(@Nullable String programParameters) {
+        this.programParameters = programParameters;
+    }
+
+    @Nullable
+    public String getWorkingDirectory() {
+        return workingDirectory;
+    }
+
+    public void setWorkingDirectory(@Nullable String workingDirectory) {
+        this.workingDirectory = workingDirectory;
+    }
+}