diff --git a/python/edu/learn-python/gen/icons/StudyIcons.java b/python/edu/learn-python/gen/icons/StudyIcons.java
new file mode 100644
index 0000000..2840910
--- /dev/null
+++ b/python/edu/learn-python/gen/icons/StudyIcons.java
@@ -0,0 +1,29 @@
+package icons;
+
+import com.intellij.openapi.util.IconLoader;
+
+import javax.swing.*;
+
+/**
+ * NOTE THIS FILE IS AUTO-GENERATED
+ * DO NOT EDIT IT BY HAND, run build/scripts/icons.gant instead
+ */
+public class StudyIcons {
+  private static Icon load(String path) {
+    return IconLoader.getIcon(path, StudyIcons.class);
+  }
+
+  public static final Icon Add = load("/icons/com/jetbrains/python/edu/add.png"); // 16x16
+  public static final Icon Checked = load("/icons/com/jetbrains/python/edu/checked.png"); // 32x32
+  public static final Icon Failed = load("/icons/com/jetbrains/python/edu/failed.png"); // 32x32
+  public static final Icon Next = load("/icons/com/jetbrains/python/edu/next.png"); // 24x24
+  public static final Icon Playground = load("/icons/com/jetbrains/python/edu/playground.png"); // 32x28
+  public static final Icon Prev = load("/icons/com/jetbrains/python/edu/prev.png"); // 24x24
+  public static final Icon Refresh = load("/icons/com/jetbrains/python/edu/refresh.png"); // 16x16
+  public static final Icon Refresh24 = load("/icons/com/jetbrains/python/edu/refresh24.png"); // 24x24
+  public static final Icon Resolve = load("/icons/com/jetbrains/python/edu/resolve.png"); // 24x24
+  public static final Icon Run = load("/icons/com/jetbrains/python/edu/Run.png"); // 24x24
+  public static final Icon ShowHint = load("/icons/com/jetbrains/python/edu/showHint.png"); // 24x24
+  public static final Icon Unchecked = load("/icons/com/jetbrains/python/edu/unchecked.png"); // 32x32
+  public static final Icon WatchInput = load("/icons/com/jetbrains/python/edu/WatchInput.png"); // 24x24
+}
diff --git a/python/edu/learn-python/learn-python.iml b/python/edu/learn-python/learn-python.iml
new file mode 100644
index 0000000..bd539d1
--- /dev/null
+++ b/python/edu/learn-python/learn-python.iml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/tests" isTestSource="true" />
+      <sourceFolder url="file://$MODULE_DIR$/gen" isTestSource="false" generated="true" />
+      <sourceFolder url="file://$MODULE_DIR$/resources" type="java-resource" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="module" module-name="platform-impl" />
+    <orderEntry type="module" module-name="python-community" />
+    <orderEntry type="module" module-name="lang-impl" />
+    <orderEntry type="library" name="gson" level="project" />
+    <orderEntry type="library" name="JUnit4" level="project" />
+  </component>
+</module>
+
diff --git a/python/edu/learn-python/resources/META-INF/plugin.xml b/python/edu/learn-python/resources/META-INF/plugin.xml
new file mode 100644
index 0000000..ec828eb
--- /dev/null
+++ b/python/edu/learn-python/resources/META-INF/plugin.xml
@@ -0,0 +1,73 @@
+<!--suppress XmlUnboundNsPrefix -->
+<idea-plugin version="2">
+  <id>com.jetbrains.python.edu.learn-python</id>
+  <name>Educational plugin for PyCharm</name>
+  <version>1.0</version>
+  <vendor email="support@yourcompany.com" url="http://www.yourcompany.com">YourCompany</vendor>
+
+  <description><![CDATA[
+
+      ]]></description>
+
+  <change-notes><![CDATA[
+
+      ]]>
+  </change-notes>
+
+  <!--depends>com.intellij.modules.python</depends-->
+
+  <!-- please see http://confluence.jetbrains.net/display/IDEADEV/Plugin+Compatibility+with+IntelliJ+Platform+Products
+       on how to target different products -->
+
+  <depends>com.intellij.modules.lang</depends>
+  <depends>com.intellij.modules.python</depends>
+  <application-components>
+  </application-components>
+
+  <project-components>
+    <component>
+      <implementation-class>com.jetbrains.python.edu.StudyTaskManager</implementation-class>
+      <interface-class>com.jetbrains.python.edu.StudyTaskManager</interface-class>
+    </component>
+  </project-components>
+
+  <application-components>
+    <component>
+      <implementation-class>com.jetbrains.python.edu.StudyInitialConfigurator</implementation-class>
+      <headless-implementation-class/>
+    </component>
+  </application-components>
+
+  <actions>
+    <action id="CheckAction" class="com.jetbrains.python.edu.actions.StudyCheckAction" text="check"
+            description="Runs tests for current tasks" icon="/icons/icon.jpg">
+    </action>
+    <action id="PrevWindowAction" class="com.jetbrains.python.edu.actions.StudyPrevWindowAction" text="PrevWindowAction" description="prev">
+    </action>
+
+    <action id="NextWindow" class="com.jetbrains.python.edu.actions.StudyNextWindowAction" text="NextWindowAction" description="next">
+    </action>
+    <action id="NextTaskAction" class="com.jetbrains.python.edu.actions.StudyNextStudyTaskAction" text="NextTaskAction" description="Next Task"/>
+    <action id="PreviousTaskAction" class="com.jetbrains.python.edu.actions.StudyPreviousStudyTaskAction" text="PreviousTaskAction"
+            description="Previous Task"/>
+    <action id="RefreshTaskAction" class="com.jetbrains.python.edu.actions.StudyRefreshTaskAction" text="RefreshTaskAction"
+            description="Refresh current task"/>
+    <action id="WatchInputAction" class="com.jetbrains.python.edu.actions.StudyEditInputAction" text="WatchInputAction"
+            description="watch input"/>
+    <action id="StudyRunAction" class="com.jetbrains.python.edu.actions.StudyRunAction" text="StudyRunAction" description="run your code"/>
+    <action id="ShowHintAction" class="com.jetbrains.python.edu.actions.StudyShowHintAction" text="Show hint"
+            description="show hint">
+      <add-to-group group-id="MainToolBar" anchor="last"/>
+    </action>
+  </actions>
+
+  <extensions defaultExtensionNs="com.intellij">
+    <toolWindow id="Course Description" anchor="right" factoryClass="com.jetbrains.python.edu.ui.StudyToolWindowFactory" conditionClass="com.jetbrains.python.edu.ui.StudyCondition"/>
+    <fileEditorProvider implementation="com.jetbrains.python.edu.editor.StudyFileEditorProvider"/>
+    <directoryProjectGenerator implementation="com.jetbrains.python.edu.StudyDirectoryProjectGenerator"/>
+    <treeStructureProvider implementation="com.jetbrains.python.edu.projectView.StudyTreeStructureProvider"/>
+    <highlightErrorFilter implementation="com.jetbrains.python.edu.StudyHighlightErrorFilter"/>
+    <applicationService serviceInterface="com.intellij.openapi.fileEditor.impl.EditorEmptyTextPainter"
+        serviceImplementation="com.jetbrains.python.edu.StudyInstructionPainter" overrides="true"/>
+  </extensions>
+</idea-plugin>
\ No newline at end of file
diff --git a/python/edu/learn-python/resources/com/jetbrains/python/edu/user_tester.py b/python/edu/learn-python/resources/com/jetbrains/python/edu/user_tester.py
new file mode 100644
index 0000000..c17e6cd
--- /dev/null
+++ b/python/edu/learn-python/resources/com/jetbrains/python/edu/user_tester.py
@@ -0,0 +1,58 @@
+import sys
+import imp
+import os
+import subprocess
+
+USER_TESTS = "userTests"
+
+TEST_FAILED = "FAILED"
+
+TEST_PASSED = "PASSED"
+
+INPUT = "input"
+OUTPUT = "output"
+
+
+def get_index(logical_name, full_name):
+    logical_name_len = len(logical_name)
+    if full_name[:logical_name_len] == logical_name:
+        return int(full_name[logical_name_len])
+    return -1
+
+
+def process_user_tests(file_path):
+    user_tests = []
+    imp.load_source('user_file', file_path)
+    user_tests_dir_path = os.path.abspath(os.path.join(file_path, os.pardir, USER_TESTS))
+    user_test_files = os.listdir(user_tests_dir_path)
+    for user_file in user_test_files:
+        index = get_index(INPUT, user_file)
+        if index == -1:
+            continue
+        output = OUTPUT + str(index)
+        if output in user_test_files:
+            input_path = os.path.abspath(os.path.join(user_tests_dir_path, user_file))
+            output_path = os.path.abspath(os.path.join(user_tests_dir_path, output))
+            user_tests.append((input_path, output_path, index))
+    return sorted(user_tests, key=(lambda x: x[2]))
+
+
+def run_user_test(python, executable_path):
+    user_tests = process_user_tests(executable_path)
+    for test in user_tests:
+        input, output, index = test
+        test_output = subprocess.check_output([python, executable_path, input])
+        expected_output = open(output).read()
+        test_status = TEST_PASSED if test_output == expected_output else TEST_FAILED
+        print "TEST" + str(index) + " " + test_status
+        print "OUTPUT:"
+        print test_output + "\n"
+        if test_status == TEST_FAILED:
+            print "EXPECTED OUTPUT:"
+            print expected_output + "\n"
+
+
+if __name__ == "__main__":
+    python = sys.argv[1]
+    executable_path = sys.argv[2]
+    run_user_test(python , executable_path)
\ No newline at end of file
diff --git a/python/edu/learn-python/resources/courses/introduction_course.zip b/python/edu/learn-python/resources/courses/introduction_course.zip
new file mode 100644
index 0000000..f3b24f2
--- /dev/null
+++ b/python/edu/learn-python/resources/courses/introduction_course.zip
Binary files differ
diff --git a/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/Run.png b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/Run.png
new file mode 100644
index 0000000..27a6e36
--- /dev/null
+++ b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/Run.png
Binary files differ
diff --git a/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/WatchInput.png b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/WatchInput.png
new file mode 100644
index 0000000..4992191
--- /dev/null
+++ b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/WatchInput.png
Binary files differ
diff --git a/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/add.png b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/add.png
new file mode 100644
index 0000000..9494f2d
--- /dev/null
+++ b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/add.png
Binary files differ
diff --git a/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/checked.png b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/checked.png
new file mode 100644
index 0000000..4105a01
--- /dev/null
+++ b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/checked.png
Binary files differ
diff --git a/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/failed.png b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/failed.png
new file mode 100644
index 0000000..e2aaa55
--- /dev/null
+++ b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/failed.png
Binary files differ
diff --git a/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/icon.jpg b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/icon.jpg
new file mode 100644
index 0000000..3a9716e
--- /dev/null
+++ b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/icon.jpg
Binary files differ
diff --git a/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/next.png b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/next.png
new file mode 100644
index 0000000..dd1a5d9
--- /dev/null
+++ b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/next.png
Binary files differ
diff --git a/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/playground.png b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/playground.png
new file mode 100644
index 0000000..d12a751
--- /dev/null
+++ b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/playground.png
Binary files differ
diff --git a/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/prev.png b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/prev.png
new file mode 100644
index 0000000..0656f81
--- /dev/null
+++ b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/prev.png
Binary files differ
diff --git a/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/refresh.png b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/refresh.png
new file mode 100644
index 0000000..d595f6b
--- /dev/null
+++ b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/refresh.png
Binary files differ
diff --git a/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/refresh24.png b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/refresh24.png
new file mode 100644
index 0000000..218f075
--- /dev/null
+++ b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/refresh24.png
Binary files differ
diff --git a/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/resolve.png b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/resolve.png
new file mode 100644
index 0000000..7ef960b
--- /dev/null
+++ b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/resolve.png
Binary files differ
diff --git a/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/resolve_dark.png b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/resolve_dark.png
new file mode 100644
index 0000000..99aaa1d
--- /dev/null
+++ b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/resolve_dark.png
Binary files differ
diff --git a/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/showHint.png b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/showHint.png
new file mode 100644
index 0000000..f10fd56
--- /dev/null
+++ b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/showHint.png
Binary files differ
diff --git a/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/unchecked.png b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/unchecked.png
new file mode 100644
index 0000000..2145982
--- /dev/null
+++ b/python/edu/learn-python/resources/icons/com/jetbrains/python/edu/unchecked.png
Binary files differ
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/StudyDirectoryProjectGenerator.java b/python/edu/learn-python/src/com/jetbrains/python/edu/StudyDirectoryProjectGenerator.java
new file mode 100644
index 0000000..d4831d9
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/StudyDirectoryProjectGenerator.java
@@ -0,0 +1,393 @@
+package com.jetbrains.python.edu;
+
+import com.google.gson.*;
+import com.google.gson.stream.JsonReader;
+import com.intellij.facet.ui.FacetEditorValidator;
+import com.intellij.facet.ui.FacetValidatorsManager;
+import com.intellij.facet.ui.ValidationResult;
+import com.intellij.lang.javascript.boilerplate.GithubDownloadUtil;
+import com.intellij.openapi.application.PathManager;
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.progress.ProcessCanceledException;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.vfs.VirtualFileManager;
+import com.intellij.platform.DirectoryProjectGenerator;
+import com.intellij.platform.templates.github.GeneratorException;
+import com.intellij.platform.templates.github.ZipUtil;
+import com.jetbrains.python.edu.course.Course;
+import com.jetbrains.python.edu.course.CourseInfo;
+import com.jetbrains.python.edu.ui.StudyNewProjectPanel;
+import com.jetbrains.python.newProject.PythonProjectGenerator;
+import icons.StudyIcons;
+import org.jetbrains.annotations.Nls;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import javax.swing.*;
+import java.io.*;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+
+public class StudyDirectoryProjectGenerator extends PythonProjectGenerator implements DirectoryProjectGenerator {
+  private static final Logger LOG = Logger.getInstance(StudyDirectoryProjectGenerator.class.getName());
+  private static final String REPO_URL = "https://github.com/JetBrains/pycharm-courses/archive/master.zip";
+  private static final String USER_NAME = "PyCharm";
+  private static final String COURSE_META_FILE = "course.json";
+  private static final String COURSE_NAME_ATTRIBUTE = "name";
+  private static final Pattern CACHE_PATTERN = Pattern.compile("(name=(.*)) (path=(.*course.json)) (author=(.*)) (description=(.*))");
+  private static final String REPOSITORY_NAME = "pycharm-courses";
+  public static final String AUTHOR_ATTRIBUTE = "author";
+  private final File myCoursesDir = new File(PathManager.getConfigPath(), "courses");
+  private static final String CACHE_NAME = "courseNames.txt";
+  private Map<CourseInfo, File> myCourses = new HashMap<CourseInfo, File>();
+  private File mySelectedCourseFile;
+  private Project myProject;
+  public ValidationResult myValidationResult = new ValidationResult("selected course is not valid");
+
+  @Nls
+  @NotNull
+  @Override
+  public String getName() {
+    return "Study project";
+  }
+
+
+  public void setCourses(Map<CourseInfo, File> courses) {
+    myCourses = courses;
+  }
+
+  /**
+   * Finds selected course in courses by name.
+   *
+   * @param courseName name of selected course
+   */
+  public void setSelectedCourse(@NotNull CourseInfo courseName) {
+    File courseFile = myCourses.get(courseName);
+    if (courseFile == null) {
+      LOG.error("invalid course in list");
+    }
+    mySelectedCourseFile = courseFile;
+  }
+
+  /**
+   * Adds course to courses specified in params
+   *
+   * @param courseDir must be directory containing course file
+   * @return added course name or null if course is invalid
+   */
+  @Nullable
+  private static CourseInfo addCourse(Map<CourseInfo, File> courses, File courseDir) {
+    if (courseDir.isDirectory()) {
+      File[] courseFiles = courseDir.listFiles(new FilenameFilter() {
+        @Override
+        public boolean accept(File dir, String name) {
+          return name.equals(COURSE_META_FILE);
+        }
+      });
+      if (courseFiles.length != 1) {
+        LOG.info("User tried to add course with more than one or without course files");
+        return null;
+      }
+      File courseFile = courseFiles[0];
+      CourseInfo courseInfo = getCourseInfo(courseFile);
+      if (courseInfo != null) {
+        courses.put(courseInfo, courseFile);
+      }
+      return courseInfo;
+    }
+    return null;
+  }
+
+
+  /**
+   * Adds course from zip archive to courses
+   *
+   * @return added course name or null if course is invalid
+   */
+  @Nullable
+  public CourseInfo addLocalCourse(String zipFilePath) {
+    File file = new File(zipFilePath);
+    try {
+      String fileName = file.getName();
+      String unzippedName = fileName.substring(0, fileName.indexOf("."));
+      File courseDir = new File(myCoursesDir, unzippedName);
+      ZipUtil.unzip(null, courseDir, file, null, null, true);
+      CourseInfo courseName = addCourse(myCourses, courseDir);
+      flushCache();
+      return courseName;
+    }
+    catch (IOException e) {
+      LOG.error("Failed to unzip course archive");
+      LOG.error(e);
+    }
+    return null;
+  }
+
+  @Nullable
+  @Override
+  public Object showGenerationSettings(VirtualFile baseDir) throws ProcessCanceledException {
+    return null;
+  }
+
+  @Nullable
+  @Override
+  public Icon getLogo() {
+    return StudyIcons.Playground;
+  }
+
+
+  @Override
+  public void generateProject(@NotNull final Project project, @NotNull final VirtualFile baseDir,
+                              @Nullable Object settings, @NotNull Module module) {
+
+    myProject = project;
+    Reader reader = null;
+    try {
+      reader = new InputStreamReader(new FileInputStream(mySelectedCourseFile));
+      Gson gson = new GsonBuilder().setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES).create();
+      Course course = gson.fromJson(reader, Course.class);
+      course.init(false);
+      course.create(baseDir, new File(mySelectedCourseFile.getParent()));
+      course.setResourcePath(mySelectedCourseFile.getAbsolutePath());
+      VirtualFileManager.getInstance().refreshWithoutFileWatcher(true);
+      StudyTaskManager.getInstance(project).setCourse(course);
+    }
+    catch (FileNotFoundException e) {
+      LOG.error(e);
+    }
+    finally {
+      StudyUtils.closeSilently(reader);
+    }
+  }
+
+  /**
+   * Downloads courses from {@link com.jetbrains.python.edu.StudyDirectoryProjectGenerator#REPO_URL}
+   * and unzips them into {@link com.jetbrains.python.edu.StudyDirectoryProjectGenerator#myCoursesDir}
+   */
+
+  public void downloadAndUnzip(boolean needProgressBar) {
+    File outputFile = new File(PathManager.getConfigPath(), "courses.zip");
+    try {
+      if (!needProgressBar) {
+        GithubDownloadUtil.downloadAtomically(null, REPO_URL,
+                                              outputFile, USER_NAME, REPOSITORY_NAME);
+      }
+      else {
+        GithubDownloadUtil.downloadContentToFileWithProgressSynchronously(myProject, REPO_URL, "downloading courses", outputFile, USER_NAME,
+                                                                          REPOSITORY_NAME, false);
+      }
+      if (outputFile.exists()) {
+        ZipUtil.unzip(null, myCoursesDir, outputFile, null, null, true);
+        if (!outputFile.delete()) {
+          LOG.error("Failed to delete", outputFile.getName());
+        }
+        File[] files = myCoursesDir.listFiles();
+        if (files != null) {
+          for (File file : files) {
+            String fileName = file.getName();
+            if (StudyUtils.isZip(fileName)) {
+              ZipUtil.unzip(null, new File(myCoursesDir, fileName.substring(0, fileName.indexOf("."))), file, null, null, true);
+              if (!file.delete()) {
+                LOG.error("Failed to delete", fileName);
+              }
+            }
+          }
+        }
+      } else {
+        LOG.debug("failed to download course");
+      }
+    }
+    catch (IOException e) {
+      LOG.error(e);
+    }
+    catch (GeneratorException e) {
+      LOG.error(e);
+    }
+  }
+
+  public Map<CourseInfo, File> getLoadedCourses() {
+    return myCourses;
+  }
+
+  /**
+   * Parses courses located in {@link com.jetbrains.python.edu.StudyDirectoryProjectGenerator#myCoursesDir}
+   * to {@link com.jetbrains.python.edu.StudyDirectoryProjectGenerator#myCourses}
+   *
+   * @return map with course names and course files location
+   */
+  public Map<CourseInfo, File> loadCourses() {
+    Map<CourseInfo, File> courses = new HashMap<CourseInfo, File>();
+    if (myCoursesDir.exists()) {
+      File[] courseDirs = myCoursesDir.listFiles(new FileFilter() {
+        @Override
+        public boolean accept(File pathname) {
+          return pathname.isDirectory();
+        }
+      });
+      for (File courseDir : courseDirs) {
+        addCourse(courses, courseDir);
+      }
+    }
+    return courses;
+  }
+
+  /**
+   * Parses course json meta file and finds course name
+   *
+   * @return information about course or null if course file is invalid
+   */
+  @Nullable
+  private static CourseInfo getCourseInfo(File courseFile) {
+    CourseInfo courseInfo = null;
+    BufferedReader reader = null;
+    try {
+      if (courseFile.getName().equals(COURSE_META_FILE)) {
+        reader = new BufferedReader(new InputStreamReader(new FileInputStream(courseFile)));
+        JsonReader r = new JsonReader(reader);
+        JsonParser parser = new JsonParser();
+        JsonElement el = parser.parse(r);
+        String courseName = el.getAsJsonObject().get(COURSE_NAME_ATTRIBUTE).getAsString();
+        String courseAuthor = el.getAsJsonObject().get(AUTHOR_ATTRIBUTE).getAsString();
+        String courseDescription = el.getAsJsonObject().get("description").getAsString();
+        courseInfo = new CourseInfo(courseName, courseAuthor, courseDescription);
+      }
+    }
+    catch (Exception e) {
+      //error will be shown in UI
+    }
+    finally {
+      StudyUtils.closeSilently(reader);
+    }
+    return courseInfo;
+  }
+
+  @NotNull
+  @Override
+  public ValidationResult validate(@NotNull String s) {
+    return myValidationResult;
+  }
+
+  public void setValidationResult(ValidationResult validationResult) {
+    myValidationResult = validationResult;
+  }
+
+  /**
+   * @return courses from memory or from cash file or parses course directory
+   */
+  public Map<CourseInfo, File> getCourses() {
+    if (!myCourses.isEmpty()) {
+      return myCourses;
+    }
+    if (myCoursesDir.exists()) {
+      File cacheFile = new File(myCoursesDir, CACHE_NAME);
+      if (cacheFile.exists()) {
+        myCourses = getCoursesFromCache(cacheFile);
+        if (!myCourses.isEmpty()) {
+          return myCourses;
+        }
+      }
+      myCourses = loadCourses();
+      if (!myCourses.isEmpty()) {
+        return myCourses;
+      }
+    }
+    downloadAndUnzip(false);
+    myCourses = loadCourses();
+    flushCache();
+    return myCourses;
+  }
+
+  /**
+   * Writes courses to cash file {@link com.jetbrains.python.edu.StudyDirectoryProjectGenerator#CACHE_NAME}
+   */
+  @SuppressWarnings("IOResourceOpenedButNotSafelyClosed")
+  public void flushCache() {
+    File cashFile = new File(myCoursesDir, CACHE_NAME);
+    PrintWriter writer = null;
+    try {
+      if (!cashFile.exists()) {
+        final boolean created = cashFile.createNewFile();
+        if (!created) {
+          LOG.error("Cannot flush courses cache. Can't create " + CACHE_NAME + " file");
+          return;
+        }
+      }
+      writer = new PrintWriter(cashFile);
+      for (Map.Entry<CourseInfo, File> course : myCourses.entrySet()) {
+        CourseInfo courseInfo = course.getKey();
+        String line = String
+          .format("name=%s path=%s author=%s description=%s", courseInfo.getName(), course.getValue(), courseInfo.getAuthor(),
+                  courseInfo.getDescription());
+        writer.println(line);
+      }
+    }
+    catch (FileNotFoundException e) {
+      LOG.error(e);
+    }
+    catch (IOException e) {
+      LOG.error(e);
+    }
+    finally {
+      StudyUtils.closeSilently(writer);
+    }
+  }
+
+  /**
+   * Loads courses from {@link com.jetbrains.python.edu.StudyDirectoryProjectGenerator#CACHE_NAME} file
+   *
+   * @return map of course names and course files
+   */
+  @SuppressWarnings("IOResourceOpenedButNotSafelyClosed")
+  private static Map<CourseInfo, File> getCoursesFromCache(File cashFile) {
+    Map<CourseInfo, File> coursesFromCash = new HashMap<CourseInfo, File>();
+    BufferedReader reader =  null;
+    try {
+       reader = new BufferedReader(new InputStreamReader(new FileInputStream(cashFile)));
+      String line;
+
+      while ((line = reader.readLine()) != null) {
+        Matcher matcher = CACHE_PATTERN.matcher(line);
+        if (matcher.matches()) {
+          String courseName = matcher.group(2);
+          File file = new File(matcher.group(4));
+          String author = matcher.group(6);
+          String description = matcher.group(8);
+          CourseInfo courseInfo = new CourseInfo(courseName, author, description);
+          if (file.exists()) {
+            coursesFromCash.put(courseInfo, file);
+          }
+        }
+      }
+    }
+    catch (FileNotFoundException e) {
+      LOG.error(e);
+    }
+    catch (IOException e) {
+      LOG.error(e);
+    }
+    finally {
+      StudyUtils.closeSilently(reader);
+    }
+    return coursesFromCash;
+  }
+
+  @Nullable
+  @Override
+  public JPanel extendBasePanel() throws ProcessCanceledException {
+    StudyNewProjectPanel settingsPanel = new StudyNewProjectPanel(this);
+    settingsPanel.registerValidators(new FacetValidatorsManager() {
+      public void registerValidator(FacetEditorValidator validator, JComponent... componentsToWatch) {
+        throw new UnsupportedOperationException();
+      }
+      public void validate() {
+        fireStateChanged();
+      }
+    });
+    return settingsPanel.getContentPanel();
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/StudyDocumentListener.java b/python/edu/learn-python/src/com/jetbrains/python/edu/StudyDocumentListener.java
new file mode 100644
index 0000000..9fdcf70
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/StudyDocumentListener.java
@@ -0,0 +1,65 @@
+package com.jetbrains.python.edu;
+
+
+import com.intellij.openapi.editor.Document;
+import com.intellij.openapi.editor.LogicalPosition;
+import com.intellij.openapi.editor.event.DocumentAdapter;
+import com.intellij.openapi.editor.event.DocumentEvent;
+import com.intellij.openapi.editor.impl.event.DocumentEventImpl;
+import com.jetbrains.python.edu.course.TaskFile;
+import com.jetbrains.python.edu.course.TaskWindow;
+
+/**
+ * author: liana
+ * data: 7/16/14.
+ * Listens changes in study files and updates
+ * coordinates of all the windows in current task file
+ */
+public class StudyDocumentListener extends DocumentAdapter {
+  private final TaskFile myTaskFile;
+  private int oldLine;
+  private int oldLineStartOffset;
+  private TaskWindow myTaskWindow;
+
+  public StudyDocumentListener(TaskFile taskFile) {
+    myTaskFile = taskFile;
+  }
+
+
+  //remembering old end before document change because of problems
+  // with fragments containing "\n"
+  @Override
+  public void beforeDocumentChange(DocumentEvent e) {
+    int offset = e.getOffset();
+    int oldEnd = offset + e.getOldLength();
+    Document document = e.getDocument();
+    oldLine = document.getLineNumber(oldEnd);
+    oldLineStartOffset = document.getLineStartOffset(oldLine);
+    int line = document.getLineNumber(offset);
+    int offsetInLine = offset - document.getLineStartOffset(line);
+    LogicalPosition pos = new LogicalPosition(line, offsetInLine);
+    myTaskWindow = myTaskFile.getTaskWindow(document, pos);
+
+  }
+
+  @Override
+  public void documentChanged(DocumentEvent e) {
+    if (e instanceof DocumentEventImpl) {
+      DocumentEventImpl event = (DocumentEventImpl)e;
+      Document document = e.getDocument();
+      int offset = e.getOffset();
+      int change = event.getNewLength() - event.getOldLength();
+      if (myTaskWindow != null) {
+        int newLength = myTaskWindow.getLength() + change;
+        myTaskWindow.setLength(newLength <= 0 ? 0 : newLength);
+      }
+      int newEnd = offset + event.getNewLength();
+      int newLine = document.getLineNumber(newEnd);
+      int lineChange = newLine - oldLine;
+      myTaskFile.incrementLines(oldLine + 1, lineChange);
+      int newEndOffsetInLine = offset + e.getNewLength() - document.getLineStartOffset(newLine);
+      int oldEndOffsetInLine = offset + e.getOldLength() - oldLineStartOffset;
+      myTaskFile.updateLine(lineChange, oldLine, newEndOffsetInLine, oldEndOffsetInLine);
+    }
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/StudyEditorFactoryListener.java b/python/edu/learn-python/src/com/jetbrains/python/edu/StudyEditorFactoryListener.java
new file mode 100644
index 0000000..7565d76
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/StudyEditorFactoryListener.java
@@ -0,0 +1,100 @@
+package com.jetbrains.python.edu;
+
+
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.editor.Document;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.editor.LogicalPosition;
+import com.intellij.openapi.editor.event.EditorFactoryEvent;
+import com.intellij.openapi.editor.event.EditorFactoryListener;
+import com.intellij.openapi.editor.event.EditorMouseAdapter;
+import com.intellij.openapi.editor.event.EditorMouseEvent;
+import com.intellij.openapi.fileEditor.FileDocumentManager;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.jetbrains.python.edu.course.StudyStatus;
+import com.jetbrains.python.edu.course.TaskFile;
+import com.jetbrains.python.edu.course.TaskWindow;
+import com.jetbrains.python.edu.editor.StudyEditor;
+import org.jetbrains.annotations.NotNull;
+
+import java.awt.*;
+
+
+class StudyEditorFactoryListener implements EditorFactoryListener {
+
+  /**
+   * draws selected task window if there is one located in mouse position
+   */
+  private static class WindowSelectionListener extends EditorMouseAdapter {
+    private final TaskFile myTaskFile;
+
+    WindowSelectionListener(TaskFile taskFile) {
+      myTaskFile = taskFile;
+    }
+
+    @Override
+    public void mouseClicked(EditorMouseEvent e) {
+      Editor editor = e.getEditor();
+      Point point = e.getMouseEvent().getPoint();
+      LogicalPosition pos = editor.xyToLogicalPosition(point);
+      TaskWindow taskWindow = myTaskFile.getTaskWindow(editor.getDocument(), pos);
+      if (taskWindow != null) {
+        myTaskFile.setSelectedTaskWindow(taskWindow);
+        taskWindow.draw(editor, taskWindow.getStatus() != StudyStatus.Solved, true);
+      }
+      else {
+        myTaskFile.drawAllWindows(editor);
+      }
+    }
+  }
+
+  @Override
+  public void editorCreated(@NotNull final EditorFactoryEvent event) {
+    final Editor editor = event.getEditor();
+
+    final Project project = editor.getProject();
+    if (project == null) {
+      return;
+    }
+    ApplicationManager.getApplication().invokeLater(
+      new Runnable() {
+        @Override
+        public void run() {
+          ApplicationManager.getApplication().runWriteAction(new Runnable() {
+            @Override
+            public void run() {
+              Document document = editor.getDocument();
+              VirtualFile openedFile = FileDocumentManager.getInstance().getFile(document);
+              if (openedFile != null) {
+                StudyTaskManager taskManager = StudyTaskManager.getInstance(project);
+                TaskFile taskFile = taskManager.getTaskFile(openedFile);
+                if (taskFile != null) {
+                  taskFile.navigateToFirstTaskWindow(editor);
+                  editor.addEditorMouseListener(new WindowSelectionListener(taskFile));
+                  StudyDocumentListener listener = new StudyDocumentListener(taskFile);
+                  StudyEditor.addDocumentListener(document, listener);
+                  document.addDocumentListener(listener);
+                  taskFile.drawAllWindows(editor);
+                }
+              }
+            }
+          });
+        }
+      }
+    );
+  }
+
+  @Override
+  public void editorReleased(@NotNull EditorFactoryEvent event) {
+    Editor editor = event.getEditor();
+    Document document = editor.getDocument();
+    StudyDocumentListener listener = StudyEditor.getListener(document);
+    if (listener != null) {
+      document.removeDocumentListener(listener);
+      StudyEditor.removeListener(document);
+    }
+    editor.getMarkupModel().removeAllHighlighters();
+    editor.getSelectionModel().removeSelection();
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/StudyHighlightErrorFilter.java b/python/edu/learn-python/src/com/jetbrains/python/edu/StudyHighlightErrorFilter.java
new file mode 100644
index 0000000..1377128
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/StudyHighlightErrorFilter.java
@@ -0,0 +1,23 @@
+package com.jetbrains.python.edu;
+
+import com.intellij.codeInsight.highlighting.HighlightErrorFilter;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.psi.PsiErrorElement;
+import org.jetbrains.annotations.NotNull;
+import com.jetbrains.python.edu.course.TaskFile;
+
+/**
+ * author: liana
+ * data: 7/23/14.
+ */
+public class StudyHighlightErrorFilter extends HighlightErrorFilter {
+  @Override
+  public boolean shouldHighlightErrorElement(@NotNull final PsiErrorElement element) {
+    VirtualFile file = element.getContainingFile().getVirtualFile();
+    Project project = element.getProject();
+    StudyTaskManager taskManager = StudyTaskManager.getInstance(project);
+    TaskFile taskFile = taskManager.getTaskFile(file);
+    return taskFile == null;
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/StudyInitialConfigurator.java b/python/edu/learn-python/src/com/jetbrains/python/edu/StudyInitialConfigurator.java
new file mode 100644
index 0000000..34776f3
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/StudyInitialConfigurator.java
@@ -0,0 +1,67 @@
+package com.jetbrains.python.edu;
+
+import com.intellij.codeInsight.CodeInsightSettings;
+import com.intellij.ide.RecentProjectsManagerBase;
+import com.intellij.ide.ui.UISettings;
+import com.intellij.ide.util.PropertiesComponent;
+import com.intellij.openapi.application.PathManager;
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.fileTypes.FileTypeManager;
+import com.intellij.openapi.project.ex.ProjectManagerEx;
+import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.platform.templates.github.ZipUtil;
+import com.intellij.util.PathUtil;
+import com.intellij.util.messages.MessageBus;
+import org.jetbrains.annotations.NonNls;
+
+import java.io.File;
+import java.io.IOException;
+
+@SuppressWarnings({"UtilityClassWithoutPrivateConstructor", "UtilityClassWithPublicConstructor"})
+public class StudyInitialConfigurator {
+  private static final Logger LOG = Logger.getInstance(StudyInitialConfigurator.class.getName()
+  );
+  @NonNls private static final String CONFIGURED = "StudyPyCharm.InitialConfiguration";
+
+
+  /**
+   * @noinspection UnusedParameters
+   */
+  public StudyInitialConfigurator(MessageBus bus,
+                                  UISettings uiSettings,
+                                  CodeInsightSettings codeInsightSettings,
+                                  final PropertiesComponent propertiesComponent,
+                                  FileTypeManager fileTypeManager,
+                                  final ProjectManagerEx projectManager,
+                                  RecentProjectsManagerBase recentProjectsManager) {
+    if (!propertiesComponent.getBoolean(CONFIGURED, false)) {
+      final File file = new File(getCoursesRoot(), "introduction_course.zip");
+      final File newCourses = new File(PathManager.getConfigPath(), "courses");
+      try {
+        FileUtil.createDirectory(newCourses);
+        String fileName = file.getName();
+        String unzippedName = fileName.substring(0, fileName.indexOf("."));
+        File courseDir = new File(newCourses, unzippedName);
+        ZipUtil.unzip(null, courseDir, file, null, null, true);
+
+      }
+      catch (IOException e) {
+        LOG.warn("Couldn't copy bundled courses " + e);
+      }
+    }
+  }
+
+  public static File getCoursesRoot() {
+    @NonNls String jarPath = PathUtil.getJarPathForClass(StudyInitialConfigurator.class);
+    if (jarPath.endsWith(".jar")) {
+      final File jarFile = new File(jarPath);
+
+
+      File pluginBaseDir = jarFile.getParentFile();
+      return new File(pluginBaseDir, "courses");
+    }
+
+    return new File(jarPath , "courses");
+  }
+
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/StudyInstructionPainter.java b/python/edu/learn-python/src/com/jetbrains/python/edu/StudyInstructionPainter.java
new file mode 100644
index 0000000..4f34bfb
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/StudyInstructionPainter.java
@@ -0,0 +1,47 @@
+package com.jetbrains.python.edu;
+
+import com.intellij.openapi.fileEditor.impl.EditorEmptyTextPainter;
+import com.intellij.openapi.fileEditor.impl.EditorsSplitters;
+import com.intellij.openapi.util.Couple;
+import com.intellij.ui.Gray;
+import com.intellij.ui.JBColor;
+import com.intellij.util.PairFunction;
+import com.intellij.util.ui.GraphicsUtil;
+import com.intellij.util.ui.UIUtil;
+import com.jetbrains.python.edu.ui.StudyCondition;
+
+import java.awt.*;
+
+/**
+ * author: liana
+ * data: 7/29/14.
+ */
+public class StudyInstructionPainter extends EditorEmptyTextPainter {
+  @Override
+  public void paintEmptyText(final EditorsSplitters splitters, Graphics g) {
+    if (!StudyCondition.VALUE) {
+      super.paintEmptyText(splitters, g);
+      return;
+    }
+    boolean isDarkBackground = UIUtil.isUnderDarcula();
+    UIUtil.applyRenderingHints(g);
+    GraphicsUtil.setupAntialiasing(g, true, false);
+    g.setColor(new JBColor(isDarkBackground ? Gray._230 : Gray._80, Gray._160));
+    g.setFont(UIUtil.getLabelFont().deriveFont(isDarkBackground ? 24f : 20f));
+
+    UIUtil.TextPainter painter = new UIUtil.TextPainter().withLineSpacing(1.5f);
+
+    painter.appendLine("PyCharm Educational Edition").underlined(new JBColor(Gray._150, Gray._180));
+    painter.appendLine("Navigate to the next task window with Ctrl + Enter").smaller().withBullet();
+    painter.appendLine("Navigate between task windows with Ctrl + < and Ctrl + >").smaller().withBullet();
+    painter.appendLine("Get hint for the task window using Ctrl + 7").smaller().withBullet();
+    painter.appendLine("To see your progress open the 'Course Description' panel").smaller().withBullet();
+                       painter.draw(g, new PairFunction<Integer, Integer, Couple<Integer>>() {
+                         @Override
+                         public Couple<Integer> fun(Integer width, Integer height) {
+                           Dimension s = splitters.getSize();
+                           return Couple.of((s.width - width) / 2, (s.height - height) / 2);
+                         }
+                       });
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/StudyResourceManger.java b/python/edu/learn-python/src/com/jetbrains/python/edu/StudyResourceManger.java
new file mode 100644
index 0000000..38f1c2f
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/StudyResourceManger.java
@@ -0,0 +1,5 @@
+package com.jetbrains.python.edu;
+
+public interface StudyResourceManger {
+  String USER_TESTER = "user_tester.py";
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/StudyTaskManager.java b/python/edu/learn-python/src/com/jetbrains/python/edu/StudyTaskManager.java
new file mode 100644
index 0000000..213c1f7
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/StudyTaskManager.java
@@ -0,0 +1,296 @@
+package com.jetbrains.python.edu;
+
+import com.intellij.ide.ui.UISettings;
+import com.intellij.openapi.actionSystem.*;
+import com.intellij.openapi.actionSystem.ex.AnActionListener;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.components.*;
+import com.intellij.openapi.editor.EditorFactory;
+import com.intellij.openapi.fileEditor.FileEditor;
+import com.intellij.openapi.fileEditor.FileEditorManager;
+import com.intellij.openapi.keymap.Keymap;
+import com.intellij.openapi.keymap.KeymapManager;
+import com.intellij.openapi.project.DumbAware;
+import com.intellij.openapi.project.DumbAwareRunnable;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.startup.StartupManager;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.vfs.VirtualFileAdapter;
+import com.intellij.openapi.vfs.VirtualFileEvent;
+import com.intellij.openapi.vfs.VirtualFileManager;
+import com.intellij.openapi.wm.*;
+import com.intellij.util.xmlb.XmlSerializer;
+import com.jetbrains.python.edu.actions.StudyNextWindowAction;
+import com.jetbrains.python.edu.actions.StudyPrevWindowAction;
+import com.jetbrains.python.edu.actions.StudyShowHintAction;
+import com.jetbrains.python.edu.course.Course;
+import com.jetbrains.python.edu.course.Lesson;
+import com.jetbrains.python.edu.course.Task;
+import com.jetbrains.python.edu.course.TaskFile;
+import com.jetbrains.python.edu.ui.StudyCondition;
+import com.jetbrains.python.edu.ui.StudyToolWindowFactory;
+import org.jdom.Element;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import javax.swing.*;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Implementation of class which contains all the information
+ * about study in context of current project
+ */
+
+@State(
+  name = "StudySettings",
+  storages = {
+    @Storage(
+      id = "others",
+      file = "$PROJECT_CONFIG_DIR$/study_project.xml",
+      scheme = StorageScheme.DIRECTORY_BASED
+    )}
+)
+public class StudyTaskManager implements ProjectComponent, PersistentStateComponent<Element>, DumbAware {
+  public static final String COURSE_ELEMENT = "courseElement";
+  private static Map<String, StudyTaskManager> myTaskManagers = new HashMap<String, StudyTaskManager>();
+  private static Map<String, String> myDeletedShortcuts = new HashMap<String, String>();
+  private final Project myProject;
+  private Course myCourse;
+  private FileCreatedListener myListener;
+
+
+  public void setCourse(Course course) {
+    myCourse = course;
+  }
+
+  private StudyTaskManager(@NotNull final Project project) {
+    myTaskManagers.put(project.getBasePath(), this);
+    myProject = project;
+  }
+
+
+  @Nullable
+  public Course getCourse() {
+    return myCourse;
+  }
+
+  @Nullable
+  @Override
+  public Element getState() {
+    Element el = new Element("taskManager");
+    if (myCourse != null) {
+      Element courseElement = new Element(COURSE_ELEMENT);
+      XmlSerializer.serializeInto(myCourse, courseElement);
+      el.addContent(courseElement);
+    }
+    return el;
+  }
+
+  @Override
+  public void loadState(Element el) {
+    myCourse = XmlSerializer.deserialize(el.getChild(COURSE_ELEMENT), Course.class);
+    if (myCourse != null) {
+      myCourse.init(true);
+    }
+  }
+
+  @Override
+  public void projectOpened() {
+    ApplicationManager.getApplication().invokeLater(new DumbAwareRunnable() {
+      @Override
+      public void run() {
+        ApplicationManager.getApplication().runWriteAction(new DumbAwareRunnable() {
+          @Override
+          public void run() {
+            if (myCourse != null) {
+              StartupManager.getInstance(myProject).runWhenProjectIsInitialized(new Runnable() {
+                @Override
+                public void run() {
+                  ToolWindowManager.getInstance(myProject).getToolWindow(ToolWindowId.PROJECT_VIEW).show(null);
+                  FileEditor[] editors = FileEditorManager.getInstance(myProject).getSelectedEditors();
+                  if (editors.length > 0) {
+                    JComponent focusedComponent = editors[0].getPreferredFocusedComponent();
+                    if (focusedComponent != null) {
+                      IdeFocusManager.getInstance(myProject).requestFocus(focusedComponent, true);
+                    }
+                  }
+                }
+              });
+              UISettings.getInstance().HIDE_TOOL_STRIPES = false;
+              UISettings.getInstance().fireUISettingsChanged();
+              ToolWindowManager toolWindowManager = ToolWindowManager.getInstance(myProject);
+              String toolWindowId = StudyToolWindowFactory.STUDY_TOOL_WINDOW;
+              //TODO:decide smth with tool window position
+              try {
+                Method method = toolWindowManager.getClass().getDeclaredMethod("registerToolWindow", String.class,
+                                                                               JComponent.class,
+                                                                               ToolWindowAnchor.class,
+                                                                               boolean.class, boolean.class, boolean.class);
+                method.setAccessible(true);
+                method.invoke(toolWindowManager, toolWindowId, null, ToolWindowAnchor.LEFT, true, true, true);
+              }
+              catch (Exception e) {
+                final ToolWindow toolWindow = toolWindowManager.getToolWindow(toolWindowId);
+                if (toolWindow == null)
+                  toolWindowManager.registerToolWindow(toolWindowId, true, ToolWindowAnchor.RIGHT, myProject, true);
+              }
+
+              final ToolWindow studyToolWindow = toolWindowManager.getToolWindow(toolWindowId);
+              if (studyToolWindow != null) {
+                StudyUtils.updateStudyToolWindow(myProject);
+                studyToolWindow.show(null);
+              }
+              addShortcut(StudyNextWindowAction.SHORTCUT, StudyNextWindowAction.ACTION_ID);
+              addShortcut(StudyPrevWindowAction.SHORTCUT, StudyPrevWindowAction.ACTION_ID);
+              addShortcut(StudyShowHintAction.SHORTCUT, StudyShowHintAction.ACTION_ID);
+              addShortcut(StudyNextWindowAction.SHORTCUT2, StudyNextWindowAction.ACTION_ID);
+            }
+          }
+        });
+      }
+    });
+  }
+
+
+  private static void addShortcut(@NotNull final String shortcutString, @NotNull final String actionIdString) {
+    Keymap keymap = KeymapManager.getInstance().getActiveKeymap();
+    Shortcut studyActionShortcut = new KeyboardShortcut(KeyStroke.getKeyStroke(shortcutString), null);
+    String[] actionsIds = keymap.getActionIds(studyActionShortcut);
+    for (String actionId : actionsIds) {
+      myDeletedShortcuts.put(actionId, shortcutString);
+      keymap.removeShortcut(actionId, studyActionShortcut);
+    }
+    keymap.addShortcut(actionIdString, studyActionShortcut);
+  }
+
+  @Override
+  public void projectClosed() {
+    StudyCondition.VALUE = false;
+    if (myCourse != null) {
+      ToolWindowManager.getInstance(myProject).getToolWindow(StudyToolWindowFactory.STUDY_TOOL_WINDOW).getContentManager()
+        .removeAllContents(false);
+      if (!myDeletedShortcuts.isEmpty()) {
+        for (Map.Entry<String, String> shortcut : myDeletedShortcuts.entrySet()) {
+          Keymap keymap = KeymapManager.getInstance().getActiveKeymap();
+          Shortcut actionShortcut = new KeyboardShortcut(KeyStroke.getKeyStroke(shortcut.getValue()), null);
+          keymap.addShortcut(shortcut.getKey(), actionShortcut);
+        }
+      }
+    }
+  }
+
+  @Override
+  public void initComponent() {
+    EditorFactory.getInstance().addEditorFactoryListener(new StudyEditorFactoryListener(), myProject);
+    ActionManager.getInstance().addAnActionListener(new AnActionListener() {
+      @Override
+      public void beforeActionPerformed(AnAction action, DataContext dataContext, AnActionEvent event) {
+        AnAction[] newGroupActions = ((ActionGroup)ActionManager.getInstance().getAction("NewGroup")).getChildren(null);
+        for (AnAction newAction : newGroupActions) {
+          if (newAction == action) {
+            myListener =  new FileCreatedListener();
+            VirtualFileManager.getInstance().addVirtualFileListener(myListener);
+            break;
+          }
+        }
+      }
+
+      @Override
+      public void afterActionPerformed(AnAction action, DataContext dataContext, AnActionEvent event) {
+        AnAction[] newGroupActions = ((ActionGroup)ActionManager.getInstance().getAction("NewGroup")).getChildren(null);
+        for (AnAction newAction : newGroupActions) {
+          if (newAction == action) {
+            VirtualFileManager.getInstance().removeVirtualFileListener(myListener);
+          }
+        }
+      }
+
+      @Override
+      public void beforeEditorTyping(char c, DataContext dataContext) {
+
+      }
+    });
+  }
+
+  @Override
+  public void disposeComponent() {
+  }
+
+  @NotNull
+  @Override
+  public String getComponentName() {
+    return "StudyTaskManager";
+  }
+
+  public static StudyTaskManager getInstance(@NotNull final Project project) {
+    StudyTaskManager item = myTaskManagers.get(project.getBasePath());
+    return item != null ? item : new StudyTaskManager(project);
+  }
+
+
+  @Nullable
+  public TaskFile getTaskFile(@NotNull final VirtualFile file) {
+    if (myCourse == null) {
+      return null;
+    }
+    VirtualFile taskDir = file.getParent();
+    if (taskDir != null) {
+      String taskDirName = taskDir.getName();
+      if (taskDirName.contains(Task.TASK_DIR)) {
+        VirtualFile lessonDir = taskDir.getParent();
+        if (lessonDir != null) {
+          String lessonDirName = lessonDir.getName();
+          int lessonIndex = StudyUtils.getIndex(lessonDirName, Lesson.LESSON_DIR);
+          List<Lesson> lessons = myCourse.getLessons();
+          if (!StudyUtils.indexIsValid(lessonIndex, lessons)) {
+            return null;
+          }
+          Lesson lesson = lessons.get(lessonIndex);
+          int taskIndex = StudyUtils.getIndex(taskDirName, Task.TASK_DIR);
+          List<Task> tasks = lesson.getTaskList();
+          if (!StudyUtils.indexIsValid(taskIndex, tasks)) {
+            return null;
+          }
+          Task task = tasks.get(taskIndex);
+          return task.getFile(file.getName());
+        }
+      }
+    }
+    return null;
+  }
+
+  class FileCreatedListener extends VirtualFileAdapter {
+    @Override
+    public void fileCreated(@NotNull VirtualFileEvent event) {
+      VirtualFile createdFile = event.getFile();
+      VirtualFile taskDir = createdFile.getParent();
+      String taskLogicalName = Task.TASK_DIR;
+      if (taskDir != null && taskDir.getName().contains(taskLogicalName)) {
+        int taskIndex = StudyUtils.getIndex(taskDir.getName(), taskLogicalName);
+        VirtualFile lessonDir = taskDir.getParent();
+        String lessonLogicalName = Lesson.LESSON_DIR;
+        if (lessonDir != null && lessonDir.getName().contains(lessonLogicalName)) {
+          int lessonIndex = StudyUtils.getIndex(lessonDir.getName(), lessonLogicalName);
+          if (myCourse != null) {
+            List<Lesson> lessons = myCourse.getLessons();
+            if (StudyUtils.indexIsValid(lessonIndex, lessons)) {
+              Lesson lesson = lessons.get(lessonIndex);
+              List<Task> tasks = lesson.getTaskList();
+              if (StudyUtils.indexIsValid(taskIndex, tasks)) {
+                Task task = tasks.get(taskIndex);
+                TaskFile taskFile = new TaskFile();
+                taskFile.init(task, false);
+                taskFile.setUserCreated(true);
+                task.getTaskFiles().put(createdFile.getName(), taskFile);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/StudyUtils.java b/python/edu/learn-python/src/com/jetbrains/python/edu/StudyUtils.java
new file mode 100644
index 0000000..d3ac1da
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/StudyUtils.java
@@ -0,0 +1,151 @@
+package com.jetbrains.python.edu;
+
+import com.intellij.ide.SaveAndSyncHandlerImpl;
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.actionSystem.Presentation;
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.editor.Document;
+import com.intellij.openapi.fileEditor.FileDocumentManager;
+import com.intellij.openapi.fileEditor.FileEditor;
+import com.intellij.openapi.fileEditor.FileEditorManager;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.TextRange;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.vfs.VirtualFileManager;
+import com.intellij.openapi.wm.ToolWindowManager;
+import com.intellij.util.ui.UIUtil;
+import com.jetbrains.python.edu.course.TaskFile;
+import com.jetbrains.python.edu.course.TaskWindow;
+import com.jetbrains.python.edu.editor.StudyEditor;
+import com.jetbrains.python.edu.ui.StudyToolWindowFactory;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.*;
+import java.util.Collection;
+
+public class StudyUtils {
+  private static final Logger LOG = Logger.getInstance(StudyUtils.class.getName());
+  public static void closeSilently(Closeable stream) {
+    if (stream != null) {
+      try {
+        stream.close();
+      }
+      catch (IOException e) {
+        // close silently
+      }
+    }
+  }
+
+  public static boolean isZip(String fileName) {
+    return fileName.contains(".zip");
+  }
+
+  public static <T> T getFirst(Iterable<T> container) {
+    return container.iterator().next();
+  }
+
+  public static boolean indexIsValid(int index, Collection collection) {
+    int size = collection.size();
+    return index >= 0 && index < size;
+  }
+
+  @SuppressWarnings("IOResourceOpenedButNotSafelyClosed")
+  @Nullable
+  public static String getFileText(String parentDir, String fileName, boolean wrapHTML) {
+
+    File inputFile = parentDir !=null ? new File(parentDir, fileName) : new File(fileName);
+    if (!inputFile.exists()) return null;
+    StringBuilder taskText = new StringBuilder();
+    BufferedReader reader = null;
+    try {
+      reader = new BufferedReader(new InputStreamReader(new FileInputStream(inputFile)));
+      String line;
+      while ((line = reader.readLine()) != null) {
+        taskText.append(line).append("\n");
+        if (wrapHTML) {
+          taskText.append("<br>");
+        }
+      }
+      return wrapHTML ? UIUtil.toHtml(taskText.toString()) : taskText.toString();
+    }
+    catch (IOException e) {
+      LOG.error("Failed to get file text from file " + fileName, e);
+    }
+    finally {
+      closeSilently(reader);
+    }
+    return null;
+  }
+
+  public static void updateAction(AnActionEvent e) {
+    Presentation presentation = e.getPresentation();
+    presentation.setEnabled(false);
+    Project project = e.getProject();
+    if (project != null) {
+      FileEditor[] editors = FileEditorManager.getInstance(project).getAllEditors();
+      for (FileEditor editor : editors) {
+        if (editor instanceof StudyEditor) {
+          presentation.setEnabled(true);
+        }
+      }
+    }
+  }
+
+  public static void updateStudyToolWindow(Project project) {
+    ToolWindowManager.getInstance(project).getToolWindow(StudyToolWindowFactory.STUDY_TOOL_WINDOW).getContentManager().removeAllContents(false);
+    StudyToolWindowFactory factory =  new StudyToolWindowFactory();
+    factory.createToolWindowContent(project, ToolWindowManager.getInstance(project).getToolWindow(StudyToolWindowFactory.STUDY_TOOL_WINDOW));
+  }
+
+  public  static void synchronize() {
+    FileDocumentManager.getInstance().saveAllDocuments();
+    SaveAndSyncHandlerImpl.refreshOpenFiles();
+    VirtualFileManager.getInstance().refreshWithoutFileWatcher(true);
+  }
+
+  /**
+   * Gets number index in directory names like "task1", "lesson2"
+   *
+   * @param fullName    full name of directory
+   * @param logicalName part of name without index
+   * @return index of object
+   */
+  public static int getIndex(@NotNull final String fullName, @NotNull final String logicalName) {
+    if (!fullName.contains(logicalName)) {
+      throw new IllegalArgumentException();
+    }
+    return Integer.parseInt(fullName.substring(logicalName.length())) - 1;
+  }
+
+  @SuppressWarnings("IOResourceOpenedButNotSafelyClosed")
+  public static VirtualFile flushWindows(Document document, TaskFile taskFile, VirtualFile file) {
+    VirtualFile taskDir = file.getParent();
+    VirtualFile fileWindows = null;
+    if (taskDir != null) {
+      String name = file.getNameWithoutExtension() + "_windows";
+      PrintWriter printWriter = null;
+      try {
+
+        fileWindows = taskDir.createChildData(taskFile, name);
+        printWriter = new PrintWriter(new FileOutputStream(fileWindows.getPath()));
+        for (TaskWindow taskWindow : taskFile.getTaskWindows()) {
+          if (!taskWindow.isValid(document)) {
+            continue;
+          }
+          int start = taskWindow.getRealStartOffset(document);
+          String windowDescription = document.getText(new TextRange(start, start + taskWindow.getLength()));
+          printWriter.println("#study_plugin_window = " + windowDescription);
+        }
+      }
+      catch (IOException e) {
+       LOG.error(e);
+      }
+      finally {
+        closeSilently(printWriter);
+        synchronize();
+      }
+    }
+    return fileWindows;
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyCheckAction.java b/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyCheckAction.java
new file mode 100644
index 0000000..f8e10c9
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyCheckAction.java
@@ -0,0 +1,340 @@
+package com.jetbrains.python.edu.actions;
+
+import com.intellij.execution.ExecutionException;
+import com.intellij.execution.configurations.GeneralCommandLine;
+import com.intellij.ide.projectView.ProjectView;
+import com.intellij.openapi.actionSystem.ActionManager;
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.command.CommandProcessor;
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.editor.Document;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.fileEditor.FileDocumentManager;
+import com.intellij.openapi.fileEditor.FileEditor;
+import com.intellij.openapi.fileEditor.FileEditorManager;
+import com.intellij.openapi.module.ModuleManager;
+import com.intellij.openapi.project.DumbAwareAction;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.projectRoots.Sdk;
+import com.intellij.openapi.ui.popup.Balloon;
+import com.intellij.openapi.ui.popup.BalloonBuilder;
+import com.intellij.openapi.ui.popup.JBPopupFactory;
+import com.intellij.openapi.util.TextRange;
+import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.ui.JBColor;
+import com.jetbrains.python.edu.StudyDocumentListener;
+import com.jetbrains.python.edu.StudyTaskManager;
+import com.jetbrains.python.edu.StudyUtils;
+import com.jetbrains.python.edu.course.*;
+import com.jetbrains.python.edu.editor.StudyEditor;
+import com.jetbrains.python.sdk.PythonSdkType;
+import org.jetbrains.annotations.NotNull;
+
+import javax.swing.*;
+import java.awt.*;
+import java.io.*;
+import java.util.*;
+import java.util.List;
+
+public class StudyCheckAction extends DumbAwareAction {
+
+  private static final Logger LOG = Logger.getInstance(StudyCheckAction.class.getName());
+  public static final String PYTHONPATH = "PYTHONPATH";
+
+  static class StudyTestRunner {
+    public static final String TEST_OK = "#study_plugin test OK";
+    private static final String TEST_FAILED = "#study_plugin FAILED + ";
+    private final Task myTask;
+    private final VirtualFile myTaskDir;
+
+    StudyTestRunner(Task task, VirtualFile taskDir) {
+      myTask = task;
+      myTaskDir = taskDir;
+    }
+
+    Process launchTests(Project project, String executablePath) throws ExecutionException {
+      Sdk sdk = PythonSdkType.findPythonSdk(ModuleManager.getInstance(project).getModules()[0]);
+      File testRunner = new File(myTaskDir.getPath(), myTask.getTestFile());
+      GeneralCommandLine commandLine = new GeneralCommandLine();
+      commandLine.setWorkDirectory(myTaskDir.getPath());
+      final Map<String, String> env = commandLine.getEnvironment();
+      final VirtualFile courseDir = project.getBaseDir();
+      if (courseDir != null)
+        env.put(PYTHONPATH, courseDir.getPath());
+      if (sdk != null) {
+        String pythonPath = sdk.getHomePath();
+        if (pythonPath != null) {
+          commandLine.setExePath(pythonPath);
+          commandLine.addParameter(testRunner.getPath());
+          final Course course = StudyTaskManager.getInstance(project).getCourse();
+          assert course != null;
+          commandLine.addParameter(new File(course.getResourcePath()).getParent());
+          commandLine.addParameter(FileUtil.toSystemDependentName(executablePath));
+          return commandLine.createProcess();
+        }
+      }
+      return null;
+    }
+
+
+    String getPassedTests(Process p) {
+      InputStream testOutput = p.getInputStream();
+      BufferedReader testOutputReader = new BufferedReader(new InputStreamReader(testOutput));
+      String line;
+      try {
+        while ((line = testOutputReader.readLine()) != null) {
+          if (line.contains(TEST_FAILED)) {
+             return line.substring(TEST_FAILED.length(), line.length());
+          }
+        }
+      }
+      catch (IOException e) {
+        LOG.error(e);
+      }
+      finally {
+        StudyUtils.closeSilently(testOutputReader);
+      }
+      return TEST_OK;
+    }
+  }
+
+  public void check(@NotNull final Project project) {
+    ApplicationManager.getApplication().runWriteAction(new Runnable() {
+      @Override
+      public void run() {
+        CommandProcessor.getInstance().runUndoTransparentAction(new Runnable() {
+          @Override
+          public void run() {
+        final Editor selectedEditor = StudyEditor.getSelectedEditor(project);
+        if (selectedEditor != null) {
+          final FileDocumentManager fileDocumentManager = FileDocumentManager.getInstance();
+          final VirtualFile openedFile = fileDocumentManager.getFile(selectedEditor.getDocument());
+          if (openedFile != null) {
+            StudyTaskManager taskManager = StudyTaskManager.getInstance(project);
+            final TaskFile selectedTaskFile = taskManager.getTaskFile(openedFile);
+            List<VirtualFile> filesToDelete = new ArrayList<VirtualFile>();
+            if (selectedTaskFile != null) {
+              final VirtualFile taskDir = openedFile.getParent();
+              Task currentTask = selectedTaskFile.getTask();
+              StudyStatus oldStatus = currentTask.getStatus();
+              Map<String, TaskFile> taskFiles = selectedTaskFile.getTask().getTaskFiles();
+              for (Map.Entry<String, TaskFile> entry : taskFiles.entrySet()) {
+                String name = entry.getKey();
+                TaskFile taskFile = entry.getValue();
+                VirtualFile virtualFile = taskDir.findChild(name);
+                if (virtualFile == null) {
+                  continue;
+                }
+                VirtualFile windowFile = StudyUtils.flushWindows(FileDocumentManager.getInstance().getDocument(virtualFile), taskFile, virtualFile);
+                filesToDelete.add(windowFile);
+                FileDocumentManager.getInstance().saveAllDocuments();
+              }
+
+              StudyRunAction runAction = (StudyRunAction)ActionManager.getInstance().getAction(StudyRunAction.ACTION_ID);
+              if (runAction != null && currentTask.getTaskFiles().size() == 1) {
+                runAction.run(project);
+              }
+              final StudyTestRunner testRunner = new StudyTestRunner(currentTask, taskDir);
+              Process testProcess = null;
+              try {
+                testProcess = testRunner.launchTests(project, openedFile.getPath());
+              }
+              catch (ExecutionException e) {
+                LOG.error(e);
+              }
+              if (testProcess != null) {
+                String failedMessage = testRunner.getPassedTests(testProcess);
+                if (failedMessage.equals(StudyTestRunner.TEST_OK)) {
+                  currentTask.setStatus(StudyStatus.Solved, oldStatus);
+                  StudyUtils.updateStudyToolWindow(project);
+                  selectedTaskFile.drawAllWindows(selectedEditor);
+                  ProjectView.getInstance(project).refresh();
+                  for (VirtualFile file:filesToDelete) {
+                    try {
+                      file.delete(this);
+                    }
+                    catch (IOException e) {
+                      LOG.error(e);
+                    }
+                  }
+                  createTestResultPopUp("Congratulations!", JBColor.GREEN, project);
+                  return;
+                }
+                for (Map.Entry<String, TaskFile> entry : taskFiles.entrySet()) {
+                  String name = entry.getKey();
+                  TaskFile taskFile = entry.getValue();
+                  TaskFile answerTaskFile = new TaskFile();
+                  VirtualFile virtualFile = taskDir.findChild(name);
+                  if (virtualFile == null) {
+                    continue;
+                  }
+                  VirtualFile answerFile = getCopyWithAnswers(taskDir, virtualFile, taskFile, answerTaskFile);
+                  for (TaskWindow taskWindow : answerTaskFile.getTaskWindows()) {
+                    Document document = FileDocumentManager.getInstance().getDocument(virtualFile);
+                    if (document == null) {
+                      continue;
+                    }
+                    if (!taskWindow.isValid(document)) {
+                      continue;
+                    }
+                    check(project, taskWindow, answerFile, answerTaskFile, taskFile, document, testRunner, virtualFile);
+                  }
+                  FileEditor fileEditor = FileEditorManager.getInstance(project).getSelectedEditor(virtualFile);
+                  Editor editor = null;
+                  if (fileEditor instanceof StudyEditor) {
+                    StudyEditor studyEditor = (StudyEditor) fileEditor;
+                    editor = studyEditor.getEditor();
+                  }
+
+                  if (editor != null) {
+                    taskFile.drawAllWindows(editor);
+                    StudyUtils.synchronize();
+                  }
+                  try {
+                    answerFile.delete(this);
+                  }
+                  catch (IOException e) {
+                    LOG.error(e);
+                  }
+                }
+                for (VirtualFile file:filesToDelete) {
+                  try {
+                    file.delete(this);
+                  }
+                  catch (IOException e) {
+                    LOG.error(e);
+                  }
+                }
+                currentTask.setStatus(StudyStatus.Failed, oldStatus);
+                StudyUtils.updateStudyToolWindow(project);
+                createTestResultPopUp(failedMessage, JBColor.RED, project);
+              }
+            }
+          }
+        }
+
+         }
+      });
+      }
+    });
+  }
+
+  private void check(Project project,
+                     TaskWindow taskWindow,
+                     VirtualFile answerFile,
+                     TaskFile answerTaskFile,
+                     TaskFile usersTaskFile,
+                     Document usersDocument,
+                     StudyTestRunner testRunner,
+                     VirtualFile openedFile) {
+
+    try {
+       VirtualFile windowCopy = answerFile.copy(this, answerFile.getParent(), answerFile.getNameWithoutExtension() + "_window" + taskWindow.getIndex() + ".py");
+      final FileDocumentManager documentManager = FileDocumentManager.getInstance();
+      final Document windowDocument = documentManager.getDocument(windowCopy);
+      if (windowDocument != null) {
+        StudyTaskManager taskManager = StudyTaskManager.getInstance(project);
+        Course course = taskManager.getCourse();
+        Task task = usersTaskFile.getTask();
+        int taskNum = task.getIndex() + 1;
+        int lessonNum = task.getLesson().getIndex() + 1;
+        assert course != null;
+        String pathToResource = FileUtil.join(new File(course.getResourcePath()).getParent(), Lesson.LESSON_DIR + lessonNum,  Task.TASK_DIR + taskNum);
+        File resourceFile = new File(pathToResource, windowCopy.getName());
+        FileUtil.copy(new File(pathToResource, openedFile.getName()), resourceFile);
+        TaskFile windowTaskFile = new TaskFile();
+        TaskFile.copy(answerTaskFile, windowTaskFile);
+        StudyDocumentListener listener = new StudyDocumentListener(windowTaskFile);
+        windowDocument.addDocumentListener(listener);
+        int start = taskWindow.getRealStartOffset(windowDocument);
+        int end = start + taskWindow.getLength();
+        TaskWindow userTaskWindow = usersTaskFile.getTaskWindows().get(taskWindow.getIndex());
+        int userStart = userTaskWindow.getRealStartOffset(usersDocument);
+        int userEnd = userStart + userTaskWindow.getLength();
+        String text = usersDocument.getText(new TextRange(userStart, userEnd));
+        windowDocument.replaceString(start, end, text);
+        ApplicationManager.getApplication().runWriteAction(new Runnable() {
+          @Override
+          public void run() {
+            documentManager.saveDocument(windowDocument);
+          }
+        });
+        VirtualFile fileWindows = StudyUtils.flushWindows(windowDocument, windowTaskFile, windowCopy);
+        Process smartTestProcess = testRunner.launchTests(project, windowCopy.getPath());
+        boolean res = testRunner.getPassedTests(smartTestProcess).equals(StudyTestRunner.TEST_OK);
+        userTaskWindow.setStatus(res ? StudyStatus.Solved : StudyStatus.Failed, StudyStatus.Unchecked);
+        windowCopy.delete(this);
+        fileWindows.delete(this);
+        if (!resourceFile.delete()) {
+          LOG.error("failed to delete", resourceFile.getPath());
+        }
+      }
+    }
+    catch (IOException e) {
+      LOG.error(e);
+    }
+    catch (ExecutionException e) {
+      LOG.error(e);
+    }
+  }
+
+
+  private VirtualFile getCopyWithAnswers(final VirtualFile taskDir,
+                                         final VirtualFile file,
+                                         final TaskFile source,
+                                         TaskFile target) {
+    VirtualFile copy = null;
+    try {
+
+      copy = file.copy(this, taskDir, file.getNameWithoutExtension() +"_answers.py");
+      final FileDocumentManager documentManager = FileDocumentManager.getInstance();
+      final Document document = documentManager.getDocument(copy);
+      if (document != null) {
+        TaskFile.copy(source, target);
+        StudyDocumentListener listener = new StudyDocumentListener(target);
+        document.addDocumentListener(listener);
+        for (TaskWindow taskWindow : target.getTaskWindows()) {
+          if (!taskWindow.isValid(document)) {
+            continue;
+          }
+          final int start = taskWindow.getRealStartOffset(document);
+          final int end = start + taskWindow.getLength();
+          final String text = taskWindow.getPossibleAnswer();
+          document.replaceString(start, end, text);
+        }
+        ApplicationManager.getApplication().runWriteAction(new Runnable() {
+          @Override
+          public void run() {
+            documentManager.saveDocument(document);
+          }
+        });
+      }
+    }
+    catch (IOException e) {
+      LOG.error(e);
+    }
+
+
+    return copy;
+  }
+
+  private static void createTestResultPopUp(final String text, Color color, @NotNull final Project project) {
+    BalloonBuilder balloonBuilder =
+      JBPopupFactory.getInstance().createHtmlTextBalloonBuilder(text, null, color, null);
+    Balloon balloon = balloonBuilder.createBalloon();
+    StudyEditor studyEditor = StudyEditor.getSelectedStudyEditor(project);
+    assert studyEditor != null;
+    JButton checkButton = studyEditor.getCheckButton();
+    balloon.showInCenterOf(checkButton);
+  }
+
+  @Override
+  public void actionPerformed(AnActionEvent e) {
+    Project project = e.getProject();
+    if (project != null) {
+      check(project);
+    }
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyEditInputAction.java b/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyEditInputAction.java
new file mode 100644
index 0000000..5b9a6fe
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyEditInputAction.java
@@ -0,0 +1,213 @@
+package com.jetbrains.python.edu.actions;
+
+import com.intellij.icons.AllIcons;
+import com.intellij.ide.ui.UISettings;
+import com.intellij.openapi.actionSystem.*;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.fileEditor.FileDocumentManager;
+import com.intellij.openapi.project.DumbAware;
+import com.intellij.openapi.project.DumbAwareAction;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.ui.popup.JBPopup;
+import com.intellij.openapi.ui.popup.JBPopupAdapter;
+import com.intellij.openapi.ui.popup.JBPopupFactory;
+import com.intellij.openapi.ui.popup.LightweightWindowEvent;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.wm.IdeFocusManager;
+import com.intellij.ui.tabs.TabInfo;
+import com.intellij.ui.tabs.TabsListener;
+import com.intellij.ui.tabs.impl.JBEditorTabs;
+import com.jetbrains.python.edu.StudyTaskManager;
+import com.jetbrains.python.edu.StudyUtils;
+import com.jetbrains.python.edu.course.Task;
+import com.jetbrains.python.edu.course.TaskFile;
+import com.jetbrains.python.edu.course.UserTest;
+import com.jetbrains.python.edu.editor.StudyEditor;
+import com.jetbrains.python.edu.ui.StudyTestContentPanel;
+import icons.StudyIcons;
+import org.jetbrains.annotations.NotNull;
+
+import javax.swing.*;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.PrintWriter;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class StudyEditInputAction extends DumbAwareAction {
+
+  public static final String TEST_TAB_NAME = "test";
+  public static final String USER_TEST_INPUT = "input";
+  public static final String USER_TEST_OUTPUT = "output";
+  private static final Logger LOG = Logger.getInstance(StudyEditInputAction.class.getName());
+  private JBEditorTabs tabbedPane;
+  private Map<TabInfo, UserTest> myEditableTabs = new HashMap<TabInfo, UserTest>();
+
+  public void showInput(final Project project) {
+    final Editor selectedEditor = StudyEditor.getSelectedEditor(project);
+    if (selectedEditor != null) {
+      FileDocumentManager fileDocumentManager = FileDocumentManager.getInstance();
+      final VirtualFile openedFile = fileDocumentManager.getFile(selectedEditor.getDocument());
+      StudyTaskManager studyTaskManager = StudyTaskManager.getInstance(project);
+      assert openedFile != null;
+      TaskFile taskFile = studyTaskManager.getTaskFile(openedFile);
+      assert taskFile != null;
+      final Task currentTask = taskFile.getTask();
+      tabbedPane = new JBEditorTabs(project, ActionManager.getInstance(), IdeFocusManager.findInstance(), project);
+      tabbedPane.addListener(new TabsListener.Adapter() {
+        @Override
+        public void selectionChanged(TabInfo oldSelection, TabInfo newSelection) {
+          if (newSelection.getIcon() != null) {
+            int tabCount = tabbedPane.getTabCount();
+            VirtualFile taskDir = openedFile.getParent();
+            VirtualFile testsDir = taskDir.findChild(Task.USER_TESTS);
+            assert testsDir != null;
+            UserTest userTest = createUserTest(testsDir, currentTask);
+            userTest.setEditable(true);
+            StudyTestContentPanel testContentPanel = new StudyTestContentPanel(userTest);
+            TabInfo testTab = addTestTab(tabbedPane.getTabCount(), testContentPanel, currentTask, true);
+            myEditableTabs.put(testTab, userTest);
+            tabbedPane.addTabSilently(testTab, tabCount - 1);
+            tabbedPane.select(testTab, true);
+          }
+        }
+      });
+      List<UserTest> userTests = currentTask.getUserTests();
+      int i = 1;
+      for (UserTest userTest : userTests) {
+        String inputFileText = StudyUtils.getFileText(null, userTest.getInput(), false);
+        String outputFileText = StudyUtils.getFileText(null, userTest.getOutput(), false);
+        StudyTestContentPanel myContentPanel = new StudyTestContentPanel(userTest);
+        myContentPanel.addInputContent(inputFileText);
+        myContentPanel.addOutputContent(outputFileText);
+        TabInfo testTab = addTestTab(i, myContentPanel, currentTask, userTest.isEditable());
+        tabbedPane.addTabSilently(testTab, i - 1);
+        if (userTest.isEditable()) {
+          myEditableTabs.put(testTab, userTest);
+        }
+        i++;
+      }
+      TabInfo plusTab = new TabInfo(new JPanel());
+      plusTab.setIcon(StudyIcons.Add);
+      tabbedPane.addTabSilently(plusTab, tabbedPane.getTabCount());
+      final JBPopup hint =
+        JBPopupFactory.getInstance().createComponentPopupBuilder(tabbedPane.getComponent(), tabbedPane.getComponent())
+          .setResizable(true)
+          .setMovable(true)
+          .setRequestFocus(true)
+          .createPopup();
+      StudyEditor selectedStudyEditor = StudyEditor.getSelectedStudyEditor(project);
+      assert selectedStudyEditor != null;
+      hint.showInCenterOf(selectedStudyEditor.getComponent());
+      hint.addListener(new HintClosedListener(currentTask));
+    }
+  }
+
+
+  private static void flushBuffer(@NotNull final StringBuilder buffer, @NotNull final File file) {
+    PrintWriter printWriter = null;
+    try {
+      printWriter = new PrintWriter(new FileOutputStream(file));
+      printWriter.print(buffer.toString());
+    }
+    catch (FileNotFoundException e) {
+      LOG.error(e);
+    }
+    finally {
+      StudyUtils.closeSilently(printWriter);
+    }
+    StudyUtils.synchronize();
+  }
+
+  private static UserTest createUserTest(@NotNull final VirtualFile testsDir, @NotNull final Task currentTask) {
+    UserTest userTest = new UserTest();
+    List<UserTest> userTests = currentTask.getUserTests();
+    int testNum = userTests.size() + 1;
+    String inputName = USER_TEST_INPUT + testNum;
+    File inputFile = new File(testsDir.getPath(), inputName);
+    String outputName = USER_TEST_OUTPUT + testNum;
+    File outputFile = new File(testsDir.getPath(), outputName);
+    userTest.setInput(inputFile.getPath());
+    userTest.setOutput(outputFile.getPath());
+    userTests.add(userTest);
+    return userTest;
+  }
+
+  private TabInfo addTestTab(int nameIndex, final StudyTestContentPanel contentPanel, @NotNull final Task currentTask, boolean toBeClosable) {
+    TabInfo testTab = toBeClosable ? createClosableTab(contentPanel, currentTask) : new TabInfo(contentPanel);
+    return testTab.setText(TEST_TAB_NAME + String.valueOf(nameIndex));
+  }
+
+  private TabInfo createClosableTab(StudyTestContentPanel contentPanel, Task currentTask) {
+    TabInfo closableTab = new TabInfo(contentPanel);
+    final DefaultActionGroup tabActions = new DefaultActionGroup();
+    tabActions.add(new CloseTab(closableTab, currentTask));
+    closableTab.setTabLabelActions(tabActions, ActionPlaces.EDITOR_TAB);
+    return closableTab;
+  }
+
+  public void actionPerformed(AnActionEvent e) {
+    showInput(e.getProject());
+  }
+
+  private class HintClosedListener extends  JBPopupAdapter {
+    private final Task myTask;
+    private HintClosedListener(@NotNull final Task task) {
+      myTask = task;
+    }
+
+    @Override
+    public void onClosed(LightweightWindowEvent event) {
+      for (final UserTest userTest : myTask.getUserTests()) {
+        ApplicationManager.getApplication().runWriteAction(new Runnable() {
+          @Override
+          public void run() {
+            if (userTest.isEditable()) {
+              File inputFile = new File(userTest.getInput());
+              File outputFile = new File(userTest.getOutput());
+              flushBuffer(userTest.getInputBuffer(), inputFile);
+              flushBuffer(userTest.getOutputBuffer(), outputFile);
+            }
+          }
+        });
+      }
+    }
+  }
+
+  private class CloseTab extends AnAction implements DumbAware {
+
+    private final TabInfo myTabInfo;
+    private final Task myTask;
+
+    public CloseTab(final TabInfo info, @NotNull final Task task) {
+      myTabInfo = info;
+      myTask = task;
+    }
+
+    @Override
+    public void update(final AnActionEvent e) {
+      e.getPresentation().setIcon(tabbedPane.isEditorTabs() ? AllIcons.Actions.CloseNew : AllIcons.Actions.Close);
+      e.getPresentation().setHoveredIcon(tabbedPane.isEditorTabs() ? AllIcons.Actions.CloseNewHovered : AllIcons.Actions.CloseHovered);
+      e.getPresentation().setVisible(UISettings.getInstance().SHOW_CLOSE_BUTTON);
+      e.getPresentation().setText("Delete test");
+    }
+
+    @Override
+    public void actionPerformed(final AnActionEvent e) {
+      tabbedPane.removeTab(myTabInfo);
+      UserTest userTest = myEditableTabs.get(myTabInfo);
+      File testInputFile = new File(userTest.getInput());
+      File testOutputFile = new File(userTest.getOutput());
+      if (testInputFile.delete() && testOutputFile.delete()) {
+        StudyUtils.synchronize();
+      } else {
+        LOG.error("failed to delete user tests");
+      }
+      myTask.getUserTests().remove(userTest);
+    }
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyNextStudyTaskAction.java b/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyNextStudyTaskAction.java
new file mode 100644
index 0000000..81818a9
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyNextStudyTaskAction.java
@@ -0,0 +1,24 @@
+package com.jetbrains.python.edu.actions;
+
+import com.jetbrains.python.edu.editor.StudyEditor;
+import com.jetbrains.python.edu.course.Task;
+
+import javax.swing.*;
+
+public class StudyNextStudyTaskAction extends StudyTaskNavigationAction {
+
+  @Override
+  protected JButton getButton(StudyEditor selectedStudyEditor) {
+    return selectedStudyEditor.getNextTaskButton();
+  }
+
+  @Override
+  protected String getNavigationFinishedMessage() {
+    return "It's the last task";
+  }
+
+  @Override
+  protected Task getTargetTask(Task sourceTask) {
+    return sourceTask.next();
+  }
+}
\ No newline at end of file
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyNextWindowAction.java b/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyNextWindowAction.java
new file mode 100644
index 0000000..595aeef
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyNextWindowAction.java
@@ -0,0 +1,32 @@
+package com.jetbrains.python.edu.actions;
+
+import com.jetbrains.python.edu.StudyUtils;
+import com.jetbrains.python.edu.course.TaskWindow;
+import icons.StudyIcons;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+/**
+ * move caret to next task window
+ */
+public class StudyNextWindowAction extends StudyWindowNavigationAction {
+  public static final String ACTION_ID = "NextWindow";
+  public static final String SHORTCUT = "ctrl pressed PERIOD";
+  public static final String SHORTCUT2 = "ctrl pressed ENTER";
+
+  public StudyNextWindowAction() {
+    super("NextWindowAction", "Select next window", StudyIcons.Next);
+  }
+
+  @Override
+  protected TaskWindow getNextTaskWindow(@NotNull final TaskWindow window) {
+    int index = window.getIndex();
+    List<TaskWindow> windows = window.getTaskFile().getTaskWindows();
+    if (StudyUtils.indexIsValid(index, windows)) {
+      int newIndex = index + 1;
+        return newIndex == windows.size() ? windows.get(0) : windows.get(newIndex);
+    }
+    return null;
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyPrevWindowAction.java b/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyPrevWindowAction.java
new file mode 100644
index 0000000..3474561
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyPrevWindowAction.java
@@ -0,0 +1,34 @@
+package com.jetbrains.python.edu.actions;
+
+import com.jetbrains.python.edu.StudyUtils;
+import com.jetbrains.python.edu.course.TaskWindow;
+import icons.StudyIcons;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+/**
+ * author: liana
+ * data: 6/30/14.
+ */
+public class StudyPrevWindowAction extends StudyWindowNavigationAction {
+  public static final String ACTION_ID = "PrevWindowAction";
+  public static final String SHORTCUT = "ctrl pressed COMMA";
+
+  public StudyPrevWindowAction() {
+    super("PrevWindowAction", "Select previous window", StudyIcons.Prev);
+  }
+
+
+  @Nullable
+  @Override
+  protected TaskWindow getNextTaskWindow(@NotNull final TaskWindow window) {
+    int prevIndex = window.getIndex() - 1;
+    List<TaskWindow> windows = window.getTaskFile().getTaskWindows();
+    if (StudyUtils.indexIsValid(prevIndex, windows)) {
+      return windows.get(prevIndex);
+    }
+    return null;
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyPreviousStudyTaskAction.java b/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyPreviousStudyTaskAction.java
new file mode 100644
index 0000000..bc26c28
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyPreviousStudyTaskAction.java
@@ -0,0 +1,25 @@
+package com.jetbrains.python.edu.actions;
+
+
+import com.jetbrains.python.edu.editor.StudyEditor;
+import com.jetbrains.python.edu.course.Task;
+
+import javax.swing.*;
+
+public class StudyPreviousStudyTaskAction extends StudyTaskNavigationAction {
+
+  @Override
+  protected JButton getButton(StudyEditor selectedStudyEditor) {
+    return selectedStudyEditor.getPrevTaskButton();
+  }
+
+  @Override
+  protected String getNavigationFinishedMessage() {
+    return "It's already the first task";
+  }
+
+  @Override
+  protected Task getTargetTask(Task sourceTask) {
+    return sourceTask.prev();
+  }
+}
\ No newline at end of file
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyRefreshTaskAction.java b/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyRefreshTaskAction.java
new file mode 100644
index 0000000..f8abb0b
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyRefreshTaskAction.java
@@ -0,0 +1,122 @@
+package com.jetbrains.python.edu.actions;
+
+import com.intellij.ide.projectView.ProjectView;
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.command.CommandProcessor;
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.editor.Document;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.fileEditor.FileDocumentManager;
+import com.intellij.openapi.project.DumbAwareAction;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.ui.MessageType;
+import com.intellij.openapi.ui.popup.Balloon;
+import com.intellij.openapi.ui.popup.BalloonBuilder;
+import com.intellij.openapi.ui.popup.JBPopupFactory;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.wm.IdeFocusManager;
+import com.jetbrains.python.edu.StudyDocumentListener;
+import com.jetbrains.python.edu.StudyTaskManager;
+import com.jetbrains.python.edu.StudyUtils;
+import com.jetbrains.python.edu.course.*;
+import com.jetbrains.python.edu.editor.StudyEditor;
+
+import java.io.*;
+
+public class StudyRefreshTaskAction extends DumbAwareAction {
+  private static final Logger LOG = Logger.getInstance(StudyRefreshTaskAction.class.getName());
+
+  public void refresh(final Project project) {
+        ApplicationManager.getApplication().invokeLater(new Runnable() {
+          @Override
+          public void run() {
+            ApplicationManager.getApplication().runWriteAction(new Runnable() {
+              @SuppressWarnings("IOResourceOpenedButNotSafelyClosed")
+              @Override
+              public void run() {
+                final Editor editor = StudyEditor.getSelectedEditor(project);
+                assert editor != null;
+                final Document document = editor.getDocument();
+                StudyDocumentListener listener = StudyEditor.getListener(document);
+                if (listener != null) {
+                  document.removeDocumentListener(listener);
+                }
+                final int lineCount = document.getLineCount();
+                if (lineCount != 0) {
+                  CommandProcessor.getInstance().runUndoTransparentAction(new Runnable() {
+                    @Override
+                    public void run() {
+                      document.deleteString(0, document.getLineEndOffset(lineCount - 1));
+                    }
+                  });
+                }
+                StudyTaskManager taskManager = StudyTaskManager.getInstance(project);
+                Course course = taskManager.getCourse();
+                assert course != null;
+                File resourceFile = new File(course.getResourcePath());
+                File resourceRoot = resourceFile.getParentFile();
+                FileDocumentManager fileDocumentManager = FileDocumentManager.getInstance();
+                VirtualFile openedFile = fileDocumentManager.getFile(document);
+                assert openedFile != null;
+                final TaskFile selectedTaskFile = taskManager.getTaskFile(openedFile);
+                assert selectedTaskFile != null;
+                Task currentTask = selectedTaskFile.getTask();
+                String lessonDir = Lesson.LESSON_DIR + String.valueOf(currentTask.getLesson().getIndex() + 1);
+                String taskDir = Task.TASK_DIR + String.valueOf(currentTask.getIndex() + 1);
+                File pattern = new File(new File(new File(resourceRoot, lessonDir), taskDir), openedFile.getName());
+                BufferedReader reader = null;
+                try {
+                  reader = new BufferedReader(new InputStreamReader(new FileInputStream(pattern)));
+                  String line;
+                  StringBuilder patternText = new StringBuilder();
+                  while ((line = reader.readLine()) != null) {
+                    patternText.append(line);
+                    patternText.append("\n");
+                  }
+                  int patternLength = patternText.length();
+                  if (patternText.charAt(patternLength - 1) == '\n') {
+                    patternText.delete(patternLength - 1, patternLength);
+                  }
+                  document.setText(patternText);
+                  StudyStatus oldStatus = currentTask.getStatus();
+                  LessonInfo lessonInfo = currentTask.getLesson().getLessonInfo();
+                  lessonInfo.update(oldStatus, -1);
+                  lessonInfo.update(StudyStatus.Unchecked, +1);
+                  StudyUtils.updateStudyToolWindow(project);
+                  for (TaskWindow taskWindow : selectedTaskFile.getTaskWindows()) {
+                    taskWindow.reset();
+                  }
+                  ProjectView.getInstance(project).refresh();
+                  if (listener != null) {
+                    document.addDocumentListener(listener);
+                  }
+                  selectedTaskFile.drawAllWindows(editor);
+                  IdeFocusManager.getInstance(project).requestFocus(editor.getContentComponent(), true);
+                  selectedTaskFile.navigateToFirstTaskWindow(editor);
+                  BalloonBuilder balloonBuilder =
+                    JBPopupFactory.getInstance().createHtmlTextBalloonBuilder("You can now start again", MessageType.INFO, null);
+                  Balloon balloon = balloonBuilder.createBalloon();
+                  StudyEditor selectedStudyEditor = StudyEditor.getSelectedStudyEditor(project);
+                  assert selectedStudyEditor != null;
+                  balloon.showInCenterOf(selectedStudyEditor.getRefreshButton());
+                }
+                catch (FileNotFoundException e1) {
+                  LOG.error(e1);
+                }
+                catch (IOException e1) {
+                  LOG.error(e1);
+                }
+                finally {
+                  StudyUtils.closeSilently(reader);
+                }
+              }
+            });
+          }
+        });
+  }
+
+  public void actionPerformed(AnActionEvent e) {
+    refresh(e.getProject());
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyRunAction.java b/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyRunAction.java
new file mode 100644
index 0000000..71e95de
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyRunAction.java
@@ -0,0 +1,89 @@
+package com.jetbrains.python.edu.actions;
+
+import com.intellij.execution.ExecutionException;
+import com.intellij.execution.RunContentExecutor;
+import com.intellij.execution.configurations.GeneralCommandLine;
+import com.intellij.execution.process.OSProcessHandler;
+import com.intellij.execution.process.ProcessHandler;
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.fileEditor.FileDocumentManager;
+import com.intellij.openapi.module.ModuleManager;
+import com.intellij.openapi.project.DumbAwareAction;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.projectRoots.Sdk;
+import com.intellij.openapi.util.Disposer;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.jetbrains.python.sdk.PythonSdkType;
+import com.jetbrains.python.edu.StudyResourceManger;
+import com.jetbrains.python.edu.StudyTaskManager;
+import com.jetbrains.python.edu.course.Task;
+import com.jetbrains.python.edu.course.TaskFile;
+import com.jetbrains.python.edu.editor.StudyEditor;
+
+import java.io.File;
+
+public class StudyRunAction extends DumbAwareAction {
+  private static final Logger LOG = Logger.getInstance(StudyRunAction.class.getName());
+  public static final String ACTION_ID = "StudyRunAction";
+
+  public void run(Project project) {
+    Editor selectedEditor = StudyEditor.getSelectedEditor(project);
+    FileDocumentManager fileDocumentManager = FileDocumentManager.getInstance();
+    assert selectedEditor != null;
+    VirtualFile openedFile = fileDocumentManager.getFile(selectedEditor.getDocument());
+    StudyTaskManager taskManager = StudyTaskManager.getInstance(project);
+    if (openedFile != null && openedFile.getCanonicalPath() != null) {
+      String filePath = openedFile.getCanonicalPath();
+      GeneralCommandLine cmd = new GeneralCommandLine();
+      cmd.setWorkDirectory(openedFile.getParent().getCanonicalPath());
+      Sdk sdk = PythonSdkType.findPythonSdk(ModuleManager.getInstance(project).getModules()[0]);
+      if (sdk != null) {
+        String pythonPath = sdk.getHomePath();
+        if (pythonPath != null) {
+          cmd.setExePath(pythonPath);
+          TaskFile selectedTaskFile = taskManager.getTaskFile(openedFile);
+          assert selectedTaskFile != null;
+          Task currentTask = selectedTaskFile.getTask();
+          if (!currentTask.getUserTests().isEmpty()) {
+            cmd.addParameter(new File(project.getBaseDir().getPath(), StudyResourceManger.USER_TESTER).getPath());
+            cmd.addParameter(pythonPath);
+            cmd.addParameter(filePath);
+            Process p;
+            try {
+              p = cmd.createProcess();
+            }
+            catch (ExecutionException e) {
+              LOG.error(e);
+              return;
+            }
+            ProcessHandler handler = new OSProcessHandler(p);
+
+            RunContentExecutor executor = new RunContentExecutor(project, handler);
+            Disposer.register(project, executor);
+            executor.run();
+            return;
+          }
+          try {
+            cmd.addParameter(filePath);
+            Process p = cmd.createProcess();
+            ProcessHandler handler = new OSProcessHandler(p);
+
+            RunContentExecutor executor = new RunContentExecutor(project, handler);
+            Disposer.register(project, executor);
+            executor.run();
+          }
+
+          catch (ExecutionException e) {
+            LOG.error(e);
+          }
+        }
+      }
+    }
+  }
+
+  public void actionPerformed(AnActionEvent e) {
+    run(e.getProject());
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyShowHintAction.java b/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyShowHintAction.java
new file mode 100644
index 0000000..1efa908
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyShowHintAction.java
@@ -0,0 +1,95 @@
+package com.jetbrains.python.edu.actions;
+
+import com.intellij.codeInsight.documentation.DocumentationComponent;
+import com.intellij.codeInsight.documentation.DocumentationManager;
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.editor.LogicalPosition;
+import com.intellij.openapi.fileEditor.FileDocumentManager;
+import com.intellij.openapi.project.DumbAwareAction;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.ui.popup.JBPopup;
+import com.intellij.openapi.ui.popup.JBPopupFactory;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import com.intellij.psi.PsiManager;
+import com.jetbrains.python.edu.StudyTaskManager;
+import com.jetbrains.python.edu.StudyUtils;
+import com.jetbrains.python.edu.course.Course;
+import com.jetbrains.python.edu.course.TaskFile;
+import com.jetbrains.python.edu.course.TaskWindow;
+import com.jetbrains.python.edu.editor.StudyEditor;
+import icons.StudyIcons;
+
+import java.io.File;
+
+public class StudyShowHintAction extends DumbAwareAction {
+  public static final String ACTION_ID = "ShowHintAction";
+  public static final String SHORTCUT = "ctrl pressed 7";
+
+  public StudyShowHintAction() {
+    super("Show hint", "Show hint", StudyIcons.ShowHint);
+  }
+
+  public void actionPerformed(AnActionEvent e) {
+    Project project = e.getProject();
+    if (project != null) {
+      DocumentationManager documentationManager = DocumentationManager.getInstance(project);
+      DocumentationComponent component = new DocumentationComponent(documentationManager);
+      Editor selectedEditor = StudyEditor.getSelectedEditor(project);
+      FileDocumentManager fileDocumentManager = FileDocumentManager.getInstance();
+      assert selectedEditor != null;
+      VirtualFile openedFile = fileDocumentManager.getFile(selectedEditor.getDocument());
+      if (openedFile != null) {
+        StudyTaskManager taskManager = StudyTaskManager.getInstance(e.getProject());
+        TaskFile taskFile = taskManager.getTaskFile(openedFile);
+        if (taskFile != null) {
+          PsiFile file = PsiManager.getInstance(project).findFile(openedFile);
+          if (file != null) {
+            LogicalPosition pos = selectedEditor.getCaretModel().getLogicalPosition();
+            TaskWindow taskWindow = taskFile.getTaskWindow(selectedEditor.getDocument(), pos);
+            if (taskWindow != null) {
+              String hint = taskWindow.getHint();
+              if (hint == null) {
+                return;
+              }
+              Course course = taskManager.getCourse();
+              if (course != null) {
+                File resourceFile = new File(course.getResourcePath());
+                File resourceRoot = resourceFile.getParentFile();
+                if (resourceRoot != null && resourceRoot.exists()) {
+                  File hintsDir = new File(resourceRoot, Course.HINTS_DIR);
+                  if (hintsDir.exists()) {
+                    String hintText = StudyUtils.getFileText(hintsDir.getAbsolutePath(), hint, true);
+                    if (hintText != null) {
+                      int offset = selectedEditor.getDocument().getLineStartOffset(pos.line) + pos.column;
+                      PsiElement element = file.findElementAt(offset);
+                      if (element != null) {
+                        component.setData(element, hintText, true, null);
+                        final JBPopup popup =
+                          JBPopupFactory.getInstance().createComponentPopupBuilder(component, component)
+                            .setDimensionServiceKey(project, DocumentationManager.JAVADOC_LOCATION_AND_SIZE, false)
+                            .setResizable(true)
+                            .setMovable(true)
+                            .setRequestFocus(true)
+                            .createPopup();
+                        component.setHint(popup);
+                        popup.showInBestPositionFor(selectedEditor);
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  @Override
+  public void update(AnActionEvent e) {
+    StudyUtils.updateAction(e);
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyTaskNavigationAction.java b/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyTaskNavigationAction.java
new file mode 100644
index 0000000..b781e7d
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyTaskNavigationAction.java
@@ -0,0 +1,97 @@
+package com.jetbrains.python.edu.actions;
+
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.fileEditor.FileDocumentManager;
+import com.intellij.openapi.fileEditor.FileEditorManager;
+import com.intellij.openapi.project.DumbAwareAction;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.ui.MessageType;
+import com.intellij.openapi.ui.popup.Balloon;
+import com.intellij.openapi.ui.popup.BalloonBuilder;
+import com.intellij.openapi.ui.popup.JBPopupFactory;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.jetbrains.python.edu.StudyTaskManager;
+import com.jetbrains.python.edu.course.Lesson;
+import com.jetbrains.python.edu.course.Task;
+import com.jetbrains.python.edu.course.TaskFile;
+import com.jetbrains.python.edu.editor.StudyEditor;
+
+import javax.swing.*;
+import java.util.Map;
+
+/**
+ * author: liana
+ * data: 7/21/14.
+ */
+abstract public class StudyTaskNavigationAction extends DumbAwareAction {
+  public void navigateTask(Project project) {
+    Editor selectedEditor = StudyEditor.getSelectedEditor(project);
+    FileDocumentManager fileDocumentManager = FileDocumentManager.getInstance();
+    assert selectedEditor != null;
+    VirtualFile openedFile = fileDocumentManager.getFile(selectedEditor.getDocument());
+    StudyTaskManager taskManager = StudyTaskManager.getInstance(project);
+    assert openedFile != null;
+    TaskFile selectedTaskFile = taskManager.getTaskFile(openedFile);
+    assert selectedTaskFile != null;
+    Task currentTask = selectedTaskFile.getTask();
+    Task nextTask = getTargetTask(currentTask);
+    if (nextTask == null) {
+      BalloonBuilder balloonBuilder =
+        JBPopupFactory.getInstance().createHtmlTextBalloonBuilder(getNavigationFinishedMessage(), MessageType.INFO, null);
+      Balloon balloon = balloonBuilder.createBalloon();
+      StudyEditor selectedStudyEditor = StudyEditor.getSelectedStudyEditor(project);
+      balloon.showInCenterOf(getButton(selectedStudyEditor));
+      return;
+    }
+    for (VirtualFile file : FileEditorManager.getInstance(project).getOpenFiles()) {
+      FileEditorManager.getInstance(project).closeFile(file);
+    }
+    int nextTaskIndex = nextTask.getIndex();
+    int lessonIndex = nextTask.getLesson().getIndex();
+    Map<String, TaskFile> nextTaskFiles = nextTask.getTaskFiles();
+    if (nextTaskFiles.isEmpty()) {
+      return;
+    }
+    VirtualFile projectDir = project.getBaseDir();
+    String lessonDirName = Lesson.LESSON_DIR + String.valueOf(lessonIndex + 1);
+    if (projectDir == null) {
+      return;
+    }
+    VirtualFile lessonDir = projectDir.findChild(lessonDirName);
+    if (lessonDir == null) {
+      return;
+    }
+    String taskDirName = Task.TASK_DIR + String.valueOf(nextTaskIndex + 1);
+    VirtualFile taskDir = lessonDir.findChild(taskDirName);
+    if (taskDir == null) {
+      return;
+    }
+    VirtualFile shouldBeActive = null;
+    for (Map.Entry<String, TaskFile> entry : nextTaskFiles.entrySet()) {
+      String name = entry.getKey();
+      TaskFile taskFile = entry.getValue();
+      VirtualFile vf = taskDir.findChild(name);
+      if (vf != null) {
+        FileEditorManager.getInstance(project).openFile(vf, true);
+        if (!taskFile.getTaskWindows().isEmpty()) {
+          shouldBeActive = vf;
+        }
+      }
+    }
+    if (shouldBeActive != null) {
+      FileEditorManager.getInstance(project).openFile(shouldBeActive, true);
+    }
+  }
+
+  protected abstract JButton getButton(StudyEditor selectedStudyEditor);
+
+  @Override
+  public void actionPerformed(AnActionEvent e) {
+    navigateTask(e.getProject());
+  }
+
+  protected abstract String getNavigationFinishedMessage();
+
+  protected abstract Task getTargetTask(Task sourceTask);
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyWindowNavigationAction.java b/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyWindowNavigationAction.java
new file mode 100644
index 0000000..8c6b902
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/actions/StudyWindowNavigationAction.java
@@ -0,0 +1,65 @@
+package com.jetbrains.python.edu.actions;
+
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.fileEditor.FileDocumentManager;
+import com.intellij.openapi.project.DumbAwareAction;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.jetbrains.python.edu.StudyTaskManager;
+import com.jetbrains.python.edu.StudyUtils;
+import com.jetbrains.python.edu.course.TaskFile;
+import com.jetbrains.python.edu.course.TaskWindow;
+import com.jetbrains.python.edu.editor.StudyEditor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import javax.swing.*;
+
+abstract public class StudyWindowNavigationAction extends DumbAwareAction {
+
+  public StudyWindowNavigationAction(String actionId, String description, Icon icon) {
+    super(actionId, description, icon);
+  }
+
+  public void navigateWindow(@NotNull final Project project) {
+      Editor selectedEditor = StudyEditor.getSelectedEditor(project);
+      if (selectedEditor != null) {
+        FileDocumentManager fileDocumentManager = FileDocumentManager.getInstance();
+        VirtualFile openedFile = fileDocumentManager.getFile(selectedEditor.getDocument());
+        if (openedFile != null) {
+          StudyTaskManager taskManager = StudyTaskManager.getInstance(project);
+          TaskFile selectedTaskFile = taskManager.getTaskFile(openedFile);
+          if (selectedTaskFile != null) {
+            TaskWindow selectedTaskWindow = selectedTaskFile.getSelectedTaskWindow();
+            if (selectedTaskWindow == null) {
+              return;
+            }
+            TaskWindow nextTaskWindow = getNextTaskWindow(selectedTaskWindow);
+            if (nextTaskWindow == null) {
+              return;
+            }
+            nextTaskWindow.draw(selectedEditor, true, true);
+            selectedTaskFile.setSelectedTaskWindow(nextTaskWindow);
+            }
+          }
+        }
+      }
+
+  @Nullable
+  protected abstract TaskWindow getNextTaskWindow(@NotNull final TaskWindow window);
+
+  @Override
+  public void actionPerformed(AnActionEvent e) {
+    Project project = e.getProject();
+    if (project == null) {
+      return;
+    }
+    navigateWindow(project);
+  }
+
+  @Override
+  public void update(AnActionEvent e) {
+    StudyUtils.updateAction(e);
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/course/Course.java b/python/edu/learn-python/src/com/jetbrains/python/edu/course/Course.java
new file mode 100644
index 0000000..89613ac
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/course/Course.java
@@ -0,0 +1,104 @@
+package com.jetbrains.python.edu.course;
+
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.openapi.vfs.VirtualFile;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.File;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Course {
+
+  private static final Logger LOG = Logger.getInstance(Course.class.getName());
+  public static final String PLAYGROUND_DIR = "Playground";
+  public List<Lesson> lessons = new ArrayList<Lesson>();
+  public String description;
+  public String name;
+  public String myResourcePath = "";
+  public String author;
+  public static final String COURSE_DIR = "course";
+  public static final String HINTS_DIR = "hints";
+
+
+  public List<Lesson> getLessons() {
+    return lessons;
+  }
+
+  /**
+   * Initializes state of course
+   */
+  public void init(boolean isRestarted) {
+    for (Lesson lesson : lessons) {
+      lesson.init(this, isRestarted);
+    }
+  }
+
+  public String getAuthor() {
+    return author;
+  }
+
+  /**
+   * Creates course directory in project user created
+   *
+   * @param baseDir      project directory
+   * @param resourceRoot directory where original course is stored
+   */
+  public void create(@NotNull final VirtualFile baseDir, @NotNull final File resourceRoot) {
+    ApplicationManager.getApplication().invokeLater(
+      new Runnable() {
+        @Override
+        public void run() {
+          ApplicationManager.getApplication().runWriteAction(new Runnable() {
+            @Override
+            public void run() {
+              try {
+                for (int i = 0; i < lessons.size(); i++) {
+                  Lesson lesson = lessons.get(i);
+                  lesson.setIndex(i);
+                  lesson.create(baseDir, resourceRoot);
+                }
+                baseDir.createChildDirectory(this, PLAYGROUND_DIR);
+                File[] files = resourceRoot.listFiles(new FilenameFilter() {
+                  @Override
+                  public boolean accept(File dir, String name) {
+                   return !name.contains(Lesson.LESSON_DIR) && !name.equals("course.json") && !name.equals("hints");
+                  }
+                });
+                for (File file: files) {
+                  FileUtil.copy(file, new File(baseDir.getPath(), file.getName()));
+                }
+              }
+              catch (IOException e) {
+                LOG.error(e);
+              }
+            }
+          });
+        }
+      });
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public void setResourcePath(@NotNull final String resourcePath) {
+    myResourcePath = resourcePath;
+  }
+
+  public String getResourcePath() {
+    return myResourcePath;
+  }
+
+  public String getDescription() {
+    return description;
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/course/CourseInfo.java b/python/edu/learn-python/src/com/jetbrains/python/edu/course/CourseInfo.java
new file mode 100644
index 0000000..9f820c1
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/course/CourseInfo.java
@@ -0,0 +1,52 @@
+package com.jetbrains.python.edu.course;
+
+/**
+ * Implementation of class which contains information to be shawn in course description in tool window
+ * and when project is being created
+ */
+public class CourseInfo {
+  private String myName;
+  private String myAuthor;
+  private String myDescription;
+  public static CourseInfo INVALID_COURSE = new CourseInfo("", "", "");
+
+  public CourseInfo(String name, String author, String description) {
+    myName = name;
+    myAuthor = author;
+    myDescription = description;
+  }
+
+  public String getName() {
+    return myName;
+  }
+
+  public String getAuthor() {
+    return myAuthor;
+  }
+
+  public String getDescription() {
+    return myDescription;
+  }
+
+  @Override
+  public String toString() {
+    return myName;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    CourseInfo that = (CourseInfo)o;
+    return that.getName().equals(myName) && that.getAuthor().equals(myAuthor)
+           && that.getDescription().equals(myDescription);
+  }
+
+  @Override
+  public int hashCode() {
+    int result = myName != null ? myName.hashCode() : 0;
+    result = 31 * result + (myAuthor != null ? myAuthor.hashCode() : 0);
+    result = 31 * result + (myDescription != null ? myDescription.hashCode() : 0);
+    return result;
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/course/Lesson.java b/python/edu/learn-python/src/com/jetbrains/python/edu/course/Lesson.java
new file mode 100644
index 0000000..3879d51
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/course/Lesson.java
@@ -0,0 +1,109 @@
+package com.jetbrains.python.edu.course;
+
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.util.xmlb.annotations.Transient;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Lesson implements Stateful{
+  public String name;
+  public List<Task> taskList = new ArrayList<Task>();
+  private Course myCourse = null;
+  public int myIndex = -1;
+  public static final String LESSON_DIR = "lesson";
+  public LessonInfo myLessonInfo = new LessonInfo();
+
+  public LessonInfo getLessonInfo() {
+    return myLessonInfo;
+  }
+
+  @Transient
+  public StudyStatus getStatus() {
+    for (Task task : taskList) {
+      StudyStatus taskStatus = task.getStatus();
+      if (taskStatus == StudyStatus.Unchecked || taskStatus == StudyStatus.Failed) {
+        return StudyStatus.Unchecked;
+      }
+    }
+    return StudyStatus.Solved;
+  }
+
+  @Override
+  public void setStatus(StudyStatus status, StudyStatus oldStatus) {
+    for (Task task : taskList) {
+      task.setStatus(status, oldStatus);
+    }
+  }
+
+  public List<Task> getTaskList() {
+    return taskList;
+  }
+
+
+  public String getName() {
+    return name;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  /**
+   * Creates lesson directory in its course folder in project user created
+   *
+   * @param courseDir    project directory of course
+   * @param resourceRoot directory where original lesson stored
+   * @throws java.io.IOException
+   */
+  public void create(@NotNull final VirtualFile courseDir, @NotNull final File resourceRoot) throws IOException {
+    String lessonDirName = LESSON_DIR + Integer.toString(myIndex + 1);
+    VirtualFile lessonDir = courseDir.createChildDirectory(this, lessonDirName);
+    for (int i = 0; i < taskList.size(); i++) {
+      Task task = taskList.get(i);
+      task.setIndex(i);
+      task.create(lessonDir, new File(resourceRoot, lessonDir.getName()));
+    }
+  }
+
+
+  /**
+   * Initializes state of lesson
+   *
+   * @param course course which lesson belongs to
+   */
+  public void init(final Course course, boolean isRestarted) {
+    myCourse = course;
+    myLessonInfo.setTaskNum(taskList.size());
+    myLessonInfo.setTaskUnchecked(taskList.size());
+    for (Task task : taskList) {
+      task.init(this, isRestarted);
+    }
+  }
+
+  public Lesson next() {
+    List<Lesson> lessons = myCourse.getLessons();
+    if (myIndex + 1 >= lessons.size()) {
+      return null;
+    }
+    return lessons.get(myIndex + 1);
+  }
+
+  public void setIndex(int index) {
+    myIndex = index;
+  }
+
+  public int getIndex() {
+    return myIndex;
+  }
+
+  public Lesson prev() {
+    if (myIndex - 1 < 0) {
+      return null;
+    }
+    return myCourse.getLessons().get(myIndex - 1);
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/course/LessonInfo.java b/python/edu/learn-python/src/com/jetbrains/python/edu/course/LessonInfo.java
new file mode 100644
index 0000000..85e2eb8
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/course/LessonInfo.java
@@ -0,0 +1,60 @@
+package com.jetbrains.python.edu.course;
+
+/**
+ * Implementation of class which contains information about student progress in current lesson
+ */
+public class LessonInfo {
+  private int myTaskNum;
+  private int myTaskFailed;
+  private int myTaskSolved;
+  private int myTaskUnchecked;
+
+  public int getTaskNum() {
+    return myTaskNum;
+  }
+
+  public void setTaskNum(int taskNum) {
+    myTaskNum = taskNum;
+  }
+
+  public int getTaskFailed() {
+    return myTaskFailed;
+  }
+
+  public void setTaskFailed(int taskFailed) {
+    myTaskFailed = taskFailed;
+  }
+
+  public int getTaskSolved() {
+    return myTaskSolved;
+  }
+
+  public void setTaskSolved(int taskSolved) {
+    myTaskSolved = taskSolved;
+  }
+
+  public int getTaskUnchecked() {
+    return myTaskUnchecked;
+  }
+
+  public void setTaskUnchecked(int taskUnchecked) {
+    myTaskUnchecked = taskUnchecked;
+  }
+
+  public void update(StudyStatus status, int delta) {
+    switch (status) {
+      case Solved: {
+        myTaskSolved += delta;
+        break;
+      }
+      case Failed: {
+        myTaskFailed += delta;
+        break;
+      }
+      case Unchecked: {
+        myTaskUnchecked += delta;
+        break;
+      }
+    }
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/course/Stateful.java b/python/edu/learn-python/src/com/jetbrains/python/edu/course/Stateful.java
new file mode 100644
index 0000000..3a16362
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/course/Stateful.java
@@ -0,0 +1,6 @@
+package com.jetbrains.python.edu.course;
+
+public interface Stateful {
+  StudyStatus getStatus();
+  void setStatus(StudyStatus status, StudyStatus oldStatus);
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/course/StudyStatus.java b/python/edu/learn-python/src/com/jetbrains/python/edu/course/StudyStatus.java
new file mode 100644
index 0000000..d95b42b
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/course/StudyStatus.java
@@ -0,0 +1,8 @@
+package com.jetbrains.python.edu.course;
+
+/**
+ * @see {@link TaskWindow#myStatus}
+ */
+public enum StudyStatus {
+  Unchecked, Solved, Failed
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/course/Task.java b/python/edu/learn-python/src/com/jetbrains/python/edu/course/Task.java
new file mode 100644
index 0000000..2323412
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/course/Task.java
@@ -0,0 +1,201 @@
+package com.jetbrains.python.edu.course;
+
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.util.xmlb.annotations.Transient;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import com.jetbrains.python.edu.StudyUtils;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Implementation of task which contains task files, tests, input file for tests
+ */
+public class Task implements Stateful{
+  public static final String TASK_DIR = "task";
+  private static final String ourTestFile = "tests.py";
+  public String name;
+  private static final String ourTextFile = "task.html";
+  public Map<String, TaskFile> taskFiles = new HashMap<String, TaskFile>();
+  private Lesson myLesson;
+  public int myIndex;
+  public List<UserTest> userTests = new ArrayList<UserTest>();
+  public static final String USER_TESTS = "userTests";
+
+  public Map<String, TaskFile> getTaskFiles() {
+    return taskFiles;
+  }
+
+  @Transient
+  public StudyStatus getStatus() {
+    for (TaskFile taskFile : taskFiles.values()) {
+      StudyStatus taskFileStatus = taskFile.getStatus();
+      if (taskFileStatus == StudyStatus.Unchecked) {
+        return StudyStatus.Unchecked;
+      }
+      if (taskFileStatus == StudyStatus.Failed) {
+        return StudyStatus.Failed;
+      }
+    }
+    return StudyStatus.Solved;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  public void setStatus(@NotNull final StudyStatus status, @NotNull final StudyStatus oldStatus) {
+    LessonInfo lessonInfo = myLesson.getLessonInfo();
+    if (status != oldStatus) {
+      lessonInfo.update(oldStatus, -1);
+      lessonInfo.update(status, +1);
+    }
+    for (TaskFile taskFile : taskFiles.values()) {
+      taskFile.setStatus(status, oldStatus);
+    }
+  }
+
+  public List<UserTest> getUserTests() {
+    return userTests;
+  }
+
+  public String getTestFile() {
+    return ourTestFile;
+  }
+
+  public String getText() {
+    return ourTextFile;
+  }
+
+  /**
+   * Creates task directory in its lesson folder in project user created
+   *
+   * @param lessonDir    project directory of lesson which task belongs to
+   * @param resourceRoot directory where original task file stored
+   * @throws java.io.IOException
+   */
+  public void create(@NotNull final VirtualFile lessonDir, @NotNull final File resourceRoot) throws IOException {
+    VirtualFile taskDir = lessonDir.createChildDirectory(this, TASK_DIR + Integer.toString(myIndex + 1));
+    File newResourceRoot = new File(resourceRoot, taskDir.getName());
+    int i = 0;
+    for (Map.Entry<String, TaskFile> taskFile : taskFiles.entrySet()) {
+      TaskFile taskFileContent = taskFile.getValue();
+      taskFileContent.setIndex(i);
+      i++;
+      taskFileContent.create(taskDir, newResourceRoot, taskFile.getKey());
+    }
+    File[] filesInTask = newResourceRoot.listFiles();
+    if (filesInTask != null) {
+      for (File file : filesInTask) {
+        String fileName = file.getName();
+        if (!isTaskFile(fileName)) {
+          File resourceFile = new File(newResourceRoot, fileName);
+          File fileInProject = new File(taskDir.getCanonicalPath(), fileName);
+          FileUtil.copy(resourceFile, fileInProject);
+        }
+      }
+    }
+  }
+
+  private boolean isTaskFile(@NotNull final String fileName) {
+    return taskFiles.get(fileName) != null;
+  }
+
+  @Nullable
+  public TaskFile getFile(@NotNull final String fileName) {
+    return taskFiles.get(fileName);
+  }
+
+  /**
+   * Initializes state of task file
+   *
+   * @param lesson lesson which task belongs to
+   */
+  public void init(final Lesson lesson, boolean isRestarted) {
+    myLesson = lesson;
+    for (TaskFile taskFile : taskFiles.values()) {
+      taskFile.init(this, isRestarted);
+    }
+  }
+
+  public Task next() {
+    Lesson currentLesson = this.myLesson;
+    List<Task> taskList = myLesson.getTaskList();
+    if (myIndex + 1 < taskList.size()) {
+      return taskList.get(myIndex + 1);
+    }
+    Lesson nextLesson = currentLesson.next();
+    if (nextLesson == null) {
+      return null;
+    }
+    return StudyUtils.getFirst(nextLesson.getTaskList());
+  }
+
+  public Task prev() {
+    Lesson currentLesson = this.myLesson;
+    if (myIndex - 1 >= 0) {
+      return myLesson.getTaskList().get(myIndex - 1);
+    }
+    Lesson prevLesson = currentLesson.prev();
+    if (prevLesson == null) {
+      return null;
+    }
+    //getting last task in previous lesson
+    return prevLesson.getTaskList().get(prevLesson.getTaskList().size() - 1);
+  }
+
+  public void setIndex(int index) {
+    myIndex = index;
+  }
+
+  public int getIndex() {
+    return myIndex;
+  }
+
+  public Lesson getLesson() {
+    return myLesson;
+  }
+
+
+  @Nullable
+  public VirtualFile getTaskDir(Project project) {
+    String lessonDirName = Lesson.LESSON_DIR + String.valueOf(myLesson.getIndex() + 1);
+    String taskDirName = TASK_DIR + String.valueOf(myIndex + 1);
+    VirtualFile courseDir = project.getBaseDir();
+    if (courseDir != null) {
+      VirtualFile lessonDir = courseDir.findChild(lessonDirName);
+      if (lessonDir != null) {
+        return lessonDir.findChild(taskDirName);
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Gets text of resource file such as test input file or task text in needed format
+   *
+   * @param fileName name of resource file which should exist in task directory
+   * @param wrapHTML if it's necessary to wrap text with html tags
+   * @return text of resource file wrapped with html tags if necessary
+   */
+  @Nullable
+  public String getResourceText(@NotNull final Project project, @NotNull final String fileName, boolean wrapHTML) {
+    VirtualFile taskDir = getTaskDir(project);
+    if (taskDir != null) {
+      return StudyUtils.getFileText(taskDir.getCanonicalPath(), fileName, wrapHTML);
+    }
+    return null;
+  }
+
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/course/TaskFile.java b/python/edu/learn-python/src/com/jetbrains/python/edu/course/TaskFile.java
new file mode 100644
index 0000000..4f17fc0
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/course/TaskFile.java
@@ -0,0 +1,228 @@
+package com.jetbrains.python.edu.course;
+
+import com.intellij.openapi.editor.Document;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.editor.LogicalPosition;
+import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.util.xmlb.annotations.Transient;
+import com.jetbrains.python.edu.StudyUtils;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Implementation of task file which contains task windows for student to type in and
+ * which is visible to student in project view
+ */
+
+public class TaskFile implements Stateful{
+  public List<TaskWindow> taskWindows = new ArrayList<TaskWindow>();
+  private Task myTask;
+  @Transient
+  private TaskWindow mySelectedTaskWindow = null;
+  public int myIndex = -1;
+  private boolean myUserCreated = false;
+
+  /**
+   * @return if all the windows in task file are marked as resolved
+   */
+  @Transient
+  public StudyStatus getStatus() {
+    for (TaskWindow taskWindow : taskWindows) {
+      StudyStatus windowStatus = taskWindow.getStatus();
+      if (windowStatus == StudyStatus.Failed) {
+        return StudyStatus.Failed;
+      }
+      if (windowStatus == StudyStatus.Unchecked) {
+        return StudyStatus.Unchecked;
+      }
+    }
+    return StudyStatus.Solved;
+  }
+
+  public Task getTask() {
+    return myTask;
+  }
+
+  @Nullable
+  @Transient
+  public TaskWindow getSelectedTaskWindow() {
+    return mySelectedTaskWindow;
+  }
+
+  /**
+   * @param selectedTaskWindow window from this task file to be set as selected
+   */
+  public void setSelectedTaskWindow(@NotNull final TaskWindow selectedTaskWindow) {
+    if (selectedTaskWindow.getTaskFile() == this) {
+      mySelectedTaskWindow = selectedTaskWindow;
+    }
+    else {
+      throw new IllegalArgumentException("Window may be set as selected only in task file which it belongs to");
+    }
+  }
+
+  public List<TaskWindow> getTaskWindows() {
+    return taskWindows;
+  }
+
+  /**
+   * Creates task files in its task folder in project user created
+   *
+   * @param taskDir      project directory of task which task file belongs to
+   * @param resourceRoot directory where original task file stored
+   * @throws java.io.IOException
+   */
+  public void create(@NotNull final VirtualFile taskDir, @NotNull final File resourceRoot,
+                     @NotNull final String name) throws IOException {
+    String systemIndependentName = FileUtil.toSystemIndependentName(name);
+    final int index = systemIndependentName.lastIndexOf("/");
+    if (index > 0) {
+      systemIndependentName = systemIndependentName.substring(index + 1);
+    }
+    File resourceFile = new File(resourceRoot, name);
+    File fileInProject = new File(taskDir.getPath(), systemIndependentName);
+    FileUtil.copy(resourceFile, fileInProject);
+  }
+
+  public void drawAllWindows(Editor editor) {
+    for (TaskWindow taskWindow : taskWindows) {
+      taskWindow.draw(editor, false, false);
+    }
+  }
+
+
+  /**
+   * @param pos position in editor
+   * @return task window located in specified position or null if there is no task window in this position
+   */
+  @Nullable
+  public TaskWindow getTaskWindow(@NotNull final Document document, @NotNull final LogicalPosition pos) {
+    int line = pos.line;
+    if (line >= document.getLineCount()) {
+      return null;
+    }
+    int column = pos.column;
+    int offset = document.getLineStartOffset(line) + column;
+    for (TaskWindow tw : taskWindows) {
+      if (tw.getLine() <= line) {
+        int twStartOffset = tw.getRealStartOffset(document);
+        final int length = tw.getLength() > 0 ? tw.getLength() : 0;
+        int twEndOffset = twStartOffset + length;
+        if (twStartOffset <= offset && offset <= twEndOffset) {
+          return tw;
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Updates task window lines
+   *
+   * @param startLine lines greater than this line and including this line will be updated
+   * @param change    change to be added to line numbers
+   */
+  public void incrementLines(int startLine, int change) {
+    for (TaskWindow taskTaskWindow : taskWindows) {
+      if (taskTaskWindow.getLine() >= startLine) {
+        taskTaskWindow.setLine(taskTaskWindow.getLine() + change);
+      }
+    }
+  }
+
+  /**
+   * Initializes state of task file
+   *
+   * @param task task which task file belongs to
+   */
+
+  public void init(final Task task, boolean isRestarted) {
+    myTask = task;
+    for (TaskWindow taskWindow : taskWindows) {
+      taskWindow.init(this, isRestarted);
+    }
+    Collections.sort(taskWindows);
+    for (int i = 0; i < taskWindows.size(); i++) {
+      taskWindows.get(i).setIndex(i);
+    }
+  }
+
+  /**
+   * @param index index of task file in list of task files of its task
+   */
+  public void setIndex(int index) {
+    myIndex = index;
+  }
+
+  /**
+   * Updates windows in specific line
+   *
+   * @param lineChange         change in line number
+   * @param line               line to be updated
+   * @param newEndOffsetInLine distance from line start to end of inserted fragment
+   * @param oldEndOffsetInLine distance from line start to end of changed fragment
+   */
+  public void updateLine(int lineChange, int line, int newEndOffsetInLine, int oldEndOffsetInLine) {
+    for (TaskWindow w : taskWindows) {
+      if ((w.getLine() == line) && (w.getStart() >= oldEndOffsetInLine)) {
+        int distance = w.getStart() - oldEndOffsetInLine;
+        if (lineChange != 0 || newEndOffsetInLine <= w.getStart()) {
+          w.setStart(distance + newEndOffsetInLine);
+          w.setLine(line + lineChange);
+        }
+      }
+    }
+  }
+
+  public static void copy(@NotNull final TaskFile source, @NotNull final TaskFile target) {
+    List<TaskWindow> sourceTaskWindows = source.getTaskWindows();
+    List<TaskWindow> windowsCopy = new ArrayList<TaskWindow>(sourceTaskWindows.size());
+    for (TaskWindow taskWindow : sourceTaskWindows) {
+      TaskWindow taskWindowCopy = new TaskWindow();
+      taskWindowCopy.setLine(taskWindow.getLine());
+      taskWindowCopy.setStart(taskWindow.getStart());
+      taskWindowCopy.setLength(taskWindow.getLength());
+      taskWindowCopy.setPossibleAnswer(taskWindow.getPossibleAnswer());
+      taskWindowCopy.setIndex(taskWindow.getIndex());
+      windowsCopy.add(taskWindowCopy);
+    }
+    target.setTaskWindows(windowsCopy);
+  }
+
+  public void setTaskWindows(List<TaskWindow> taskWindows) {
+    this.taskWindows = taskWindows;
+  }
+
+  public void setStatus(@NotNull final StudyStatus status, @NotNull final StudyStatus oldStatus) {
+    for (TaskWindow taskWindow : taskWindows) {
+      taskWindow.setStatus(status, oldStatus);
+    }
+  }
+
+  public void setUserCreated(boolean userCreated) {
+    myUserCreated = userCreated;
+  }
+
+  public boolean isUserCreated() {
+    return myUserCreated;
+  }
+
+  public void navigateToFirstTaskWindow(@NotNull final Editor editor) {
+    if (!taskWindows.isEmpty()) {
+      TaskWindow firstTaskWindow = StudyUtils.getFirst(taskWindows);
+      mySelectedTaskWindow = firstTaskWindow;
+      LogicalPosition taskWindowStart = new LogicalPosition(firstTaskWindow.getLine(), firstTaskWindow.getStart());
+      editor.getCaretModel().moveToLogicalPosition(taskWindowStart);
+      int startOffset = firstTaskWindow.getRealStartOffset(editor.getDocument());
+      int endOffset = startOffset + firstTaskWindow.getLength();
+      editor.getSelectionModel().setSelection(startOffset, endOffset);
+    }
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/course/TaskWindow.java b/python/edu/learn-python/src/com/jetbrains/python/edu/course/TaskWindow.java
new file mode 100644
index 0000000..4fb112c
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/course/TaskWindow.java
@@ -0,0 +1,177 @@
+package com.jetbrains.python.edu.course;
+
+import com.intellij.openapi.editor.Document;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.editor.colors.EditorColors;
+import com.intellij.openapi.editor.colors.EditorColorsManager;
+import com.intellij.openapi.editor.markup.HighlighterLayer;
+import com.intellij.openapi.editor.markup.HighlighterTargetArea;
+import com.intellij.openapi.editor.markup.RangeHighlighter;
+import com.intellij.openapi.editor.markup.TextAttributes;
+import com.intellij.ui.JBColor;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Implementation of windows which user should type in
+ */
+
+
+public class TaskWindow implements Comparable, Stateful {
+
+  public int line = 0;
+  public int start = 0;
+  public String hint = "";
+  public String possibleAnswer = "";
+  public int length = 0;
+  private TaskFile myTaskFile;
+  public int myIndex = -1;
+  public int myInitialLine = -1;
+  public int myInitialStart = -1;
+  public int myInitialLength = -1;
+  public StudyStatus myStatus = StudyStatus.Unchecked;
+
+  public StudyStatus getStatus() {
+    return myStatus;
+  }
+
+  public void setStatus(StudyStatus status, StudyStatus oldStatus) {
+    myStatus = status;
+  }
+
+  public void setIndex(int index) {
+    myIndex = index;
+  }
+
+  public int getLength() {
+    return length;
+  }
+
+  public void setLength(int length) {
+    this.length = length;
+  }
+
+  public int getStart() {
+    return start;
+  }
+
+  public void setStart(int start) {
+    this.start = start;
+  }
+
+  public void setLine(int line) {
+    this.line = line;
+  }
+
+  public int getLine() {
+    return line;
+  }
+
+
+  /**
+   * Draw task window with color according to its status
+   */
+  public void draw(@NotNull final Editor editor, boolean drawSelection, boolean moveCaret) {
+    Document document = editor.getDocument();
+    if (!isValid(document)) {
+      return;
+    }
+    TextAttributes defaultTestAttributes =
+      EditorColorsManager.getInstance().getGlobalScheme().getAttributes(EditorColors.LIVE_TEMPLATE_ATTRIBUTES);
+    JBColor color = getColor();
+    int startOffset = document.getLineStartOffset(line) + start;
+    RangeHighlighter
+      rh = editor.getMarkupModel().addRangeHighlighter(startOffset, startOffset + length, HighlighterLayer.LAST + 1,
+                                                       new TextAttributes(defaultTestAttributes.getForegroundColor(),
+                                                                          defaultTestAttributes.getBackgroundColor(), color,
+                                                                          defaultTestAttributes.getEffectType(),
+                                                                          defaultTestAttributes.getFontType()),
+                                                       HighlighterTargetArea.EXACT_RANGE);
+    if (drawSelection) {
+      editor.getSelectionModel().setSelection(startOffset, startOffset + length);
+    }
+    if (moveCaret) {
+      editor.getCaretModel().moveToOffset(startOffset);
+    }
+    rh.setGreedyToLeft(true);
+    rh.setGreedyToRight(true);
+  }
+
+  public boolean isValid(@NotNull final Document document) {
+    boolean isLineValid = line < document.getLineCount() && line >= 0;
+    if (!isLineValid) return false;
+    boolean isStartValid = start >= 0 && start < document.getLineEndOffset(line);
+    boolean isLengthValid = (getRealStartOffset(document) + length) <= document.getTextLength();
+    return isLengthValid && isStartValid;
+  }
+
+  private JBColor getColor() {
+    if (myStatus == StudyStatus.Solved) {
+      return JBColor.GREEN;
+    }
+    if (myStatus == StudyStatus.Failed) {
+      return JBColor.RED;
+    }
+    return JBColor.BLUE;
+  }
+
+  public int getRealStartOffset(@NotNull final Document document) {
+    return document.getLineStartOffset(line) + start;
+  }
+
+  /**
+   * Initializes window
+   *
+   * @param file task file which window belongs to
+   */
+  public void init(final TaskFile file, boolean isRestarted) {
+    if (!isRestarted) {
+      myInitialLine = line;
+      myInitialLength = length;
+      myInitialStart = start;
+    }
+    myTaskFile = file;
+  }
+
+  public TaskFile getTaskFile() {
+    return myTaskFile;
+  }
+
+  @Override
+  public int compareTo(@NotNull Object o) {
+    TaskWindow taskWindow = (TaskWindow)o;
+    if (taskWindow.getTaskFile() != myTaskFile) {
+      throw new ClassCastException();
+    }
+    int lineDiff = line - taskWindow.line;
+    if (lineDiff == 0) {
+      return start - taskWindow.start;
+    }
+    return lineDiff;
+  }
+
+  /**
+   * Returns window to its initial state
+   */
+  public void reset() {
+    myStatus = StudyStatus.Unchecked;
+    line = myInitialLine;
+    start = myInitialStart;
+    length = myInitialLength;
+  }
+
+  public String getHint() {
+    return hint;
+  }
+
+  public String getPossibleAnswer() {
+    return possibleAnswer;
+  }
+
+  public void setPossibleAnswer(String possibleAnswer) {
+    this.possibleAnswer = possibleAnswer;
+  }
+
+  public int getIndex() {
+    return myIndex;
+  }
+}
\ No newline at end of file
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/course/UserTest.java b/python/edu/learn-python/src/com/jetbrains/python/edu/course/UserTest.java
new file mode 100644
index 0000000..8133e91
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/course/UserTest.java
@@ -0,0 +1,41 @@
+package com.jetbrains.python.edu.course;
+
+public class UserTest {
+  private String input;
+  private String output;
+  private StringBuilder myInputBuffer = new StringBuilder();
+  private StringBuilder myOutputBuffer =  new StringBuilder();
+  private boolean myEditable = false;
+
+  public String getInput() {
+    return input;
+  }
+
+  public void setInput(String input) {
+    this.input = input;
+  }
+
+  public String getOutput() {
+    return output;
+  }
+
+  public void setOutput(String output) {
+    this.output = output;
+  }
+
+  public StringBuilder getInputBuffer() {
+    return myInputBuffer;
+  }
+
+  public StringBuilder getOutputBuffer() {
+    return myOutputBuffer;
+  }
+
+  public boolean isEditable() {
+    return myEditable;
+  }
+
+  public void setEditable(boolean editable) {
+    myEditable = editable;
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/editor/StudyEditor.java b/python/edu/learn-python/src/com/jetbrains/python/edu/editor/StudyEditor.java
new file mode 100644
index 0000000..69c5acc
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/editor/StudyEditor.java
@@ -0,0 +1,347 @@
+package com.jetbrains.python.edu.editor;
+
+import com.intellij.codeHighlighting.BackgroundEditorHighlighter;
+import com.intellij.ide.structureView.StructureViewBuilder;
+import com.intellij.openapi.actionSystem.ActionManager;
+import com.intellij.openapi.editor.Document;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.editor.EditorFactory;
+import com.intellij.openapi.editor.colors.EditorColorsManager;
+import com.intellij.openapi.editor.colors.EditorColorsScheme;
+import com.intellij.openapi.editor.impl.DocumentImpl;
+import com.intellij.openapi.fileEditor.*;
+import com.intellij.openapi.fileEditor.ex.FileEditorManagerEx;
+import com.intellij.openapi.fileEditor.impl.text.PsiAwareTextEditorImpl;
+import com.intellij.openapi.fileEditor.impl.text.TextEditorProvider;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Disposer;
+import com.intellij.openapi.util.Key;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.pom.Navigatable;
+import com.intellij.ui.HideableTitledPanel;
+import com.intellij.ui.JBColor;
+import com.intellij.util.ui.UIUtil;
+import com.jetbrains.python.edu.StudyDocumentListener;
+import com.jetbrains.python.edu.StudyTaskManager;
+import com.jetbrains.python.edu.actions.*;
+import com.jetbrains.python.edu.course.Task;
+import com.jetbrains.python.edu.course.TaskFile;
+import icons.StudyIcons;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import javax.swing.*;
+import javax.swing.border.EmptyBorder;
+import javax.swing.text.MutableAttributeSet;
+import javax.swing.text.StyleConstants;
+import javax.swing.text.StyledDocument;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.beans.PropertyChangeListener;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Implementation of StudyEditor which has panel with special buttons and task text
+ * also @see {@link com.jetbrains.python.edu.editor.StudyFileEditorProvider}
+ */
+public class StudyEditor implements TextEditor {
+  private static final String TASK_TEXT_HEADER = "Task Text";
+  private final FileEditor myDefaultEditor;
+  private final JComponent myComponent;
+  private JButton myCheckButton;
+  private JButton myNextTaskButton;
+  private JButton myPrevTaskButton;
+  private JButton myRefreshButton;
+  private static final Map<Document, StudyDocumentListener> myDocumentListeners = new HashMap<Document, StudyDocumentListener>();
+  private Project myProject;
+
+  public JButton getCheckButton() {
+    return myCheckButton;
+  }
+
+  public JButton getPrevTaskButton() {
+    return myPrevTaskButton;
+  }
+
+  private static JButton addButton(@NotNull final JComponent parentComponent, String toolTipText, Icon icon) {
+    JButton newButton = new JButton();
+    newButton.setToolTipText(toolTipText);
+    newButton.setIcon(icon);
+    newButton.setSize(new Dimension(icon.getIconWidth(), icon.getIconHeight()));
+    parentComponent.add(newButton);
+    return newButton;
+  }
+
+  public static void addDocumentListener(@NotNull final Document document, @NotNull final StudyDocumentListener listener) {
+    myDocumentListeners.put(document, listener);
+  }
+
+  @Nullable
+  public static StudyDocumentListener getListener(@NotNull final Document document) {
+    return myDocumentListeners.get(document);
+  }
+
+  public StudyEditor(@NotNull final Project project, @NotNull final VirtualFile file) {
+    myProject = project;
+    myDefaultEditor = TextEditorProvider.getInstance().createEditor(myProject, file);
+    myComponent = myDefaultEditor.getComponent();
+    JPanel studyPanel = new JPanel();
+    studyPanel.setLayout(new BoxLayout(studyPanel, BoxLayout.Y_AXIS));
+    TaskFile taskFile = StudyTaskManager.getInstance(myProject).getTaskFile(file);
+    if (taskFile != null) {
+      Task currentTask = taskFile.getTask();
+      String taskText = currentTask.getResourceText(project, currentTask.getText(), false);
+      initializeTaskText(studyPanel, taskText);
+      JPanel studyButtonPanel = new JPanel(new GridLayout(1, 2));
+      JPanel taskActionsPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
+      studyButtonPanel.add(taskActionsPanel);
+      studyButtonPanel.add(new JPanel());
+      initializeButtons(taskActionsPanel, taskFile);
+      studyPanel.add(studyButtonPanel);
+      myComponent.add(studyPanel, BorderLayout.NORTH);
+    }
+  }
+
+  private static void initializeTaskText(JPanel studyPanel, @Nullable String taskText) {
+    JTextPane taskTextPane = new JTextPane();
+    taskTextPane.setContentType("text/html");
+    taskTextPane.setEditable(false);
+    taskTextPane.setText(taskText);
+    EditorColorsScheme editorColorsScheme = EditorColorsManager.getInstance().getGlobalScheme();
+    int fontSize = editorColorsScheme.getEditorFontSize();
+    String fontName = editorColorsScheme.getEditorFontName();
+    setJTextPaneFont(taskTextPane, new Font(fontName, Font.PLAIN, fontSize), JBColor.BLACK);
+    taskTextPane.setBackground(UIUtil.getPanelBackground());
+    taskTextPane.setBorder(new EmptyBorder(15, 20, 0, 100));
+    HideableTitledPanel taskTextPanel = new HideableTitledPanel(TASK_TEXT_HEADER, taskTextPane, true);
+    taskTextPanel.setBorder(new EmptyBorder(10, 10, 10, 10));
+    studyPanel.add(taskTextPanel);
+  }
+
+  private static void setJTextPaneFont(JTextPane jtp, Font font, Color c) {
+    MutableAttributeSet attrs = jtp.getInputAttributes();
+    StyleConstants.setFontFamily(attrs, font.getFamily());
+    StyleConstants.setFontSize(attrs, font.getSize());
+    StyleConstants.setItalic(attrs, (font.getStyle() & Font.ITALIC) != 0);
+    StyleConstants.setBold(attrs, (font.getStyle() & Font.BOLD) != 0);
+    StyleConstants.setForeground(attrs, c);
+    StyledDocument doc = jtp.getStyledDocument();
+    doc.setCharacterAttributes(0, doc.getLength() + 1, attrs, false);
+  }
+
+  private void initializeButtons(@NotNull final JPanel taskActionsPanel, @NotNull final TaskFile taskFile) {
+    myCheckButton = addButton(taskActionsPanel, "Check task", StudyIcons.Resolve);
+    myPrevTaskButton = addButton(taskActionsPanel, "Prev Task", StudyIcons.Prev);
+    myNextTaskButton = addButton(taskActionsPanel, "Next Task", StudyIcons.Next);
+    myRefreshButton = addButton(taskActionsPanel, "Start task again", StudyIcons.Refresh24);
+    if (!taskFile.getTask().getUserTests().isEmpty()) {
+      JButton runButton = addButton(taskActionsPanel, "Run", StudyIcons.Run);
+      runButton.addActionListener(new ActionListener() {
+        @Override
+        public void actionPerformed(ActionEvent e) {
+          StudyRunAction studyRunAction = (StudyRunAction)ActionManager.getInstance().getAction("StudyRunAction");
+          studyRunAction.run(myProject);
+        }
+      });
+      JButton watchInputButton = addButton(taskActionsPanel, "Watch test input", StudyIcons.WatchInput);
+      watchInputButton.addActionListener(new ActionListener() {
+        @Override
+        public void actionPerformed(ActionEvent e) {
+          StudyEditInputAction studyEditInputAction = (StudyEditInputAction)ActionManager.getInstance().getAction("WatchInputAction");
+          studyEditInputAction.showInput(myProject);
+        }
+      });
+    }
+    myCheckButton.addActionListener(new ActionListener() {
+      @Override
+      public void actionPerformed(ActionEvent e) {
+        StudyCheckAction studyCheckAction = (StudyCheckAction)ActionManager.getInstance().getAction("CheckAction");
+        studyCheckAction.check(myProject);
+      }
+    });
+
+    myNextTaskButton.addActionListener(new ActionListener() {
+      @Override
+      public void actionPerformed(ActionEvent e) {
+        StudyNextStudyTaskAction studyNextTaskAction = (StudyNextStudyTaskAction)ActionManager.getInstance().getAction("NextTaskAction");
+        studyNextTaskAction.navigateTask(myProject);
+      }
+    });
+    myPrevTaskButton.addActionListener(new ActionListener() {
+      @Override
+      public void actionPerformed(ActionEvent e) {
+        StudyPreviousStudyTaskAction
+          prevTaskAction = (StudyPreviousStudyTaskAction)ActionManager.getInstance().getAction("PreviousTaskAction");
+        prevTaskAction.navigateTask(myProject);
+      }
+    });
+    myRefreshButton.addActionListener(new ActionListener() {
+      @Override
+      public void actionPerformed(ActionEvent e) {
+        StudyRefreshTaskAction studyRefreshTaskAction = (StudyRefreshTaskAction)ActionManager.getInstance().getAction("RefreshTaskAction");
+        studyRefreshTaskAction.refresh(myProject);
+      }
+    });
+  }
+
+  public JButton getNextTaskButton() {
+    return myNextTaskButton;
+  }
+
+  public JButton getRefreshButton() {
+    return myRefreshButton;
+  }
+
+  FileEditor getDefaultEditor() {
+    return myDefaultEditor;
+  }
+
+  @NotNull
+  @Override
+  public JComponent getComponent() {
+    return myComponent;
+  }
+
+  @Nullable
+  @Override
+  public JComponent getPreferredFocusedComponent() {
+    return myDefaultEditor.getPreferredFocusedComponent();
+  }
+
+  @NotNull
+  @Override
+  public String getName() {
+    return "Study Editor";
+  }
+
+  @NotNull
+  @Override
+  public FileEditorState getState(@NotNull FileEditorStateLevel level) {
+    return myDefaultEditor.getState(level);
+  }
+
+  @Override
+  public void setState(@NotNull FileEditorState state) {
+    myDefaultEditor.setState(state);
+  }
+
+  @Override
+  public boolean isModified() {
+    return myDefaultEditor.isModified();
+  }
+
+  @Override
+  public boolean isValid() {
+    return myDefaultEditor.isValid();
+  }
+
+  @Override
+  public void selectNotify() {
+    myDefaultEditor.selectNotify();
+  }
+
+  @Override
+  public void deselectNotify() {
+    myDefaultEditor.deselectNotify();
+  }
+
+  @Override
+  public void addPropertyChangeListener(@NotNull PropertyChangeListener listener) {
+    myDefaultEditor.addPropertyChangeListener(listener);
+  }
+
+  @Override
+  public void removePropertyChangeListener(@NotNull PropertyChangeListener listener) {
+    myDefaultEditor.removePropertyChangeListener(listener);
+  }
+
+  @Nullable
+  @Override
+  public BackgroundEditorHighlighter getBackgroundHighlighter() {
+    return myDefaultEditor.getBackgroundHighlighter();
+  }
+
+  @Nullable
+  @Override
+  public FileEditorLocation getCurrentLocation() {
+    return myDefaultEditor.getCurrentLocation();
+  }
+
+  @Nullable
+  @Override
+  public StructureViewBuilder getStructureViewBuilder() {
+    return myDefaultEditor.getStructureViewBuilder();
+  }
+
+  @Override
+  public void dispose() {
+    Disposer.dispose(myDefaultEditor);
+  }
+
+  @Nullable
+  @Override
+  public <T> T getUserData(@NotNull Key<T> key) {
+    return myDefaultEditor.getUserData(key);
+  }
+
+  @Override
+  public <T> void putUserData(@NotNull Key<T> key, @Nullable T value) {
+    myDefaultEditor.putUserData(key, value);
+  }
+
+
+  @Nullable
+  public static StudyEditor getSelectedStudyEditor(@NotNull final Project project) {
+    try {
+      FileEditor fileEditor = FileEditorManagerEx.getInstanceEx(project).getSplitters().getCurrentWindow().
+        getSelectedEditor().getSelectedEditorWithProvider().getFirst();
+      if (fileEditor instanceof StudyEditor) {
+        return (StudyEditor)fileEditor;
+      }
+    } catch (Exception e) {
+      return null;
+    }
+    return null;
+  }
+
+  @Nullable
+  public static Editor getSelectedEditor(@NotNull final Project project) {
+    StudyEditor studyEditor = getSelectedStudyEditor(project);
+    if (studyEditor != null) {
+      FileEditor defaultEditor = studyEditor.getDefaultEditor();
+      if (defaultEditor instanceof PsiAwareTextEditorImpl) {
+        return ((PsiAwareTextEditorImpl)defaultEditor).getEditor();
+      }
+    }
+    return null;
+  }
+
+  public static void removeListener(Document document) {
+    myDocumentListeners.remove(document);
+  }
+
+  @NotNull
+  @Override
+  public Editor getEditor() {
+    if (myDefaultEditor instanceof TextEditor)
+      return ((TextEditor)myDefaultEditor).getEditor();
+    return EditorFactory.getInstance().createViewer(new DocumentImpl(""), myProject);
+  }
+
+  @Override
+  public boolean canNavigateTo(@NotNull Navigatable navigatable) {
+    if (myDefaultEditor instanceof TextEditor) {
+      ((TextEditor)myDefaultEditor).canNavigateTo(navigatable);
+    }
+    return false;
+  }
+
+  @Override
+  public void navigateTo(@NotNull Navigatable navigatable) {
+    if (myDefaultEditor instanceof TextEditor) {
+      ((TextEditor)myDefaultEditor).navigateTo(navigatable);
+    }
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/editor/StudyFileEditorProvider.java b/python/edu/learn-python/src/com/jetbrains/python/edu/editor/StudyFileEditorProvider.java
new file mode 100644
index 0000000..631b5a9
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/editor/StudyFileEditorProvider.java
@@ -0,0 +1,64 @@
+package com.jetbrains.python.edu.editor;
+
+import com.intellij.openapi.fileEditor.FileEditor;
+import com.intellij.openapi.fileEditor.FileEditorPolicy;
+import com.intellij.openapi.fileEditor.FileEditorProvider;
+import com.intellij.openapi.fileEditor.FileEditorState;
+import com.intellij.openapi.fileEditor.impl.text.TextEditorProvider;
+import com.intellij.openapi.project.DumbAware;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.vfs.VirtualFile;
+import org.jdom.Element;
+import org.jetbrains.annotations.NotNull;
+import com.jetbrains.python.edu.StudyTaskManager;
+import com.jetbrains.python.edu.course.TaskFile;
+
+/**
+ * User: lia
+ * Date: 10.05.14
+ * Time: 12:45
+ */
+class StudyFileEditorProvider implements FileEditorProvider, DumbAware {
+  static final private String EDITOR_TYPE_ID = "StudyEditor";
+  final private FileEditorProvider defaultTextEditorProvider = TextEditorProvider.getInstance();
+
+  @Override
+  public boolean accept(@NotNull Project project, @NotNull VirtualFile file) {
+    TaskFile taskFile = StudyTaskManager.getInstance(project).getTaskFile(file);
+    return taskFile != null && !taskFile.isUserCreated();
+  }
+
+  @NotNull
+  @Override
+  public FileEditor createEditor(@NotNull Project project, @NotNull VirtualFile file) {
+    return new StudyEditor(project, file);
+  }
+
+  @Override
+  public void disposeEditor(@NotNull FileEditor editor) {
+    defaultTextEditorProvider.disposeEditor(editor);
+  }
+
+  @NotNull
+  @Override
+  public FileEditorState readState(@NotNull Element sourceElement, @NotNull Project project, @NotNull VirtualFile file) {
+    return defaultTextEditorProvider.readState(sourceElement, project, file);
+  }
+
+  @Override
+  public void writeState(@NotNull FileEditorState state, @NotNull Project project, @NotNull Element targetElement) {
+    defaultTextEditorProvider.writeState(state, project, targetElement);
+  }
+
+  @NotNull
+  @Override
+  public String getEditorTypeId() {
+    return EDITOR_TYPE_ID;
+  }
+
+  @NotNull
+  @Override
+  public FileEditorPolicy getPolicy() {
+    return FileEditorPolicy.HIDE_DEFAULT_EDITOR;
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/projectView/StudyDirectoryNode.java b/python/edu/learn-python/src/com/jetbrains/python/edu/projectView/StudyDirectoryNode.java
new file mode 100644
index 0000000..abf648c
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/projectView/StudyDirectoryNode.java
@@ -0,0 +1,112 @@
+package com.jetbrains.python.edu.projectView;
+
+import com.intellij.ide.projectView.PresentationData;
+import com.intellij.ide.projectView.ViewSettings;
+import com.intellij.ide.projectView.impl.nodes.PsiDirectoryNode;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.psi.PsiDirectory;
+import com.intellij.psi.PsiElement;
+import com.intellij.ui.JBColor;
+import com.intellij.ui.SimpleTextAttributes;
+import com.jetbrains.python.edu.StudyTaskManager;
+import com.jetbrains.python.edu.StudyUtils;
+import com.jetbrains.python.edu.course.*;
+import icons.StudyIcons;
+import org.jetbrains.annotations.NotNull;
+
+import javax.swing.*;
+import java.awt.*;
+
+public class StudyDirectoryNode extends PsiDirectoryNode {
+  private final PsiDirectory myValue;
+  private final Project myProject;
+
+  public StudyDirectoryNode(@NotNull final Project project,
+                            PsiDirectory value,
+                            ViewSettings viewSettings) {
+    super(project, value, viewSettings);
+    myValue = value;
+    myProject = project;
+  }
+
+  @Override
+  protected void updateImpl(PresentationData data) {
+    data.setIcon(StudyIcons.Unchecked);
+    String valueName = myValue.getName();
+    StudyTaskManager studyTaskManager = StudyTaskManager.getInstance(myProject);
+    Course course = studyTaskManager.getCourse();
+    if (course == null) {
+      return;
+    }
+    if (valueName.equals(myProject.getName())) {
+      data.clearText();
+      data.addText(course.getName(), new SimpleTextAttributes(SimpleTextAttributes.STYLE_BOLD, JBColor.BLUE));
+      data.addText(" (" + valueName + ")", SimpleTextAttributes.GRAYED_ATTRIBUTES);
+      return;
+    }
+    if (valueName.contains(Task.TASK_DIR)) {
+      TaskFile file = null;
+      for (PsiElement child : myValue.getChildren()) {
+        VirtualFile virtualFile = child.getContainingFile().getVirtualFile();
+        file = studyTaskManager.getTaskFile(virtualFile);
+        if (file != null) {
+          break;
+        }
+      }
+      if (file != null) {
+        Task task = file.getTask();
+        setStudyAttributes(task, data, task.getName());
+      }
+    }
+    if (valueName.contains(Lesson.LESSON_DIR)) {
+      int lessonIndex = Integer.parseInt(valueName.substring(Lesson.LESSON_DIR.length())) - 1;
+      Lesson lesson = course.getLessons().get(lessonIndex);
+      setStudyAttributes(lesson, data, lesson.getName());
+    }
+
+    if (valueName.contains(Course.PLAYGROUND_DIR)) {
+      if (myValue.getParent() != null) {
+        if (!myValue.getParent().getName().contains(Course.PLAYGROUND_DIR)) {
+          data.setPresentableText(Course.PLAYGROUND_DIR);
+          data.setIcon(StudyIcons.Playground);
+          return;
+        }
+      }
+    }
+    data.setPresentableText(valueName);
+  }
+
+  @Override
+  public int getTypeSortWeight(boolean sortByType) {
+    String name = myValue.getName();
+    if (name.contains(Lesson.LESSON_DIR) || name.contains(Task.TASK_DIR)) {
+      String logicalName = name.contains(Lesson.LESSON_DIR) ? Lesson.LESSON_DIR : Task.TASK_DIR;
+      return StudyUtils.getIndex(name, logicalName) + 1;
+    }
+    return name.contains(Course.PLAYGROUND_DIR) ? 0 : 3;
+  }
+
+  private static void setStudyAttributes(Stateful stateful, PresentationData data, String additionalName) {
+    StudyStatus taskStatus = stateful.getStatus();
+    switch (taskStatus) {
+      case Unchecked: {
+        updatePresentation(data, additionalName, JBColor.blue, StudyIcons.Unchecked);
+        break;
+      }
+      case Solved: {
+        updatePresentation(data, additionalName, new JBColor(new Color(0, 134, 0), new Color(98, 150, 85)), StudyIcons.Checked);
+        break;
+      }
+      case Failed: {
+        updatePresentation(data, additionalName, JBColor.RED, StudyIcons.Failed);
+      }
+    }
+  }
+
+  private static void updatePresentation(PresentationData data, String additionalName, JBColor color, Icon icon) {
+    data.clearText();
+    data.addText(additionalName, new SimpleTextAttributes(Font.PLAIN, color));
+    data.setIcon(icon);
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/projectView/StudyTreeStructureProvider.java b/python/edu/learn-python/src/com/jetbrains/python/edu/projectView/StudyTreeStructureProvider.java
new file mode 100644
index 0000000..e301bc3
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/projectView/StudyTreeStructureProvider.java
@@ -0,0 +1,83 @@
+package com.jetbrains.python.edu.projectView;
+
+import com.intellij.ide.projectView.TreeStructureProvider;
+import com.intellij.ide.projectView.ViewSettings;
+import com.intellij.ide.projectView.impl.nodes.PsiFileNode;
+import com.intellij.ide.util.treeView.AbstractTreeNode;
+import com.intellij.openapi.project.DumbAware;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.psi.PsiDirectory;
+import com.jetbrains.python.edu.StudyTaskManager;
+import com.jetbrains.python.edu.course.Course;
+import com.jetbrains.python.edu.course.Task;
+import com.jetbrains.python.edu.course.TaskFile;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+public class StudyTreeStructureProvider implements TreeStructureProvider, DumbAware {
+  @NotNull
+  @Override
+  public Collection<AbstractTreeNode> modify(@NotNull AbstractTreeNode parent,
+                                             @NotNull Collection<AbstractTreeNode> children,
+                                             ViewSettings settings) {
+    if (!needModify(parent)) {
+      return children;
+    }
+    Collection<AbstractTreeNode> nodes = new ArrayList<AbstractTreeNode>();
+    for (AbstractTreeNode node : children) {
+      Project project = node.getProject();
+      if (project != null) {
+        if (node.getValue() instanceof PsiDirectory) {
+          PsiDirectory nodeValue = (PsiDirectory)node.getValue();
+          if (!nodeValue.getName().contains(Task.USER_TESTS)) {
+            StudyDirectoryNode newNode = new StudyDirectoryNode(project, nodeValue, settings);
+            nodes.add(newNode);
+          }
+        }
+        else {
+          if (parent instanceof StudyDirectoryNode) {
+            if (node instanceof PsiFileNode) {
+              PsiFileNode psiFileNode = (PsiFileNode)node;
+              VirtualFile virtualFile = psiFileNode.getVirtualFile();
+              if (virtualFile == null) {
+                return nodes;
+              }
+              TaskFile taskFile = StudyTaskManager.getInstance(project).getTaskFile(virtualFile);
+              if (taskFile != null) {
+                nodes.add(node);
+              }
+              String parentName = parent.getName();
+              if (parentName != null) {
+                if (parentName.equals(Course.PLAYGROUND_DIR)) {
+                  nodes.add(node);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    return nodes;
+  }
+
+  private static boolean needModify(AbstractTreeNode parent) {
+    Project project = parent.getProject();
+    if (project != null) {
+      StudyTaskManager studyTaskManager = StudyTaskManager.getInstance(project);
+      if (studyTaskManager.getCourse() == null) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  @Nullable
+  @Override
+  public Object getData(Collection<AbstractTreeNode> selected, String dataName) {
+    return null;
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/ui/StudyCondition.java b/python/edu/learn-python/src/com/jetbrains/python/edu/ui/StudyCondition.java
new file mode 100644
index 0000000..5add6c9
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/ui/StudyCondition.java
@@ -0,0 +1,25 @@
+package com.jetbrains.python.edu.ui;
+
+import com.intellij.openapi.project.DumbAware;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Condition;
+import com.jetbrains.python.edu.StudyTaskManager;
+
+/**
+ * author: liana
+ * data: 7/29/14.
+ */
+public class StudyCondition implements Condition, DumbAware {
+  public static boolean VALUE = false;
+  @Override
+  public boolean value(Object o) {
+    if (o instanceof Project) {
+      Project project = (Project) o;
+      StudyTaskManager taskManager = StudyTaskManager.getInstance(project);
+      if (taskManager.getCourse() != null) {
+        VALUE = true;
+      }
+    }
+    return false;
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/ui/StudyNewProjectPanel.form b/python/edu/learn-python/src/com/jetbrains/python/edu/ui/StudyNewProjectPanel.form
new file mode 100644
index 0000000..133c38d
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/ui/StudyNewProjectPanel.form
@@ -0,0 +1,84 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<form xmlns="http://www.intellij.com/uidesigner/form/" version="1" bind-to-class="com.jetbrains.python.edu.ui.StudyNewProjectPanel">
+  <grid id="27dc6" binding="myContentPanel" layout-manager="GridLayoutManager" row-count="2" column-count="4" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
+    <margin top="0" left="0" bottom="0" right="0"/>
+    <constraints>
+      <xy x="20" y="20" width="500" height="400"/>
+    </constraints>
+    <properties/>
+    <border type="none"/>
+    <children>
+      <grid id="54488" layout-manager="GridLayoutManager" row-count="2" column-count="1" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
+        <margin top="0" left="0" bottom="0" right="0"/>
+        <constraints>
+          <grid row="1" column="1" row-span="1" col-span="3" vsize-policy="2" hsize-policy="4" anchor="0" fill="3" indent="0" use-parent-layout="false">
+            <minimum-size width="-1" height="60"/>
+            <preferred-size width="-1" height="60"/>
+          </grid>
+        </constraints>
+        <properties/>
+        <border type="line">
+          <color color="-6709600"/>
+        </border>
+        <children>
+          <component id="213f6" class="javax.swing.JLabel" binding="myAuthorLabel">
+            <constraints>
+              <grid row="0" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="0" anchor="8" fill="0" indent="0" use-parent-layout="false"/>
+            </constraints>
+            <properties>
+              <text value=""/>
+            </properties>
+          </component>
+          <component id="d754d" class="javax.swing.JLabel" binding="myDescriptionLabel">
+            <constraints>
+              <grid row="1" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="0" anchor="8" fill="0" indent="0" use-parent-layout="false"/>
+            </constraints>
+            <properties>
+              <text value=""/>
+            </properties>
+          </component>
+        </children>
+      </grid>
+      <component id="6c40c" class="javax.swing.JLabel">
+        <constraints>
+          <grid row="0" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="0" anchor="0" fill="1" indent="0" use-parent-layout="false">
+            <preferred-size width="81" height="-1"/>
+          </grid>
+        </constraints>
+        <properties>
+          <font/>
+          <horizontalTextPosition value="0"/>
+          <text value="Courses:"/>
+        </properties>
+      </component>
+      <component id="21ac6" class="javax.swing.JComboBox" binding="myCoursesComboBox">
+        <constraints>
+          <grid row="0" column="1" row-span="1" col-span="1" vsize-policy="0" hsize-policy="7" anchor="0" fill="1" indent="0" use-parent-layout="false"/>
+        </constraints>
+        <properties/>
+      </component>
+      <component id="5c614" class="com.intellij.openapi.ui.FixedSizeButton" binding="myBrowseButton">
+        <constraints>
+          <grid row="0" column="2" row-span="1" col-span="1" vsize-policy="0" hsize-policy="0" anchor="0" fill="1" indent="0" use-parent-layout="false">
+            <minimum-size width="30" height="25"/>
+          </grid>
+        </constraints>
+        <properties/>
+      </component>
+      <component id="f1e10" class="javax.swing.JButton" binding="myRefreshButton">
+        <constraints>
+          <grid row="0" column="3" row-span="1" col-span="1" vsize-policy="0" hsize-policy="0" anchor="0" fill="1" indent="0" use-parent-layout="false">
+            <minimum-size width="30" height="23"/>
+          </grid>
+        </constraints>
+        <properties>
+          <hideActionText value="false"/>
+          <text value=""/>
+          <toolTipText value="Refresh course list"/>
+          <verticalAlignment value="1"/>
+          <verticalTextPosition value="1"/>
+        </properties>
+      </component>
+    </children>
+  </grid>
+</form>
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/ui/StudyNewProjectPanel.java b/python/edu/learn-python/src/com/jetbrains/python/edu/ui/StudyNewProjectPanel.java
new file mode 100644
index 0000000..0f1ec08
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/ui/StudyNewProjectPanel.java
@@ -0,0 +1,196 @@
+package com.jetbrains.python.edu.ui;
+
+import com.intellij.facet.ui.FacetValidatorsManager;
+import com.intellij.facet.ui.ValidationResult;
+import com.intellij.openapi.fileChooser.FileChooser;
+import com.intellij.openapi.fileChooser.FileChooserDescriptor;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.util.Consumer;
+import com.jetbrains.python.edu.StudyDirectoryProjectGenerator;
+import com.jetbrains.python.edu.StudyUtils;
+import com.jetbrains.python.edu.course.CourseInfo;
+import icons.StudyIcons;
+
+import javax.swing.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.io.File;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * author: liana
+ * data: 7/31/14.
+ */
+public class StudyNewProjectPanel{
+  private Set<CourseInfo> myAvailableCourses = new HashSet<CourseInfo>();
+  private JComboBox myCoursesComboBox;
+  private JButton myBrowseButton;
+  private JButton myRefreshButton;
+  private JPanel myContentPanel;
+  private JLabel myAuthorLabel;
+  private JLabel myDescriptionLabel;
+  private final StudyDirectoryProjectGenerator myGenerator;
+  private static final String CONNECTION_ERROR = "<html>Failed to download courses.<br>Check your Internet connection.</html>";
+  private static final String INVALID_COURSE = "Selected course is invalid";
+  private FacetValidatorsManager myValidationManager;
+
+  public StudyNewProjectPanel(StudyDirectoryProjectGenerator generator) {
+    myGenerator = generator;
+    Map<CourseInfo, File> courses = myGenerator.getCourses();
+    if (courses.isEmpty()) {
+      setError(CONNECTION_ERROR);
+    }
+    else {
+      myAvailableCourses = courses.keySet();
+      for (CourseInfo courseInfo : myAvailableCourses) {
+        myCoursesComboBox.addItem(courseInfo);
+      }
+      myAuthorLabel.setText("Author: " + StudyUtils.getFirst(myAvailableCourses).getAuthor());
+      myDescriptionLabel.setText(StudyUtils.getFirst(myAvailableCourses).getDescription());
+      //setting the first course in list as selected
+      myGenerator.setSelectedCourse(StudyUtils.getFirst(myAvailableCourses));
+      setOK();
+    }
+    initListeners();
+    myRefreshButton.setVisible(true);
+    myRefreshButton.setIcon(StudyIcons.Refresh);
+  }
+
+  private void initListeners() {
+
+    final FileChooserDescriptor fileChooser = new FileChooserDescriptor(true, false, false, true, false, false) {
+      @Override
+      public boolean isFileVisible(VirtualFile file, boolean showHiddenFiles) {
+        return file.isDirectory() || StudyUtils.isZip(file.getName());
+      }
+
+      @Override
+      public boolean isFileSelectable(VirtualFile file) {
+        return StudyUtils.isZip(file.getName());
+      }
+    };
+    myBrowseButton.addActionListener(new ActionListener() {
+      @Override
+      public void actionPerformed(ActionEvent e) {
+        FileChooser.chooseFile(fileChooser, null, null,
+                               new Consumer<VirtualFile>() {
+                                 @Override
+                                 public void consume(VirtualFile file) {
+                                   String fileName = file.getPath();
+                                   int oldSize = myAvailableCourses.size();
+                                   CourseInfo courseInfo = myGenerator.addLocalCourse(fileName);
+                                   if (courseInfo != null)  {
+                                     if (oldSize != myAvailableCourses.size()) {
+                                       myCoursesComboBox.addItem(courseInfo);
+                                     }
+                                     myCoursesComboBox.setSelectedItem(courseInfo);
+                                     setOK();
+                                   }
+                                   else {
+                                     setError(INVALID_COURSE);
+                                     myCoursesComboBox.removeAllItems();
+                                     myCoursesComboBox.addItem(CourseInfo.INVALID_COURSE);
+                                     for (CourseInfo course : myAvailableCourses) {
+                                       myCoursesComboBox.addItem(course);
+                                     }
+                                     myCoursesComboBox.setSelectedItem(CourseInfo.INVALID_COURSE);
+                                   }
+                                 }
+                               });
+      }
+    });
+    myRefreshButton.addActionListener(new RefreshActionListener());
+    myCoursesComboBox.addActionListener(new CourseSelectedListener());
+  }
+
+  private void setError(String errorMessage) {
+    myGenerator.setValidationResult(new ValidationResult(errorMessage));
+    if (myValidationManager != null) {
+      myValidationManager.validate();
+    }
+  }
+
+  private void setOK() {
+    myGenerator.setValidationResult(ValidationResult.OK);
+    if (myValidationManager != null) {
+      myValidationManager.validate();
+    }
+  }
+
+  public JPanel getContentPanel() {
+    return myContentPanel;
+  }
+
+  public void registerValidators(final FacetValidatorsManager manager) {
+    myValidationManager = manager;
+  }
+
+
+  /**
+   * Handles refreshing courses
+   * Old courses added to new courses only if their
+   * meta file still exists in local file system
+   */
+  private class RefreshActionListener implements ActionListener {
+    @Override
+    public void actionPerformed(ActionEvent e) {
+      myGenerator.downloadAndUnzip(true);
+      Map<CourseInfo, File> downloadedCourses = myGenerator.loadCourses();
+      if (downloadedCourses.isEmpty()) {
+        setError(CONNECTION_ERROR);
+        return;
+      }
+      Map<CourseInfo, File> oldCourses = myGenerator.getLoadedCourses();
+      Map<CourseInfo, File> newCourses = new HashMap<CourseInfo, File>();
+      for (Map.Entry<CourseInfo, File> course : oldCourses.entrySet()) {
+        File courseFile = course.getValue();
+        if (courseFile.exists()) {
+          newCourses.put(course.getKey(), courseFile);
+        }
+      }
+      for (Map.Entry<CourseInfo, File> course : downloadedCourses.entrySet()) {
+        CourseInfo courseName = course.getKey();
+        if (newCourses.get(courseName) == null) {
+          newCourses.put(courseName, course.getValue());
+        }
+      }
+      myCoursesComboBox.removeAllItems();
+
+      for (CourseInfo courseInfo : newCourses.keySet()) {
+        myCoursesComboBox.addItem(courseInfo);
+      }
+      myGenerator.setSelectedCourse(StudyUtils.getFirst(newCourses.keySet()));
+
+      myGenerator.setCourses(newCourses);
+      myAvailableCourses = newCourses.keySet();
+      myGenerator.flushCache();
+    }
+  }
+
+
+  /**
+   * Handles selecting course in combo box
+   * Sets selected course in combo box as selected in
+   * {@link StudyNewProjectPanel#myGenerator}
+   */
+  private class CourseSelectedListener implements ActionListener {
+    @Override
+    public void actionPerformed(ActionEvent e) {
+      JComboBox cb = (JComboBox)e.getSource();
+      CourseInfo selectedCourse = (CourseInfo)cb.getSelectedItem();
+      if (selectedCourse == null || selectedCourse.equals(CourseInfo.INVALID_COURSE)) {
+        myAuthorLabel.setText("");
+        myDescriptionLabel.setText("");
+        return;
+      }
+      myAuthorLabel.setText("Author: " + selectedCourse.getAuthor());
+      myCoursesComboBox.removeItem(CourseInfo.INVALID_COURSE);
+      myDescriptionLabel.setText(selectedCourse.getDescription());
+      myGenerator.setSelectedCourse(selectedCourse);
+      setOK();
+    }
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/ui/StudyProgressBar.java b/python/edu/learn-python/src/com/jetbrains/python/edu/ui/StudyProgressBar.java
new file mode 100644
index 0000000..97fa00d
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/ui/StudyProgressBar.java
@@ -0,0 +1,92 @@
+package com.jetbrains.python.edu.ui;
+
+import com.intellij.openapi.project.DumbAware;
+import com.intellij.openapi.ui.GraphicsConfig;
+import com.intellij.ui.ColorUtil;
+import com.intellij.ui.Gray;
+import com.intellij.ui.JBColor;
+import com.intellij.util.ui.GraphicsUtil;
+import com.intellij.util.ui.UIUtil;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.geom.Rectangle2D;
+
+public class StudyProgressBar extends JComponent implements DumbAware {
+  public static final Color BLUE = JBColor.BLUE;
+  private static final Color SHADOW1 = new JBColor(Gray._190, JBColor.border());
+  private static final Color SHADOW2 = Gray._105;
+  private static final int BRICK_WIDTH = 10;
+  private static final int BRICK_SPACE = 2;
+  private final int myHeight;
+  private final int myIndent;
+  private double myFraction = 0.0;
+  private Color myColor = BLUE;
+
+  public StudyProgressBar(double fraction, Color color, int height, int indent) {
+    myFraction = fraction;
+    myColor = color;
+    myHeight = height;
+    myIndent = indent;
+  }
+
+  private int getBricksToDraw(double fraction) {
+    int bricksTotal = (getWidth() - 8) / (BRICK_WIDTH + BRICK_SPACE);
+    return (int)(bricksTotal * fraction) + 1;
+  }
+
+  protected void paintComponent(Graphics g) {
+    final GraphicsConfig config = GraphicsUtil.setupAAPainting(g);
+    Graphics2D g2 = (Graphics2D)g;
+    if (myFraction > 1) {
+      myFraction = 1;
+    }
+
+    Dimension size = getSize();
+    double width = size.getWidth() - 2*myIndent;
+    g2.setPaint(UIUtil.getListBackground());
+    Rectangle2D rect = new Rectangle2D.Double(myIndent, 0, width, myHeight);
+    g2.fill(rect);
+
+    g2.setPaint(new JBColor(SHADOW1, JBColor.border()));
+    rect.setRect(myIndent, 0, width, myHeight);
+    int arcWidth = 5;
+    int arcHeight = 5;
+    g2.drawRoundRect(myIndent, 0, (int)width, myHeight, arcWidth, arcHeight);
+    g2.setPaint(SHADOW2);
+    g2.drawRoundRect(myIndent, 0, (int)width, myHeight, arcWidth, arcHeight);
+
+    int y_center = myHeight / 2;
+    int y_steps = myHeight / 2 - 3;
+    int alpha_step = y_steps > 0 ? (255 - 70) / y_steps : 255 - 70;
+    int x_offset = 4;
+
+    g.setClip(4 + myIndent, 3, (int)width - 6, myHeight - 4);
+
+    int bricksToDraw = myFraction == 0 ? 0 : getBricksToDraw(myFraction);
+    for (int i = 0; i < bricksToDraw; i++) {
+      g2.setPaint(myColor);
+      UIUtil.drawLine(g2, x_offset, y_center, x_offset + BRICK_WIDTH - 1, y_center);
+      for (int j = 0; j < y_steps; j++) {
+        Color color = ColorUtil.toAlpha(myColor, 255 - alpha_step * (j + 1));
+        g2.setPaint(color);
+        UIUtil.drawLine(g2, x_offset, y_center - 1 - j, x_offset + BRICK_WIDTH - 1, y_center - 1 - j);
+        if (!(y_center % 2 != 0 && j == y_steps - 1)) {
+          UIUtil.drawLine(g2, x_offset, y_center + 1 + j, x_offset + BRICK_WIDTH - 1, y_center + 1 + j);
+        }
+      }
+      g2.setColor(
+        ColorUtil.toAlpha(myColor, 255 - alpha_step * (y_steps / 2 + 1)));
+      g2.drawRect(x_offset, y_center - y_steps, BRICK_WIDTH - 1, myHeight - 7);
+      x_offset += BRICK_WIDTH + BRICK_SPACE;
+    }
+    config.restore();
+  }
+
+  @Override
+  public Dimension getMaximumSize() {
+    Dimension dimension = super.getMaximumSize();
+    dimension.height = myHeight + 10;
+    return dimension;
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/ui/StudyTestContentPanel.java b/python/edu/learn-python/src/com/jetbrains/python/edu/ui/StudyTestContentPanel.java
new file mode 100644
index 0000000..dee4fba
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/ui/StudyTestContentPanel.java
@@ -0,0 +1,67 @@
+package com.jetbrains.python.edu.ui;
+
+import com.intellij.ui.DocumentAdapter;
+import com.intellij.ui.components.JBScrollPane;
+import org.jetbrains.annotations.NotNull;
+import com.jetbrains.python.edu.course.UserTest;
+
+import javax.swing.*;
+import javax.swing.event.DocumentEvent;
+import javax.swing.text.BadLocationException;
+import java.awt.*;
+
+public class StudyTestContentPanel extends JPanel {
+  public static final Dimension PREFERRED_SIZE = new Dimension(300, 200);
+  private static final Font HEADER_FONT = new Font("Arial", Font.BOLD, 16);
+  private final JTextArea myInputArea = new JTextArea();
+  private final JTextArea myOutputArea = new JTextArea();
+  public StudyTestContentPanel(UserTest userTest) {
+    this.setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
+    initContentLabel("input", myInputArea);
+    myInputArea.getDocument().addDocumentListener(new BufferUpdater(userTest.getInputBuffer()));
+    myOutputArea.getDocument().addDocumentListener(new BufferUpdater(userTest.getOutputBuffer()));
+    initContentLabel("output", myOutputArea);
+    setEditable(userTest.isEditable());
+  }
+
+  private void initContentLabel(final String headerText, @NotNull final JTextArea contentArea) {
+    JLabel headerLabel = new JLabel(headerText);
+    headerLabel.setFont(HEADER_FONT);
+    this.add(headerLabel);
+    this.add(new JSeparator(SwingConstants.HORIZONTAL));
+    JScrollPane scroll = new JBScrollPane(contentArea);
+    scroll.setPreferredSize(PREFERRED_SIZE);
+    this.add(scroll);
+  }
+
+  private void setEditable(boolean isEditable) {
+    myInputArea.setEditable(isEditable);
+    myOutputArea.setEditable(isEditable);
+  }
+  public void addInputContent(final String content) {
+    myInputArea.setText(content);
+  }
+
+  public  void addOutputContent(final String content) {
+    myOutputArea.setText(content);
+  }
+
+  private class BufferUpdater extends DocumentAdapter {
+    private final StringBuilder myBuffer;
+
+    private BufferUpdater(StringBuilder buffer) {
+      myBuffer = buffer;
+    }
+
+    @Override
+    protected void textChanged(DocumentEvent e) {
+      myBuffer.delete(0, myBuffer.length());
+      try {
+        myBuffer.append(e.getDocument().getText(0, e.getDocument().getLength()));
+      }
+      catch (BadLocationException e1) {
+        e1.printStackTrace();
+      }
+    }
+  }
+}
diff --git a/python/edu/learn-python/src/com/jetbrains/python/edu/ui/StudyToolWindowFactory.java b/python/edu/learn-python/src/com/jetbrains/python/edu/ui/StudyToolWindowFactory.java
new file mode 100644
index 0000000..a553978
--- /dev/null
+++ b/python/edu/learn-python/src/com/jetbrains/python/edu/ui/StudyToolWindowFactory.java
@@ -0,0 +1,81 @@
+package com.jetbrains.python.edu.ui;
+
+import com.intellij.openapi.project.DumbAware;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.wm.ToolWindow;
+import com.intellij.openapi.wm.ToolWindowFactory;
+import com.intellij.ui.JBColor;
+import com.intellij.ui.content.Content;
+import com.intellij.ui.content.ContentFactory;
+import com.intellij.util.ui.UIUtil;
+import com.jetbrains.python.edu.StudyTaskManager;
+import com.jetbrains.python.edu.course.Course;
+import com.jetbrains.python.edu.course.Lesson;
+import com.jetbrains.python.edu.course.LessonInfo;
+import com.jetbrains.python.edu.course.StudyStatus;
+import org.jetbrains.annotations.NotNull;
+
+import javax.swing.*;
+import java.awt.*;
+import java.util.List;
+
+public class StudyToolWindowFactory implements ToolWindowFactory, DumbAware {
+  public static final String STUDY_TOOL_WINDOW = "Course Description";
+  JPanel contentPanel = new JPanel();
+
+  @Override
+  public void createToolWindowContent(@NotNull final Project project, @NotNull final ToolWindow toolWindow) {
+    if (StudyTaskManager.getInstance(project).getCourse() != null) {
+      contentPanel.setLayout(new BoxLayout(contentPanel, BoxLayout.PAGE_AXIS));
+      contentPanel.add(Box.createRigidArea(new Dimension(10, 0)));
+      StudyTaskManager taskManager = StudyTaskManager.getInstance(project);
+      Course course = taskManager.getCourse();
+      if (course == null) {
+        return;
+      }
+      String courseName = UIUtil.toHtml("<h1>" + course.getName() + "</h1>", 10);
+      String description = UIUtil.toHtml(course.getDescription(), 5);
+      String author = taskManager.getCourse().getAuthor();
+      String authorLabel = UIUtil.toHtml("<b>Author: </b>" + author, 5);
+      contentPanel.add(new JLabel(courseName));
+      contentPanel.add(new JLabel(authorLabel));
+      contentPanel.add(Box.createRigidArea(new Dimension(0, 10)));
+      contentPanel.add(new JLabel(description));
+
+      int taskNum = 0;
+      int taskSolved = 0;
+      int lessonsCompleted = 0;
+      List<Lesson> lessons = course.getLessons();
+      for (Lesson lesson : lessons) {
+        if (lesson.getStatus() == StudyStatus.Solved) {
+          lessonsCompleted++;
+        }
+        LessonInfo lessonInfo = lesson.getLessonInfo();
+        taskNum += lessonInfo.getTaskNum();
+        taskSolved += lessonInfo.getTaskSolved();
+      }
+      String completedLessons = String.format("%d of %d lessons completed", lessonsCompleted, course.getLessons().size());
+      String completedTasks = String.format("%d of %d tasks completed", taskSolved, taskNum);
+      String tasksLeft = String.format("%d of %d tasks left", taskNum - taskSolved, taskNum);
+      contentPanel.add(Box.createVerticalStrut(10));
+      addStatistics(completedLessons);
+      addStatistics(completedTasks);
+
+      double percent = (taskSolved * 100.0) / taskNum;
+      contentPanel.add(Box.createRigidArea(new Dimension(0, 10)));
+      StudyProgressBar studyProgressBar = new StudyProgressBar(percent / 100, JBColor.GREEN, 40, 10);
+      contentPanel.add(studyProgressBar);
+      addStatistics(tasksLeft);
+      ContentFactory contentFactory = ContentFactory.SERVICE.getInstance();
+      Content content = contentFactory.createContent(contentPanel, "", true);
+      toolWindow.getContentManager().addContent(content);
+    }
+  }
+
+  private void addStatistics(String statistics) {
+    String labelText = UIUtil.toHtml(statistics, 5);
+    contentPanel.add(Box.createRigidArea(new Dimension(0, 10)));
+    JLabel statisticLabel = new JLabel(labelText);
+    contentPanel.add(statisticLabel);
+  }
+}
diff --git a/python/edu/learn-python/testData/course.json b/python/edu/learn-python/testData/course.json
new file mode 100644
index 0000000..bff570a
--- /dev/null
+++ b/python/edu/learn-python/testData/course.json
@@ -0,0 +1,130 @@
+{
+  "name": "Python для начинающих",
+  "description": "Начальный курс по языку Python",
+  "lessons": [
+    {
+      "name": "Первые программа",
+      "task_list": [
+        {
+          "name": "Задание 1",
+          "text": "hello-text.html",
+          "test_file": "hello-tests.py",
+          "test_num": 1,
+          "task_files": {
+            "helloworld.py": {
+              "task_windows": [
+                {
+                  "line": 0,
+                  "start": 0,
+                  "text": "type operator",
+                  "hint": "hello-text.html",
+                  "possible_answer": "print"
+                },
+                {
+                  "line": 0,
+                  "start": 33,
+                  "text": "type your name",
+                  "hint": "empty_study.docs",
+                  "possible_answer": "Liana"
+                }
+              ]
+            }
+          }
+        },
+        {
+          "name": "Задание 2",
+          "text": "matchends-text.html",
+          "test_file": "matchends-test.py",
+          "test_num": 3,
+          "task_files": {
+            "match_ends.py": {
+              "task_windows": [
+                {
+                  "line": 1,
+                  "start": 43,
+                  "text": "condition",
+                  "hint": "empty_study.docs",
+                  "possible_answer": ">="
+                },
+                {
+                  "line": 1,
+                  "start": 61,
+                  "text": "index",
+                  "hint": "empty_study.docs",
+                  "possible_answer": "0"
+                },
+                {
+                  "line": 1,
+                  "start": 73,
+                  "text": "index",
+                  "hint": "empty_study.docs",
+                  "possible_answer": "-1"
+                },
+                {
+                  "line": 2,
+                  "start": 11,
+                  "text": "function",
+                  "hint": "list.docs",
+                  "possible_answer": "len"
+                }
+              ]
+            }
+          }
+        }
+      ]
+    },
+    {
+      "name": "Простые задачи",
+      "task_list": [
+        {
+          "name": "Задание 1",
+          "text": "sum-text.html",
+          "test_file": "sum_tests.py",
+          "test_num": 3,
+          "user_tests": [
+            {
+              "input": "sum-input.txt",
+              "output": "sum-output"
+            }
+          ],
+          "task_files": {
+            "sum.py": {
+              "task_windows": [
+                {
+                  "line": 4,
+                  "start": 15,
+                  "text": "получите из консоли имя файла",
+                  "hint": "argv.docs",
+                  "possible_answer": "sys.argv[1]"
+                },
+                {
+                  "line": 5,
+                  "start": 8,
+                  "text": "откройте файл на запись",
+                  "hint": "empty_study.docs",
+                  "possible_answer": "open(filename, 'r')"
+                },
+                {
+                  "line": 10,
+                  "start": 4,
+                  "text": "закройте файл",
+                  "hint": "empty_study.docs",
+                  "possible_answer": "f.close()"
+                },
+                {
+                  "line": 11,
+                  "start": 14,
+                  "text": "правильно проинициализируйте значение",
+                  "hint": "empty_study.docs",
+                  "possible_answer": "-sys.maxint"
+                }
+              ]
+            }
+          }
+        }
+
+      ]
+
+    }
+  ]
+}
\ No newline at end of file
diff --git a/python/edu/learn-python/tests/JsonParserTest.java b/python/edu/learn-python/tests/JsonParserTest.java
new file mode 100644
index 0000000..903f0a5
--- /dev/null
+++ b/python/edu/learn-python/tests/JsonParserTest.java
@@ -0,0 +1,37 @@
+import com.google.gson.FieldNamingPolicy;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import org.junit.Before;
+import org.junit.Test;
+import com.jetbrains.python.edu.StudyUtils;
+import com.jetbrains.python.edu.course.Course;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.InputStreamReader;
+import java.io.Reader;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * author: liana
+ * data: 7/4/14.
+ */
+public class JsonParserTest {
+  private Course myCourse = null;
+  @Before
+  public void setUp() throws FileNotFoundException {
+    Reader reader = new InputStreamReader(new FileInputStream("EDIDE/testData/course.json"));
+    Gson gson = new GsonBuilder().setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES).create();
+    myCourse = gson.fromJson(reader, Course.class);
+  }
+
+  @Test
+  public void testCourseLevel() {
+    assertEquals(myCourse.getName(), "Python для начинающих");
+    assertEquals(StudyUtils.getFirst(myCourse.getLessons().get(1).getTaskList().get(0).getUserTests()).getInput(), "sum-input.txt");
+    assertEquals(myCourse.getLessons().size(), 2);
+    assertEquals(myCourse.getLessons().get(0).getTaskList().size(), 2);
+    assertEquals(myCourse.getLessons().get(1).getTaskList().size(), 1);
+  }
+}