diff --git a/.gitignore b/.gitignore
index 740fcdf4f..765ba3bfc 100644
--- a/.gitignore
+++ b/.gitignore
@@ -51,3 +51,5 @@
 **/**.mp4
 /documentation/jupyter_execute/
 /documentation/**/**.gif
+/documentation/source/img.png
+/documentation/source/demo.png
diff --git a/documentation/README.md b/documentation/README.md
index 87bedad75..38e4332fa 100644
--- a/documentation/README.md
+++ b/documentation/README.md
@@ -79,4 +79,8 @@ And you need to skip all cells you don't want to run with cell tags:
 
 ```python
 {"tags": ["skip-execution"]}
-```
\ No newline at end of file
+```
+
+### Preprocess-Add colab link
+Everytime the `make html` is called, all `ipynb` file will have corresponding colab link in it by modifying the source
+code. So you will find that your source code is modified in git. Please commit that changes as well.
diff --git a/documentation/source/action.ipynb b/documentation/source/action.ipynb
index ca1374549..5383d2e28 100644
--- a/documentation/source/action.ipynb
+++ b/documentation/source/action.ipynb
@@ -6,6 +6,9 @@
    "metadata": {},
    "source": [
     "# Action and Policy\n",
+    "\n",
+    "[![Click and Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/metadriverse/metadrive/blob/main/documentation/source/action.ipynb)\n",
+    "\n",
     "This section will discuss how to control the vehicle in MetaDrive with the *Policy* interface. Before this, let's have a look at the raw control signal required by vehicles.\n",
     "\n",
     "## Action\n",
@@ -786,7 +789,7 @@
    "metadata": {},
    "source": [
     "### ReplayPolicy\n",
-    "Usually, we use [ScenarioNet](https://metadriverse.github.io/scenarionet/) to convert scenarios collected by Waymo, nuScenes, nuPlan, and Argoverse to internal [Scenario Description](description.ipynb) and rebuild the scenarios in MetaDrive. Thus this policy is used to load and replay the recorded traffic trajectories for these real-world scenarios. There are two replay policies for replaying the trajectories of ego car and traffic participants, respectively:\n",
+    "Usually, we use [ScenarioNet](https://metadriverse.github.io/scenarionet/) to convert scenarios collected by Waymo, nuScenes, nuPlan, and Argoverse to internal [Scenario Description](scenario_description.ipynb) and rebuild the scenarios in MetaDrive. Thus this policy is used to load and replay the recorded traffic trajectories for these real-world scenarios. There are two replay policies for replaying the trajectories of ego car and traffic participants, respectively:\n",
     "* **ReplayEgoCarPolicy**\n",
     "* **ReplayTrafficParticipantPolicy**\n",
     "\n",
diff --git a/documentation/source/before_reading.ipynb b/documentation/source/before_reading.ipynb
index 9a1c44d75..c4750627a 100644
--- a/documentation/source/before_reading.ipynb
+++ b/documentation/source/before_reading.ipynb
@@ -6,6 +6,9 @@
    "metadata": {},
    "source": [
     "# Before reading the Doc\n",
+    "\n",
+    "[![Click and Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/metadriverse/metadrive/blob/main/documentation/source/before_reading.ipynb)\n",
+    "\n",
     "Most of the document is made with `jupyter notebook`. Therefore, you can clone the [repo](https://github.com/metadriverse/metadrive) and run the demo code listed in `metadrive/documentation/source/*.ipynb` on your local machine. These examples are supposed to work with the latest main branch. Note: videos can not be played in notebook as it doesn't support `<video>` label.\n",
     "\n",
     "Some code cell contains the expected running results. If you find your running is different from the existing cell output or the code is broken, please file an issue in our [github repo](https://github.com/metadriverse/metadrive). "
diff --git a/documentation/source/conf.py b/documentation/source/conf.py
index 6601f20fe..55c01ab68 100644
--- a/documentation/source/conf.py
+++ b/documentation/source/conf.py
@@ -74,3 +74,39 @@
     "html_image",
 ]
 myst_url_schemes = ("http", "https", "mailto")
+
+# This will add the colab execution link automatically!
+import os
+import nbformat
+
+
+def add_hyperlink_to_notebook(notebook_path):
+    """
+    Add the colab link to notebook!
+    """
+    nb = nbformat.read(notebook_path, as_version=4)
+    link_text = "https://colab.research.google.com/github/metadriverse/metadrive/blob/main/documentation/source/{}".format(
+        os.path.basename(notebook_path))
+    link_text = "[![Click and Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)]({})".format(
+        link_text)
+    # Assuming you want to add the link below the first heading
+    cell = nb.cells[0]
+    assert cell.cell_type == 'markdown', cell
+    if "colab" not in cell.source:
+        p = cell.source.find("\n")
+        cell.source = cell.source[:p] + f"\n\n{link_text}\n" + cell.source[p:]
+        # print(cell.source)
+        nbformat.write(nb, notebook_path)
+
+
+def process_notebooks(directory):
+    """
+    Add to all notebook.
+    """
+    for root, dirs, files in os.walk(directory):
+        for file in files:
+            if file.endswith(".ipynb"):
+                add_hyperlink_to_notebook(os.path.join(root, file))
+
+
+process_notebooks(os.path.dirname(__file__))
diff --git a/documentation/source/config_system.ipynb b/documentation/source/config_system.ipynb
index d7f40235b..f88ce95de 100644
--- a/documentation/source/config_system.ipynb
+++ b/documentation/source/config_system.ipynb
@@ -7,6 +7,9 @@
    "source": [
     "# Configuration\n",
     "\n",
+    "[![Click and Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/metadriverse/metadrive/blob/main/documentation/source/config_system.ipynb)\n",
+    "\n",
+    "\n",
     "A MetaDrive instance accepts a dict as the environmental config. For example, you can build a MetaDrive instance with 200 generated maps via \n",
     "```python\n",
     "from metadrive import MetaDriveEnv\n",
diff --git a/documentation/source/debug_mode.ipynb b/documentation/source/debug_mode.ipynb
index 29e7cf00e..b812c4ba1 100644
--- a/documentation/source/debug_mode.ipynb
+++ b/documentation/source/debug_mode.ipynb
@@ -6,6 +6,9 @@
    "metadata": {},
    "source": [
     "# Debugging mode\n",
+    "\n",
+    "[![Click and Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/metadriverse/metadrive/blob/main/documentation/source/debug_mode.ipynb)\n",
+    "\n",
     "Some configurations can be turned on to debug the simulator. As a result, you can get more console output from the simulation and visualizations such as coordinates and physics to help develop features or fix bugs. To receive debug messages, set `debug=True` in the config when creating the environment. In debug mode, the `log_level` will be changed to `logging.DEBUG`, so you will get more information from MetaDrive, Panda3D, and RenderPipeline in the console."
    ]
   },
diff --git a/documentation/source/development.rst b/documentation/source/development.rst
deleted file mode 100644
index ab9ab7cea..000000000
--- a/documentation/source/development.rst
+++ /dev/null
@@ -1,12 +0,0 @@
-.. _development_tips:
-
-
-######################
-Development Tips
-######################
-
-.. warning:: This page is working in progress!
-
-
-1. Remember to call RemoveNode of all NodePath!
-2. attachNewNode will also create NodePath so they should be destroyed too!
diff --git a/documentation/source/figs/execution_queue.png b/documentation/source/figs/execution_queue.png
index 3340d186a..c3e3847c3 100644
Binary files a/documentation/source/figs/execution_queue.png and b/documentation/source/figs/execution_queue.png differ
diff --git a/documentation/source/index.rst b/documentation/source/index.rst
index e14584a82..c5c618c3c 100644
--- a/documentation/source/index.rst
+++ b/documentation/source/index.rst
@@ -53,15 +53,16 @@ Please feel free to contact us if you have any suggestions or ideas!
    :maxdepth: 2
    :caption: Concepts and Customization
 
+   new_env.ipynb
    system_design.ipynb
    sensors.ipynb
    top_down_render.ipynb
    panda_render.ipynb
+   map.ipynb
    vehicle.ipynb
    navigation.ipynb
    scenario_description.ipynb
    record_replay.ipynb
-   development.rst
 
 .. toctree::
    :hidden:
diff --git a/documentation/source/log_msg.ipynb b/documentation/source/log_msg.ipynb
index 98e39aba9..6922a816b 100644
--- a/documentation/source/log_msg.ipynb
+++ b/documentation/source/log_msg.ipynb
@@ -7,6 +7,9 @@
    "source": [
     "# Log messages\n",
     "\n",
+    "[![Click and Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/metadriverse/metadrive/blob/main/documentation/source/log_msg.ipynb)\n",
+    "\n",
+    "\n",
     "Logging message is important to oversee the program status. MetaDrive adopts Python's `logging` module to log messages. "
    ]
   },
diff --git a/documentation/source/map.ipynb b/documentation/source/map.ipynb
new file mode 100644
index 000000000..c446a6125
--- /dev/null
+++ b/documentation/source/map.ipynb
@@ -0,0 +1,42 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "8b81ba11-b84b-4acd-85ee-e41d71b379b4",
+   "metadata": {},
+   "source": [
+    "# Map\n",
+    "\n",
+    "[![Click and Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/metadriverse/metadrive/blob/main/documentation/source/map.ipynb)\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "## PGMap\n",
+    "\n",
+    "## ScenarioMap"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.17"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/documentation/source/navigation.ipynb b/documentation/source/navigation.ipynb
index 1adfbb833..b9908a203 100644
--- a/documentation/source/navigation.ipynb
+++ b/documentation/source/navigation.ipynb
@@ -5,7 +5,9 @@
    "id": "008aaa7c",
    "metadata": {},
    "source": [
-    "# Navigation"
+    "# Navigation\n",
+    "\n",
+    "[![Click and Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/metadriverse/metadrive/blob/main/documentation/source/navigation.ipynb)"
    ]
   }
  ],
@@ -25,7 +27,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.13"
+   "version": "3.9.17"
   }
  },
  "nbformat": 4,
diff --git a/documentation/source/new_env.ipynb b/documentation/source/new_env.ipynb
new file mode 100644
index 000000000..75cd4b592
--- /dev/null
+++ b/documentation/source/new_env.ipynb
@@ -0,0 +1,328 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "0baf5128-fc22-4536-a0c1-610d6b614b93",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "source": [
+    "# Build New Env\n",
+    "\n",
+    "[![Click and Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/metadriverse/metadrive/blob/main/documentation/source/new_env.ipynb)\n",
+    "\n",
+    "This section will walk through how we build new environments or simulations from scratch.\n",
+    "We do the development on both Windows (10/11) and Linux (Ubuntu), using Pycharm.\n",
+    "Let's get familiar with the project first\n",
+    "\n",
+    "## Project Structure\n",
+    "\n",
+    "The project structure is as follows:\n",
+    "- **bridges**:  where the ros bridge, sumo bridge and other co-simulation modules are located\n",
+    "- **documentation**:  It contains files building this documentation\n",
+    "- **metadrive**:  the metadrive package, most content is in this directory\n",
+    "\n",
+    "The `metadrive` package has the following structure:\n",
+    "- **assets**:  it is downloaded from github releases automatically, containing models, textures, and mini-batch real-world scenarios\n",
+    "- **base_class**:  meta-classes for making other python classes, usually you don't need to modify it\n",
+    "- **component**:  objects/vehicles/maps/lanes/building, almost all elements used for constructing scenario is here\n",
+    "- **engine**:  it contains code regarding the simulation loop, top-down renderer, asset manager/loader, physics system, logger, skybox, shadow, and so on\n",
+    "- **envs**:  a collection of gym-style environments\n",
+    "- **examples**:  runnable scripts for making yourself familiar with MetaDrive\n",
+    "- **manager**:  managers that defines how to create/forward scene are stored here\n",
+    "- **obs**:  a collection of observations that define how to collect information from the simulator in each step\n",
+    "- **policy**:  a collection of policies that define how an object should act in each step\n",
+    "- **render_pipeline**:  it contains the deferred rendering pipeline, which is developed by [tobspr](https://github.com/tobspr/RenderPipeline)\n",
+    "- **scenario**:  it defines the universal scenario format and a set of tools to read data from the format, like parsing object state\n",
+    "- **shaders**:  .glsl shaders for making skybox, terrain, depth camera and so on\n",
+    "- **tests**:  unitest are located here, which can be viewed as examples as well\n",
+    "- **third_party**:  libraries developed by others\n",
+    "- **utils**:  various tool functions\n",
+    "- **constants.py**:  it defines constants and some properties used everywhere\n",
+    "- **type.py**:  all objects have a type label, which is selected from here\n",
+    "- **pull_asset**:  scripts to pull or update asset from the remote git release page"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7739d3dc-93c2-410d-8179-2112f14d36a2",
+   "metadata": {},
+   "source": [
+    "## Start point-BaseEnv\n",
+    "To start making your own environment, the first step is to have something runnable so you can build things on top of it.\n",
+    "This can be done with `BaseEnv`, which is an empty environment with only a vehicle placed in this environment.\n",
+    "So just make a new `your_env.py` file and put the following code into it.\n",
+    "**Note: we usually use 3D renderer to do development as it shows more details, but using 2D visualizer is allowed as well. In this doc, we use 2D renderer for convinience.** \n",
+    "If you have a screen with OpenGL support, you can completely remove the `env.render` and `env.top_down_renderer.generate_gif`. If OpenGL is not supported on your machine but a screen is still available, just turn off the `screen_record` and set `window=True` for top_down_renderer and remove `env.top_down_renderer.generate_gif`. Otherwise, just keep everying unchanged. Without a screen, the only way to visualize the environment is through generating GIFs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d7e05617-1c6d-41ee-8277-de6393fc0b11",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from metadrive.envs import BaseEnv\n",
+    "from metadrive.obs.observation_base import DummyObservation\n",
+    "import logging\n",
+    "\n",
+    "class MyEnv(BaseEnv):\n",
+    "\n",
+    "    def reward_function(self, agent):\n",
+    "        return 0, {}\n",
+    "\n",
+    "    def cost_function(self, agent):\n",
+    "        return 0, {}\n",
+    "\n",
+    "    def done_function(self, agent):\n",
+    "        return False, {}\n",
+    "    \n",
+    "    def get_single_observation(self):\n",
+    "        return DummyObservation()\n",
+    "        \n",
+    "\n",
+    "if __name__==\"__main__\":\n",
+    "    # create env\n",
+    "    env=MyEnv(dict(use_render=False, # if you have a screen and OpenGL suppor, you can set use_render=True to use 3D rendering  \n",
+    "                   manual_control=True, # we usually manually control the car to test environment\n",
+    "                   log_level=logging.CRITICAL)) # suppress logging message\n",
+    "    env.reset()\n",
+    "    for i in range(20):\n",
+    "        \n",
+    "        # step\n",
+    "        obs, reward, termination, truncate, info = env.step(env.action_space.sample())\n",
+    "        \n",
+    "        # you can set window=True and remove generate_gif() if you have a screen. \n",
+    "        # Or just use 3D rendering and remove all stuff related to env.render()  \n",
+    "        frame=env.render(mode=\"topdown\", \n",
+    "                         window=False, # turn me on, if you have screen\n",
+    "                         screen_record=True, # turn me off, if a window can be poped up\n",
+    "                         screen_size=(200, 200))\n",
+    "    env.top_down_renderer.generate_gif()\n",
+    "    env.close()\n",
+    "\n",
+    "from IPython.display import Image\n",
+    "Image(open(\"demo.gif\", 'rb').read())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "511c57de-38a7-4a85-9fd0-09e997a1948e",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "source": [
+    "As shown in the figure above, this environment contains nothing. We will make it complete gradually.\n",
+    "Firstly, let's add a map to the environment to make it a bit interesting.\n",
+    "**Also, when we develop a new environment, developing map and map management module is the first step we do. This is because map is the most important component associated with a lot of things like observation and navigation. Thus, the map has to be created in a scene firstly and the map management module `map_manager` should have the highest priority.**\n",
+    "\n",
+    "## MapManager\n",
+    "Compared to the last code cell, we add a map manager to generate different maps for each seed. Concretely, there are three maps and we choose from the three maps according to the global seed by `map_id = global_seed % 3`. New content added upon the last code cell are marked between two `======`. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5bc70887-1206-43a2-ad29-645175d03a0c",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from metadrive.envs import BaseEnv\n",
+    "from metadrive.obs.observation_base import DummyObservation\n",
+    "import logging\n",
+    "\n",
+    "# ======================================== new content ===============================================\n",
+    "import cv2\n",
+    "from metadrive.component.map.pg_map import PGMap\n",
+    "from metadrive.manager.base_manager import BaseManager\n",
+    "from metadrive.component.pgblock.first_block import FirstPGBlock\n",
+    "\n",
+    "class MyMapManager(BaseManager):\n",
+    "    PRIORITY = 0\n",
+    "\n",
+    "    def __init__(self):\n",
+    "        super(MyMapManager, self).__init__()\n",
+    "        self.current_map = None\n",
+    "        self.all_maps = {idx: None for idx in range(3)} # store the created map\n",
+    "        self._map_shape = [\"X\", \"T\", \"O\"] # three types of maps \n",
+    "\n",
+    "    def reset(self):\n",
+    "        idx = self.engine.global_random_seed % 3\n",
+    "        if self.all_maps[idx] is None:\n",
+    "            # create maps on the fly\n",
+    "            new_map = PGMap(map_config=dict(type=PGMap.BLOCK_SEQUENCE,\n",
+    "                                            config=self._map_shape[idx]))\n",
+    "            self.all_maps[idx] = new_map\n",
+    "\n",
+    "        # attach map in the world\n",
+    "        map = self.all_maps[idx]\n",
+    "        map.attach_to_world()\n",
+    "        self.current_map = map\n",
+    "        return dict(current_map=self._map_shape[idx])\n",
+    "\n",
+    "    def before_reset(self):\n",
+    "        if self.current_map is not None:\n",
+    "            self.current_map.detach_from_world()\n",
+    "            self.current_map = None\n",
+    "\n",
+    "    def destroy(self):\n",
+    "        # clear all maps when this manager is destroyed\n",
+    "        super(MyMapManager, self).destroy()\n",
+    "        for map in self.all_maps.values():\n",
+    "            if map is not None:\n",
+    "                map.destroy()\n",
+    "        self.all_maps = None\n",
+    "\n",
+    "\n",
+    "# Expand the default config system, specify where to spawn the car\n",
+    "MY_CONFIG = dict(agent_configs={\"default_agent\": dict(spawn_lane_index=(FirstPGBlock.NODE_1, FirstPGBlock.NODE_2, 0))}) \n",
+    "\n",
+    "\n",
+    "class MyEnv(BaseEnv):\n",
+    "    \n",
+    "    @classmethod\n",
+    "    def default_config(cls):\n",
+    "        config = super(MyEnv, cls).default_config()\n",
+    "        config.update(MY_CONFIG)\n",
+    "        return config\n",
+    "    \n",
+    "    def setup_engine(self):\n",
+    "        super(MyEnv, self).setup_engine()\n",
+    "        self.engine.register_manager(\"map_manager\", MyMapManager())\n",
+    "        \n",
+    "# ======================================== new content ===============================================\n",
+    "\n",
+    "    def reward_function(self, agent):\n",
+    "        return 0, {}\n",
+    "\n",
+    "    def cost_function(self, agent):\n",
+    "        return 0, {}\n",
+    "\n",
+    "    def done_function(self, agent):\n",
+    "        return False, {}\n",
+    "    \n",
+    "    def get_single_observation(self):\n",
+    "        return DummyObservation()\n",
+    "        \n",
+    "\n",
+    "if __name__==\"__main__\":\n",
+    "    frames = []\n",
+    "    \n",
+    "    # create env\n",
+    "    env=MyEnv(dict(use_render=False, # if you have a screen and OpenGL suppor, you can set use_render=True to use 3D rendering  \n",
+    "                   manual_control=True, # we usually manually control the car to test environment\n",
+    "                   num_scenarios=4,\n",
+    "                   log_level=logging.CRITICAL)) # suppress logging message\n",
+    "    for i in range(4):\n",
+    "        \n",
+    "        # reset\n",
+    "        o, info = env.reset(seed=i)\n",
+    "        print(\"Load map with shape: {}\".format(info[\"current_map\"]))\n",
+    "        # you can set window=True and remove generate_gif() if you have a screen. \n",
+    "        # Or just use 3D rendering and remove all stuff related to env.render()  \n",
+    "        frame=env.render(mode=\"topdown\", \n",
+    "                         window=False, # turn me on, if you have screen\n",
+    "                         scaling=3,\n",
+    "                         camera_position=(50, 0),\n",
+    "                         screen_size=(400, 400))\n",
+    "        frames.append(frame)\n",
+    "    cv2.imwrite(\"demo.png\",  cv2.cvtColor(cv2.hconcat(frames), cv2.COLOR_RGB2BGR))\n",
+    "    env.close()\n",
+    "\n",
+    "from IPython.display import Image\n",
+    "Image(open(\"demo.png\", 'rb').read())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2d074ecb-ebca-403b-8e23-804529332232",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "source": [
+    "The results show 4 scenarios and the 4th scenario is the same as the first one, as we repeatedly load the 3 maps according to `MyMapManager.reset()`.\n",
+    "This function also returns the shape of the current map, which you can access in the `info` returned by `env.step()`.\n",
+    "**Thus, in your own development, you can collect simulation information and return them by `env.step()` by returning a dictionary in these functions: `before_step`, `step`, `after_step`, `before_reset`, `reset`, `after_reset`.**\n",
+    "Another thing to take care of is that we overwrite the original `agent_configs` of `BaseEnv`.\n",
+    "It defines where to spawn the agent with the id `default_agent`.\n",
+    "You can create maps automatically with `PGMap` which combines some predefined blocks. Also, you can use the more general map API `ScenarioMap` which takes a dict defining lane centerline, lane lines (solid/dash), sidewalks, and crosswalks as input. More information about creating maps is at [maps](map.ipynb)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cb3c1b40-b4c5-4240-b32e-61ec201de898",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "source": [
+    "## AgentManager\n",
+    "\n",
+    "### Action Space\n",
+    "\n",
+    "### Observation Space\n",
+    "\n",
+    "The target you are interested in and wanna control\n",
+    "\n",
+    "## Other Managers\n",
+    "\n",
+    "## Development tips\n",
+    "\n",
+    "1. Remember to call RemoveNode of all NodePath!\n",
+    "2. attachNewNode will also create NodePath so they should be destroyed too!"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.17"
+  },
+  "mystnb": {
+   "execution_mode": "force"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/documentation/source/obs.ipynb b/documentation/source/obs.ipynb
index 35e34aa52..28a2d4721 100644
--- a/documentation/source/obs.ipynb
+++ b/documentation/source/obs.ipynb
@@ -13,6 +13,9 @@
    "source": [
     "# Observation\n",
     "\n",
+    "[![Click and Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/metadriverse/metadrive/blob/main/documentation/source/obs.ipynb)\n",
+    "\n",
+    "\n",
     "<img align=\"right\" src=\"figs/observation_demo.png\" width=350>\n",
     "\n",
     "MetaDrive provides various kinds of sensory input, as illustrated in the next figure.\n",
diff --git a/documentation/source/panda_render.ipynb b/documentation/source/panda_render.ipynb
index 412d82716..8f3933ab0 100644
--- a/documentation/source/panda_render.ipynb
+++ b/documentation/source/panda_render.ipynb
@@ -5,7 +5,9 @@
    "id": "3a2965f7",
    "metadata": {},
    "source": [
-    "# 3D Renderer"
+    "# 3D Renderer\n",
+    "\n",
+    "[![Click and Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/metadriverse/metadrive/blob/main/documentation/source/panda_render.ipynb)\n"
    ]
   }
  ],
@@ -25,7 +27,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.13"
+   "version": "3.9.17"
   }
  },
  "nbformat": 4,
diff --git a/documentation/source/points_and_lines.ipynb b/documentation/source/points_and_lines.ipynb
index 717d2dfca..52cc46be3 100644
--- a/documentation/source/points_and_lines.ipynb
+++ b/documentation/source/points_and_lines.ipynb
@@ -5,7 +5,10 @@
    "id": "a7ada9cf",
    "metadata": {},
    "source": [
-    "# Draw 3D Lines and Points"
+    "# Draw 3D Lines and Point\n",
+    "\n",
+    "[![Click and Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/metadriverse/metadrive/blob/main/documentation/source/points_and_lines.ipynb)\n",
+    "s"
    ]
   },
   {
diff --git a/documentation/source/record_replay.ipynb b/documentation/source/record_replay.ipynb
index 4f5b0eaff..136395a64 100644
--- a/documentation/source/record_replay.ipynb
+++ b/documentation/source/record_replay.ipynb
@@ -5,7 +5,9 @@
    "id": "e144a50f",
    "metadata": {},
    "source": [
-    "# Record and Replay"
+    "# Record and Replay\n",
+    "\n",
+    "[![Click and Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/metadriverse/metadrive/blob/main/documentation/source/record_replay.ipynb)"
    ]
   }
  ],
@@ -25,7 +27,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.13"
+   "version": "3.9.17"
   }
  },
  "nbformat": 4,
diff --git a/documentation/source/reward_cost_done.ipynb b/documentation/source/reward_cost_done.ipynb
index 8b7b27935..8cbb9b7e2 100644
--- a/documentation/source/reward_cost_done.ipynb
+++ b/documentation/source/reward_cost_done.ipynb
@@ -7,6 +7,9 @@
    "source": [
     "# Reward, Cost, Termination, and Step Information\n",
     "\n",
+    "[![Click and Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/metadriverse/metadrive/blob/main/documentation/source/reward_cost_done.ipynb)\n",
+    "\n",
+    "\n",
     "\n",
     "Following the standard OpenAI Gym API, after each step of the environment `env.step(...)`, the environment will return a tuple containing five items: `(obs, reward, terminated, truncated, info)`. In this page, we discuss the design of reward function `reward`, cost function `info[\"cost\"]`, termination criterion `terminated` in various settings, truncation information `truncated`, and the details of step information `info`."
    ]
diff --git a/documentation/source/rl_environments.ipynb b/documentation/source/rl_environments.ipynb
index 0739d426f..053f45cc0 100644
--- a/documentation/source/rl_environments.ipynb
+++ b/documentation/source/rl_environments.ipynb
@@ -6,6 +6,9 @@
    "metadata": {},
    "source": [
     "# Environments\n",
+    "\n",
+    "[![Click and Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/metadriverse/metadrive/blob/main/documentation/source/rl_environments.ipynb)\n",
+    "\n",
     "<a id='environments'></a>\n",
     "\n",
     "By default, there are 5 off-the-shelf RL environments:\n",
@@ -1455,7 +1458,7 @@
     "## Customization\n",
     "We are developing new environments for benchmarking novel and challenging RL tasks! Any idea on the design of new tasks are welcomed!\n",
     "\n",
-    "However, you may want to do development with MetaDrive and build your own environments from scratch. To this end, you have to be familiar with some basic concepts of MetaDrive and how the simulation works. Please refer to the content under **Concepts and Customiaiton** and the section [Developing Environments](TODO).\n",
+    "However, you may want to do development with MetaDrive and build your own environments from scratch. To this end, you have to be familiar with some basic concepts of MetaDrive and how the simulation works. Please refer to the content under **Concepts and Customiaiton** and the section [Developing Environments](new_env.ipynb).\n",
     "\n"
    ]
   },
diff --git a/documentation/source/scenario_description.ipynb b/documentation/source/scenario_description.ipynb
index 3a0170bb7..9e0c32ea8 100644
--- a/documentation/source/scenario_description.ipynb
+++ b/documentation/source/scenario_description.ipynb
@@ -7,11 +7,12 @@
    "source": [
     "# Scenario Description \n",
     "\n",
+    "[![Click and Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/metadriverse/metadrive/blob/main/documentation/source/scenario_description.ipynb)\n",
     "\n",
-    "There exists a lot real-world autonomous driving datasets, such as Waymo and nuPlan.\n",
     "\n",
-    "Those datasets contain rich information about road map, traffic lights, traffic participants and their motions.\n",
     "\n",
+    "There exists a lot real-world autonomous driving datasets, such as Waymo and nuPlan.\n",
+    "Those datasets contain rich information about road map, traffic lights, traffic participants and their motions.\n",
     "Those data can be imported to the MetaDrive so that we can reconstruct an interactive environments and replay (or even alter!) those scenarios recorded in the real world.\n",
     "\n",
     "To achieve that, we have a separated project called ScenarioNet (https://metadriverse.github.io/scenarionet/) that converts various sources of AD data into a unified data structure, manage those data, and import those data into MetaDrive for creating interactive environments.\n",
@@ -28,7 +29,7 @@
     "\n",
     "MetaDrive implements the **unified scenario description** in `metadrive/scenario/scenario_description.py` and [ScenarioNet](https://metadriverse.github.io/scenarionet/) implements the data management toolkits. \n",
     "\n",
-    "For completeness, we will walk through both the ScenarioNet dataset, which contains a lots of scenarios, in  and the Scenario Description, a nested dict that stores the information of one scenario."
+    "For completeness, we will walk through both the ScenarioNet dataset, which contains a lots of scenarios, and the Scenario Description, a nested dict that stores the information of one scenario."
    ]
   },
   {
@@ -38,20 +39,21 @@
    "source": [
     "## What is the ScenarioNet dataset?\n",
     "\n",
-    "**TL;DR: A established ScenarioNet dataset is a folder containing `dataset_summary.pkl` and `dataset_mapping.pkl` (optionally), along with a set of `.pkl` files each of which stores the unified scenario description of a scenario.**\n",
-    "\n",
-    "`dataset_mapping.pkl` contains the mapping from the scenario ID to the relative path. \n",
+    "**TL;DR: A established ScenarioNet dataset is a folder containing `dataset_summary.pkl` and `dataset_mapping.pkl` (optionally), along with a set of `scenario_version_id.pkl` files each of which stores the unified scenario description of a scenario.**\n",
     "\n",
-    "`dataset_summary.pkl` summarizes the meta information for each scenario.\n",
+    "To be specific, the functions of these files are as follows.\n",
     "\n",
-    "A set of `.pkl` files are stored either in the same folder of `dataset_summary.pkl` or in some other folders with the relative path to `dataset_summary.pkl` registered in `dataset_mapping.pkl`. Each of the `.pkl` file stores the serialized scenario description, i.e. a python dict, of a scenario.\n",
+    "- `dataset_summary.pkl` summarizes the meta information for each scenario. Like the number of objects and moving distance of each object.\n",
     "\n",
+    "- `dataset_mapping.pkl` contains the mapping from the scenario ID to its relative path on your machine. When this file is missing, the relative path to look up scenarios will be set to the directory of `dataset_summary.pkl`.\n",
     "\n",
-    "In this section, we demonstrate how to use the utilities from MetaDrive to easily access scenarios. We prepare two demo datasets, splitting from Waymo Open Dataset and nuScenes Dataset. Here we will demonstrate how to load the files.\n",
+    "- `scenario_version_id.pkl` stores the serialized scenario description, i.e. a python dict, of a scenario.\n",
     "\n",
+    "**Note: All these files are human readable after beding loadded and decoded by `pickle`**\n",
     "\n",
+    "Stored detailed scenario information, `scenario_version_id.pkl` files are stored either in the same folder of `dataset_summary.pkl` or in some other folders with the relative path to `dataset_summary.pkl` registered in `dataset_mapping.pkl`. The function of`dataset_mapping.pkl` is like a soft link or a pointer. Thus, to build new datasets, we only combine a set of relative paths pointing to target scenarios, without the need to copy `scenario_version_id.pkl` scenario files. In the following content, we call scenario files `.pkl` file for convenience.\n",
     "\n",
-    "You can also find some useful tutorials in ScenarioNet repo: https://github.com/metadriverse/scenarionet/tree/main/tutorial\n"
+    "In this section, we demonstrate how to use the utilities from MetaDrive to easily access scenarios. We prepare two demo datasets, splitting from Waymo Open Dataset and nuScenes Dataset. Here we will demonstrate how to load the files. You can also find some useful tutorials in ScenarioNet repo: https://github.com/metadriverse/scenarionet/tree/main/tutorial\n"
    ]
   },
   {
@@ -744,13 +746,13 @@
     {
      "data": {
       "text/plain": [
-       "\u001B[0;31mSignature:\u001B[0m\n",
-       "\u001B[0mscenario\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0msanity_check\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m\u001B[0m\n",
-       "\u001B[0;34m\u001B[0m    \u001B[0mscenario_dict\u001B[0m\u001B[0;34m,\u001B[0m\u001B[0;34m\u001B[0m\n",
-       "\u001B[0;34m\u001B[0m    \u001B[0mcheck_self_type\u001B[0m\u001B[0;34m=\u001B[0m\u001B[0;32mFalse\u001B[0m\u001B[0;34m,\u001B[0m\u001B[0;34m\u001B[0m\n",
-       "\u001B[0;34m\u001B[0m    \u001B[0mvalid_check\u001B[0m\u001B[0;34m=\u001B[0m\u001B[0;32mFalse\u001B[0m\u001B[0;34m,\u001B[0m\u001B[0;34m\u001B[0m\n",
-       "\u001B[0;34m\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n",
-       "\u001B[0;31mDocstring:\u001B[0m\n",
+       "\u001b[0;31mSignature:\u001b[0m\n",
+       "\u001b[0mscenario\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msanity_check\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0mscenario_dict\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0mcheck_self_type\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0mvalid_check\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+       "\u001b[0;31mDocstring:\u001b[0m\n",
        "Check if the input scenario dict is self-consistent and has filled required fields.\n",
        "\n",
        "The required high-level fields include tracks, dynamic_map_states, metadata, map_features.\n",
@@ -765,8 +767,8 @@
        "    check_self_type: if True, assert the input dict is a native Python dict.\n",
        "    valid_check: if True, we will assert the values for a given timestep are zeros if valid=False at that\n",
        "        timestep.\n",
-       "\u001B[0;31mFile:\u001B[0m      ~/metadrive/metadrive/scenario/scenario_description.py\n",
-       "\u001B[0;31mType:\u001B[0m      method"
+       "\u001b[0;31mFile:\u001b[0m      ~/metadrive/metadrive/scenario/scenario_description.py\n",
+       "\u001b[0;31mType:\u001b[0m      method"
       ]
      },
      "metadata": {},
@@ -1155,7 +1157,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.7.13"
   }
  },
  "nbformat": 4,
diff --git a/documentation/source/sensors.ipynb b/documentation/source/sensors.ipynb
index 9fb9b364e..cf6a75534 100644
--- a/documentation/source/sensors.ipynb
+++ b/documentation/source/sensors.ipynb
@@ -7,6 +7,9 @@
    "source": [
     "# Sensors\n",
     "\n",
+    "[![Click and Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/metadriverse/metadrive/blob/main/documentation/source/sensors.ipynb)\n",
+    "\n",
+    "\n",
     "Sensors are important for collecting information about surroundings.\n",
     "By default, all environments provide 3 basic sensors:\n",
     "\n",
diff --git a/documentation/source/system_design.ipynb b/documentation/source/system_design.ipynb
index 9661746bb..8a71ac218 100644
--- a/documentation/source/system_design.ipynb
+++ b/documentation/source/system_design.ipynb
@@ -7,6 +7,9 @@
    "source": [
     "# Simulation\n",
     "\n",
+    "[![Click and Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/metadriverse/metadrive/blob/main/documentation/source/system_design.ipynb)\n",
+    "\n",
+    "\n",
     "After going through this section, you will learn to customize an simulation environment with developer APIs. Before this, let's discuss what a simulation is.\n",
     "\n",
     "> *Simulation is the process of creating a model of a real or imagined system and then conducting experiments with this model. The purpose is usually to understand how the system works, to predict its behavior under different conditions, or to develop strategies for its operation. This is akin to creating a miniature, controllable version of a complex system in a virtual or conceptual space, where you can observe, experiment, and understand the outcomes without having to interact with the real system. This approach is invaluable in scenarios where real-world experimentation is impractical, dangerous, or impossible.*\n",
@@ -72,24 +75,25 @@
    "id": "e8b4bd74-6874-4dcb-ba93-78dc0172189b",
    "metadata": {},
    "source": [
-    "As we use the bullet engine for underlying physics simulation, the `self.engine.step()` is actually a wrapper to repeatedly execute `BulletWorld.doPhysics(dt, 1, dt)` several times which is determined by `decision_repeat`. It thus will forward the physics world by a time period, which is `dt x decision_repeat = 0.02 x 5 = 0.1s` by default. The result is the vehicle's speed will be increased to $5\\ m/s$ at state $s'$ if it has a $4.9\\ m/s$ speed with a $1m\\ /s^2$ acceleration before advancing the simulation.\n",
+    "As we use the bullet engine for underlying physics simulation, the `self.engine.step()` is actually a wrapper for repeatedly executing `BulletWorld.doPhysics(dt, 1, dt)`, where `dt` is the minimal sub-timestep for integration. A smaller `dt` produces a more accurate simulation. The `doPhysics()` is repeated by `decision_repeat` times and finally, the simulation will forward `dt * decision_repeat` seconds after calling `engine.step()`. This period is set to `0.1s` by default with `dt=0.02` and `decision_repeat=5`. For example, the vehicle's speed will be increased to $5\\ m/s$ at state $s'$ if it has a $4.9\\ m/s$ speed with a $1m\\ /s^2$ acceleration before advancing the simulation. \n",
     "\n",
     "Before advancing the physics world, there may be some preparations required. For example, if the external input contains signals for controlling a certain vehicle, the steering angles and the throttle value should be set on the target vehicle before stepping it. Thus all these preprocessings are finished by calling `self.engine.before_step()`. \n",
     "\n",
-    "Similarly, through `self.engine.after_step()`, we can post-process, calculate, and collect some information after advancing the simulation. For example, we usually detect if the vehicle collides with buildings, humans, and other vehicles in the post-processing. In addition, the state update can be finished in the `after_step` stage as well if these properties are pre-calculated somewhere. For example, if we are replaying vehicle trajectories collected in the real world, we can set the velocity and positions of vehicles in this stage directly. \n",
+    "Similarly, through `self.engine.after_step()`, we can post-process, calculate, and collect some information after advancing the simulation. For example, we usually detect if the vehicle collides with buildings, humans, and other vehicles in the post-processing. In addition, the state update can be finished in the `after_step` stage as well if these properties are pre-calculated somewhere. For example, if we are replaying vehicle trajectories collected in the real world, we can set the velocity and positions of vehicles in this stage directly. **Note: the `decision_repeat` DOES NOT take effect in `engine.before_step` and `engine.after_step`**.\n",
     "\n",
-    "If we dive deeper to check the `engine.before_step()`, `engine.step()`, and `engine.after_step()`. We will find that all three functions share the same structure. Take the `before_step()` function as the example. What the `engine.before_step()` does is actually sequentially executing `mgr.before_step()` for each manager.  \n",
+    "If we dive deeper to check the `engine.before_step()`, `engine.step()`, and `engine.after_step()`. We will find that all three functions share the same structure. Take the `before_step()` function as the example. It sequentially executes `mgr.before_step()` for each manager. \n",
     "```python\n",
     "def before_step(self):\n",
     "    for mgr in managers.values():\n",
-    "        mgr.before_step() # or mgr.step() or mgr.after_step()\n",
+    "        # or mgr.step() / mgr.after_step() for engine.step() / engine.after_step(), respectively\n",
+    "        mgr.before_step() \n",
     "```\n",
-    "Thus the `engine.step()` is to sequentially execute `before_step()`, `step()`, and `after_step()` for all managers.\n",
-    "In addition, a simulation needs an initial state as the start point of everything. \n",
+    "\n",
+    "In addition, a simulation needs an initial state as the starting point of everything.\n",
     "This is provided by calling `env.reset()`.\n",
-    "What happens in `env.reset()` is similar to `env.step()`: sequentailly calling `before_reset()` and `reset()` for all managers.\n",
+    "What happens in `env.reset()` is similar to `env.step()`: sequentailly calling `before_reset()`, `reset()`, `after_reset()` for all managers.\n",
     "\n",
-    "In a nutshell, the simulation and state transition are controlled and defined by chaining a set of managers. How to execute managers to do simulation is demonstrated in the following flow chart (supposing there are 2 managers in total).\n",
+    "In a nutshell, the simulation and state transition are controlled and defined by chaining a set of managers. How to execute managers to do simulation is demonstrated in the following flow chart (supposing there are 2 managers in total and the repetition *N*=config[\"decision_repeat\"]).\n",
     "\n",
     "<img src=\"figs/execution_queue.png\" width=\"800\" class=\"center\">\n",
     "\n",
@@ -263,7 +267,46 @@
    "metadata": {},
    "source": [
     "In practice, we use managers to manage almost everything such as maps, traffic, pedestrians, traffic lights, and so on.\n",
-    "You can find a lot of examples under the directory ```metadrive/managers```."
+    "You can find a lot of examples under the directory ```metadrive/managers```.\n",
+    "\n",
+    "### Priority\n",
+    "When multiple managers work together, it is necessary to determine the execution sequence. It can be decided by the `PRIORITY` property, which is a class property and needs to be specified when creating your manager. Managers with lower values have higher priorities. The code exemplifies this."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a962c84e-d8bf-4f77-a09b-25ec475d0c69",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from metadrive.envs import MetaDriveEnv\n",
+    "from metadrive.manager import BaseManager\n",
+    "\n",
+    "class Manager1(BaseManager):\n",
+    "    PRIORITY = 10\n",
+    "    \n",
+    "    def reset(self):\n",
+    "        print(\"Reset Manager 1\")\n",
+    "\n",
+    "class Manager2(BaseManager):\n",
+    "    PRIORITY = 20\n",
+    "\n",
+    "    def reset(self):\n",
+    "            print(\"Reset Manager 2\")\n",
+    "\n",
+    "class CompareEnv(MetaDriveEnv):\n",
+    "\n",
+    "    def setup_engine(self):\n",
+    "        super(CompareEnv, self).setup_engine()\n",
+    "        self.engine.register_manager(\"mgr_1\", Manager1())\n",
+    "        self.engine.register_manager(\"mgr_2\", Manager2())\n",
+    "\n",
+    "env = CompareEnv(dict(map=\"S\", log_level=50))\n",
+    "try:\n",
+    "    env.reset()\n",
+    "finally:\n",
+    "    env.close()"
    ]
   },
   {
@@ -644,7 +687,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.13"
+   "version": "3.9.17"
   },
   "mystnb": {
    "execution_mode": "auto"
diff --git a/documentation/source/top_down_render.ipynb b/documentation/source/top_down_render.ipynb
index 8232e49c1..280f0ea37 100644
--- a/documentation/source/top_down_render.ipynb
+++ b/documentation/source/top_down_render.ipynb
@@ -3,10 +3,19 @@
   {
    "cell_type": "markdown",
    "id": "8608d8b2",
-   "metadata": {},
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
    "source": [
     "# Top-down Renderer\n",
     "\n",
+    "[![Click and Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/metadriverse/metadrive/blob/main/documentation/source/top_down_render.ipynb)\n",
+    "\n",
+    "\n",
     "2D Top-down renderer is widely used in this documentation for rendering the results, as it is lightweight and can run on any platforms without GPU requirement. If your system has poor support for OpenGL like Apple M1/M2 chips, a good choice is to use top-down renderer. And the simulation results are exactly the same using either 3D renderer or top-down renderer.\n",
     "\n",
     "## Lifetime\n",
@@ -74,10 +83,16 @@
    "cell_type": "code",
    "execution_count": null,
    "id": "a9a890f4",
-   "metadata": {},
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
    "outputs": [],
    "source": [
-    "from metadrive.obs.top_down_renderer import TopDownRenderer\n",
+    "from metadrive.engine.top_down_renderer import TopDownRenderer\n",
     "from metadrive.utils import CONFIG, FUNC_2\n",
     "print_source(TopDownRenderer.__init__, [\"def\", \"# doc-end\"], colorscheme=FUNC_2)"
    ]
@@ -265,7 +280,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.13"
+   "version": "3.9.17"
   },
   "mystnb": {
    "execution_mode": "force"
diff --git a/documentation/source/training.ipynb b/documentation/source/training.ipynb
index 02b3fb010..a8c0aca3f 100644
--- a/documentation/source/training.ipynb
+++ b/documentation/source/training.ipynb
@@ -6,6 +6,9 @@
    "metadata": {},
    "source": [
     "# Training\n",
+    "\n",
+    "[![Click and Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/metadriverse/metadrive/blob/main/documentation/source/training.ipynb)\n",
+    "\n",
     "In this section, we provide examples about how to use common RL frameworks to train autonomous driving policy."
    ]
   },
diff --git a/documentation/source/vehicle.ipynb b/documentation/source/vehicle.ipynb
index ba91d438a..ff0fd26fb 100644
--- a/documentation/source/vehicle.ipynb
+++ b/documentation/source/vehicle.ipynb
@@ -5,7 +5,9 @@
    "id": "a229471a-921a-43dc-ad2e-b7c39ee607d8",
    "metadata": {},
    "source": [
-    "# Vehicle"
+    "# Vehicle\n",
+    "\n",
+    "[![Click and Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/metadriverse/metadrive/blob/main/documentation/source/vehicle.ipynb)\n"
    ]
   }
  ],
@@ -25,7 +27,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.13"
+   "version": "3.9.17"
   }
  },
  "nbformat": 4,
diff --git a/metadrive/component/map/pg_map.py b/metadrive/component/map/pg_map.py
index b01e64357..e6fce04fb 100644
--- a/metadrive/component/map/pg_map.py
+++ b/metadrive/component/map/pg_map.py
@@ -1,4 +1,5 @@
 import copy
+from metadrive.component.algorithm.blocks_prob_dist import PGBlockDistConfig
 from metadrive.type import MetaDriveType
 from metadrive.constants import PGLineType, PGLineColor
 from typing import List
@@ -63,15 +64,15 @@ def _generate(self):
 
     def _big_generate(self, parent_node_path: NodePath, physics_world: PhysicsWorld):
         big_map = BIG(
-            self._config[self.LANE_NUM],
-            self._config[self.LANE_WIDTH],
+            self._config.get(self.LANE_NUM, 2),
+            self._config.get(self.LANE_WIDTH, 3.5),
             self.road_network,
             parent_node_path,
             physics_world,
             # self._config["block_type_version"],
-            exit_length=self._config["exit_length"],
+            exit_length=self._config.get("exit_length", 50),
             random_seed=self.engine.global_random_seed,
-            block_dist_config=self.engine.global_config["block_dist_config"]
+            block_dist_config=self.engine.global_config.get("block_dist_config", PGBlockDistConfig)
         )
         big_map.generate(self._config[self.GENERATE_TYPE], self._config[self.GENERATE_CONFIG])
         self.blocks = big_map.blocks
@@ -81,11 +82,11 @@ def _config_generate(self, blocks_config: List, parent_node_path: NodePath, phys
         assert len(self.road_network.graph) == 0, "These Map is not empty, please create a new map to read config"
         last_block = FirstPGBlock(
             global_network=self.road_network,
-            lane_width=self._config[self.LANE_WIDTH],
-            lane_num=self._config[self.LANE_NUM],
+            lane_width=self._config.get(self.LANE_WIDTH, 3.5),
+            lane_num=self._config.get(self.LANE_NUM, 2),
             render_root_np=parent_node_path,
             physics_world=physics_world,
-            length=self._config["exit_length"],
+            length=self._config.get("exit_length", 50),
             ignore_intersection_checking=True
         )
         self.blocks.append(last_block)
diff --git a/metadrive/engine/base_engine.py b/metadrive/engine/base_engine.py
index 27f697605..0150bf801 100644
--- a/metadrive/engine/base_engine.py
+++ b/metadrive/engine/base_engine.py
@@ -12,7 +12,7 @@
 from metadrive.engine.interface import Interface
 from metadrive.engine.logger import get_logger, reset_logger
 
-from metadrive.pull_asset import pull_asset, wait_asset_lock
+from metadrive.pull_asset import pull_asset
 from metadrive.utils import concat_step_infos
 from metadrive.utils.utils import is_map_related_class
 from metadrive.version import VERSION, asset_version
@@ -309,6 +309,7 @@ def reset(self):
         """
         # reset logger
         reset_logger()
+        step_infos = {}
 
         # initialize
         self._episode_start_time = time.time()
@@ -337,8 +338,8 @@ def process_memory():
         # reset manager
         for manager_name, manager in self._managers.items():
             # clean all manager
-            manager.before_reset()
-
+            new_step_infos = manager.before_reset()
+            step_infos = concat_step_infos([step_infos, new_step_infos])
             if _debug_memory_usage:
                 lm = process_memory()
                 if lm - cm != 0:
@@ -351,7 +352,8 @@ def process_memory():
             if self.replay_episode and self.only_reset_when_replay and manager is not self.replay_manager:
                 # The scene will be generated from replay manager in only reset replay mode
                 continue
-            manager.reset()
+            new_step_infos = manager.reset()
+            step_infos = concat_step_infos([step_infos, new_step_infos])
 
             if _debug_memory_usage:
                 lm = process_memory()
@@ -360,7 +362,8 @@ def process_memory():
                 cm = lm
 
         for manager_name, manager in self.managers.items():
-            manager.after_reset()
+            new_step_infos = manager.after_reset()
+            step_infos = concat_step_infos([step_infos, new_step_infos])
 
             if _debug_memory_usage:
                 lm = process_memory()
@@ -398,6 +401,7 @@ def process_memory():
         # print(len(BaseEngine.COLORS_FREE), len(BaseEngine.COLORS_OCCUPIED))
         self.c_id = new_c2i
         self.id_c = new_i2c
+        return step_infos
 
     def before_step(self, external_actions: Dict[AnyStr, np.array]):
         """
@@ -693,7 +697,7 @@ def agent_to_object(self, agent_name):
 
     def render_topdown(self, text, *args, **kwargs):
         if self.top_down_renderer is None:
-            from metadrive.obs.top_down_renderer import TopDownRenderer
+            from metadrive.engine.top_down_renderer import TopDownRenderer
             self.top_down_renderer = TopDownRenderer(*args, **kwargs)
         return self.top_down_renderer.render(text, *args, **kwargs)
 
diff --git a/metadrive/obs/top_down_renderer.py b/metadrive/engine/top_down_renderer.py
similarity index 99%
rename from metadrive/obs/top_down_renderer.py
rename to metadrive/engine/top_down_renderer.py
index 9c230925f..8e9c047b5 100644
--- a/metadrive/obs/top_down_renderer.py
+++ b/metadrive/engine/top_down_renderer.py
@@ -42,8 +42,12 @@ def draw_top_down_map_native(
     Returns: cv2.image or pygame.Surface
 
     """
-    import cv2
     surface = WorldSurface(film_size, 0, pygame.Surface(film_size))
+    if map is None:
+        surface.move_display_window_to([0, 0])
+        surface.fill([230, 230, 230])
+        return surface if return_surface else WorldSurface.to_cv2_image(surface)
+
     b_box = map.road_network.get_bounding_box()
     x_len = b_box[1] - b_box[0]
     y_len = b_box[3] - b_box[2]
diff --git a/metadrive/envs/base_env.py b/metadrive/envs/base_env.py
index 963937efa..e1a4704cf 100644
--- a/metadrive/envs/base_env.py
+++ b/metadrive/envs/base_env.py
@@ -263,6 +263,9 @@
     only_reset_when_replay=False,
     # If True, when creating and replaying object trajectories, use the same ID as in dataset
     force_reuse_object_name=False,
+
+    # ===== randomization =====
+    num_scenarios=1  # the number of scenarios in this environment
 )
 
 
@@ -310,7 +313,7 @@ def __init__(self, config: dict = None):
 
         # scenarios
         self.start_index = 0
-        self.num_scenarios = 1
+        self.num_scenarios = self.config["num_scenarios"]
 
     def _post_process_config(self, config):
         """Add more special process to merged config"""
@@ -525,7 +528,7 @@ def reset(self, seed: Union[None, int] = None):
                 "env.reset() to rescue this environment. However, a better and safer solution is to check the "
                 "singleton of MetaDrive and restart your program."
             )
-        self.engine.reset()
+        reset_info = self.engine.reset()
         self.reset_sensors()
         # render the scene
         self.engine.taskMgr.step()
@@ -540,7 +543,7 @@ def reset(self, seed: Union[None, int] = None):
         assert (len(self.agents) == self.num_agents) or (self.num_agents == -1), \
             "Agents: {} != Num_agents: {}".format(len(self.agents), self.num_agents)
         assert self.config is self.engine.global_config is get_global_config(), "Inconsistent config may bring errors!"
-        return self._get_reset_return()
+        return self._get_reset_return(reset_info)
 
     def reset_sensors(self):
         """
@@ -563,9 +566,9 @@ def reset_sensors(self):
                     if hasattr(sensor, "track") and name != "main_camera":
                         sensor.track(current_track_agent.origin, [0., 0.8, 1.5], [0, 0.59681, 0])
 
-    def _get_reset_return(self):
+    def _get_reset_return(self, reset_info):
         # TODO: figure out how to get the information of the before step
-        scene_manager_before_step_infos = {}
+        scene_manager_before_step_infos = reset_info
         scene_manager_after_step_infos = self.engine.after_step()
 
         obses = {}
@@ -585,9 +588,17 @@ def _get_reset_return(self):
         step_infos = concat_step_infos([engine_info, done_infos, reward_infos, cost_infos])
 
         if self.is_multi_agent:
-            return (obses, step_infos)
+            return obses, step_infos
         else:
-            return (self._wrap_as_single_agent(obses), self._wrap_as_single_agent(step_infos))
+            return self._wrap_as_single_agent(obses), self._wrap_info_as_single_agent(step_infos)
+
+    def _wrap_info_as_single_agent(self, data):
+        """
+        Wrap to single agent info
+        """
+        agent_info = data.pop(next(iter(self.agents.keys())))
+        data.update(agent_info)
+        return data
 
     def _get_step_return(self, actions, engine_info):
         # update obs, dones, rewards, costs, calculate done at first !
@@ -624,7 +635,7 @@ def _get_step_return(self, actions, engine_info):
         if not self.is_multi_agent:
             return self._wrap_as_single_agent(obses), self._wrap_as_single_agent(rewards), \
                    self._wrap_as_single_agent(terminateds), self._wrap_as_single_agent(
-                truncateds), self._wrap_as_single_agent(step_infos)
+                truncateds), self._wrap_info_as_single_agent(step_infos)
         else:
             return obses, rewards, terminateds, truncateds, step_infos
 
@@ -651,8 +662,11 @@ def for_each_agent(self, func, *args, **kwargs):
         return self.agent_manager.for_each_active_agents(func, *args, **kwargs)
 
     def get_single_observation(self):
+        """
+        Get the observation for one object
+        """
         if self.__class__ is BaseEnv:
-            o = DummyObservation({})
+            o = DummyObservation()
         else:
             if self.config["agent_observation"]:
                 o = self.config["agent_observation"](self.config)
diff --git a/metadrive/envs/legacy_envs/mix_waymo_pg_env.py b/metadrive/envs/legacy_envs/mix_waymo_pg_env.py
index c04e12acf..2aeb122c9 100644
--- a/metadrive/envs/legacy_envs/mix_waymo_pg_env.py
+++ b/metadrive/envs/legacy_envs/mix_waymo_pg_env.py
@@ -151,7 +151,7 @@ def reset(self, seed: Union[None, int] = None):
                 "env.reset() to rescue this environment. However, a better and safer solution is to check the "
                 "singleton of MetaDrive and restart your program."
             )
-        self.engine.reset()
+        reset_info = self.engine.reset()
         if self.top_down_renderer is not None:
             self.top_down_renderer.clear()
         self.engine.top_down_renderer = None
@@ -166,7 +166,7 @@ def reset(self, seed: Union[None, int] = None):
         if not self.is_current_real_data:
             # give a initial speed when on metadrive
             self.agent.set_velocity(self.agent.heading, self.engine.np_random.randint(10))
-        return self._get_reset_return()
+        return self._get_reset_return(reset_info)
 
     def _reset_global_seed(self, force_seed=None):
         current_seed = force_seed if force_seed is not None else get_np_random(None).randint(
diff --git a/metadrive/envs/marl_envs/marl_intersection.py b/metadrive/envs/marl_envs/marl_intersection.py
index 82f1cefb1..9f3ee733d 100644
--- a/metadrive/envs/marl_envs/marl_intersection.py
+++ b/metadrive/envs/marl_envs/marl_intersection.py
@@ -351,7 +351,7 @@ def _long_run():
 
 def show_map_and_traj():
     import matplotlib.pyplot as plt
-    from metadrive.obs.top_down_renderer import draw_top_down_map_native, draw_top_down_trajectory
+    from metadrive.engine.top_down_renderer import draw_top_down_map_native, draw_top_down_trajectory
     import json
     import cv2
     import pygame
diff --git a/metadrive/envs/marl_envs/tinyinter.py b/metadrive/envs/marl_envs/tinyinter.py
index 9746d3084..0f5cb04e6 100644
--- a/metadrive/envs/marl_envs/tinyinter.py
+++ b/metadrive/envs/marl_envs/tinyinter.py
@@ -362,8 +362,8 @@ def default_config() -> Config:
         )
         return MultiAgentIntersectionEnv.default_config().update(tiny_config, allow_add_new_key=True)
 
-    def _get_reset_return(self):
-        org = super(MultiAgentTinyInter, self)._get_reset_return()
+    def _get_reset_return(self, reset_info):
+        org = super(MultiAgentTinyInter, self)._get_reset_return(reset_info)
 
         # if self.num_RL_agents == self.num_agents:
         #     return org
diff --git a/metadrive/envs/metadrive_env.py b/metadrive/envs/metadrive_env.py
index 011141986..8945374b9 100644
--- a/metadrive/envs/metadrive_env.py
+++ b/metadrive/envs/metadrive_env.py
@@ -104,7 +104,7 @@ def __init__(self, config: Union[dict, None] = None):
 
         # scenario setting
         self.start_seed = self.start_index = self.config["start_seed"]
-        self.env_num = self.num_scenarios = self.config["num_scenarios"]
+        self.env_num = self.num_scenarios
 
     def _post_process_config(self, config):
         config = super(MetaDriveEnv, self)._post_process_config(config)
diff --git a/metadrive/scenario/parse_object_state.py b/metadrive/scenario/parse_object_state.py
index af1dffe3e..6675ae03e 100644
--- a/metadrive/scenario/parse_object_state.py
+++ b/metadrive/scenario/parse_object_state.py
@@ -7,6 +7,9 @@
 
 
 def get_max_valid_indicis(track, current_index):
+    """
+    Find the invalid timestep and get the trajectory before that step
+    """
     states = track["state"]
     assert states["valid"][current_index], "Current index should be valid"
     end = len(states["valid"])
@@ -23,6 +26,9 @@ def get_idm_route(traj_points, width=2):
 
 
 def parse_object_state(object_dict, time_idx, check_last_state=False, sim_time_interval=0.1):
+    """
+    Parse object state of one time step
+    """
     states = object_dict["state"]
 
     epi_length = len(states["position"])
@@ -77,6 +83,9 @@ def parse_object_state(object_dict, time_idx, check_last_state=False, sim_time_i
 
 
 def parse_full_trajectory(object_dict):
+    """
+    Parse object states for a whole trajectory
+    """
     positions = object_dict["state"]["position"]
     index = len(positions)
     for current_idx in range(len(positions) - 1):
diff --git a/metadrive/tests/test_env/test_build_city.py b/metadrive/tests/test_env/test_build_city.py
index 0e13cf816..634fc09c3 100644
--- a/metadrive/tests/test_env/test_build_city.py
+++ b/metadrive/tests/test_env/test_build_city.py
@@ -3,7 +3,7 @@
 from metadrive import MetaDriveEnv
 from metadrive.component.map.city_map import CityMap
 from metadrive.engine.engine_utils import initialize_engine, close_engine
-from metadrive.obs.top_down_renderer import draw_top_down_map_native
+from metadrive.engine.top_down_renderer import draw_top_down_map_native
 
 
 def _t(num_blocks):
diff --git a/metadrive/tests/test_env/test_waymo_env.py b/metadrive/tests/test_env/test_waymo_env.py
index b8b2dd455..f95085447 100644
--- a/metadrive/tests/test_env/test_waymo_env.py
+++ b/metadrive/tests/test_env/test_waymo_env.py
@@ -19,6 +19,8 @@ def test_waymo_env(policy, render=False, num_scenarios=3):
                 "no_traffic": True if policy == TrajectoryIDMPolicy else False,
                 "use_render": render,
                 "agent_policy": policy,
+                "show_crosswalk": True,
+                "show_sidewalk": True,
                 "data_directory": AssetLoader.file_path(asset_path, "waymo", unix_style=False),
                 "num_scenarios": num_scenarios
             }
diff --git a/metadrive/tests/vis_env/vis_nuscenes.py b/metadrive/tests/vis_env/vis_nuscenes.py
index 4b86b6eb6..c7a7f67cc 100644
--- a/metadrive/tests/vis_env/vis_nuscenes.py
+++ b/metadrive/tests/vis_env/vis_nuscenes.py
@@ -1,116 +1,110 @@
-import time
-from panda3d.core import PNMImage
-from metadrive.engine.asset_loader import AssetLoader
-from metadrive.envs.scenario_env import ScenarioEnv
-from metadrive.policy.replay_policy import ReplayEgoCarPolicy
-from metadrive.component.sensors.semantic_camera import SemanticCamera
-from metadrive.component.sensors.depth_camera import DepthCamera
-from metadrive.component.sensors.rgb_camera import RGBCamera
-from metadrive.component.sensors.instance_camera import InstanceCamera
-
-NuScenesEnv = ScenarioEnv
+from metadrive.envs import BaseEnv
+from metadrive.obs.observation_base import DummyObservation
+import logging
+
+# ======================================== new content ===============================================
+import cv2
+from metadrive.component.map.pg_map import PGMap
+from metadrive.manager.base_manager import BaseManager
+from metadrive.component.pgblock.first_block import FirstPGBlock
+
+
+class MyMapManager(BaseManager):
+    PRIORITY = 0
+
+    def __init__(self):
+        super(MyMapManager, self).__init__()
+        self.current_map = None
+        self.all_maps = {idx: None for idx in range(3)}  # store the created map
+        self._map_shape = ["X", "T", "O"]  # three types of maps
+
+    def reset(self):
+        idx = self.engine.global_random_seed % 3
+        if self.all_maps[idx] is None:
+            # create maps on the fly
+            new_map = PGMap(map_config=dict(type=PGMap.BLOCK_SEQUENCE, config=self._map_shape[idx]))
+            self.all_maps[idx] = new_map
+
+        # attach map in the world
+        map = self.all_maps[idx]
+        map.attach_to_world()
+        self.current_map = map
+        return dict(current_map=self._map_shape[idx])
+
+    def before_reset(self):
+        if self.current_map is not None:
+            self.current_map.detach_from_world()
+            self.current_map = None
+
+    def destroy(self):
+        # clear all maps when this manager is destroyed
+        super(MyMapManager, self).destroy()
+        for map in self.all_maps.values():
+            if map is not None:
+                map.destroy()
+        self.all_maps = None
+
+
+# Expand the default config system, specify where to spawn the car
+MY_CONFIG = dict(agent_configs={"default_agent": dict(spawn_lane_index=(FirstPGBlock.NODE_1, FirstPGBlock.NODE_2, 0))})
+
+
+class MyEnv(BaseEnv):
+    @classmethod
+    def default_config(cls):
+        config = super(MyEnv, cls).default_config()
+        config.update(MY_CONFIG)
+        return config
+
+    def setup_engine(self):
+        super(MyEnv, self).setup_engine()
+        self.engine.register_manager("map_manager", MyMapManager())
+
+    # ======================================== new content ===============================================
+
+    def reward_function(self, agent):
+        return 0, {}
+
+    def cost_function(self, agent):
+        return 0, {}
+
+    def done_function(self, agent):
+        return False, {}
+
+    def get_single_observation(self):
+        return DummyObservation()
+
 
 if __name__ == "__main__":
-    env = NuScenesEnv(
-        {
-            "use_render": True,
-            "agent_policy": ReplayEgoCarPolicy,
-            "manual_control": True,
-            "show_interface": True,
-            # "debug_static_world": True,
-            # "need_lane_localization": False,
-            # "image_observation": True,
-            "show_logo": False,
-            "no_traffic": False,
-            "store_data": False,
-            "sequential_seed": True,
-            # "pstats": True,
-            # "debug_static_world": True,
-            # "sequential_seed": True,
-            # "reactive_traffic": True,
-            "curriculum_level": 1,
-            "show_fps": True,
-            "show_sidewalk": True,
-            "show_crosswalk": True,
-            # "show_coordinates": True,
-            "sensors": {
-                "semantic": (SemanticCamera, 400, 300),
-                "depth": (DepthCamera, 400, 300),
-                "rgb": (RGBCamera, 400, 300),
-            },
-            # "pstats": True,
-            # "use_mesh_terrain": True,
-            "debug": True,
-            # "no_static_vehicles": False,
-            # "pstats": True,
-            # "render_pipeline": True,
-            # "window_size": (1600, 900),
-            "camera_dist": 9,
-            "interface_panel": ["semantic", "depth", "rgb"],
-            "start_scenario_index": 0,
-            "num_scenarios": 10,
-            # "force_reuse_object_name": True,
-            "horizon": 1000,
-            "vehicle_config": dict(
-                # light=True,
-                # random_color=True,
-                show_navi_mark=False,
-                # no_wheel_friction=True,
-                lidar=dict(num_lasers=120, distance=50),
-                lane_line_detector=dict(num_lasers=0, distance=50),
-                side_detector=dict(num_lasers=12, distance=50)
-            ),
-            "data_directory": AssetLoader.file_path("nuscenes", unix_style=False),
-            # "drivable_area_extension": 0,
-        }
-    )
-
-    # 0,1,3,4,5,6
-
-    success = []
-    reset_num = 0
-    start = time.time()
-    reset_used_time = 0
-    s = 0
-    # while True:
-    # for i in range(10):
-    start_reset = time.time()
-    env.reset(seed=0)
-
-    def reload_shader():
-        env.engine.pbrpipe._recompile_pbr()
-        env.engine.pssm.set_shader_inputs(env.engine.render)
-
-    env.engine.accept("`", reload_shader)
-    env.engine.accept("9", env.engine.terrain.reload_terrain_shader)
-    env.engine.accept("0", env.engine.bufferViewer.toggleEnable)
-
-    reset_used_time += time.time() - start_reset
-    reset_num += 1
-    for t in range(1000000):
-        o, r, tm, tc, info = env.step([1, 0.88])
-        env.engine.terrain.origin.set_shader_input('is_terrain', 1)
-        assert env.observation_space.contains(o)
-        s += 1
-        # if env.config["use_render"]:
-        #     env.render(
-        #         text={
-        #             "seed": env.current_seed,
-        #             "num_map": info["num_stored_maps"],
-        #             "data_coverage": info["data_coverage"],
-        #             "reward": r,
-        #             "heading_r": info["step_reward_heading"],
-        #             "lateral_r": info["step_reward_lateral"],
-        #             "smooth_action_r": info["step_reward_action_smooth"]
-        #         },
-        #         # mode="topdown"
-        #     )
-        # if tm or tc:
-        #     print(
-        #         "Time elapse: {:.4f}. Average FPS: {:.4f}, AVG_Reset_time: {:.4f}".format(
-        #             time.time() - start, s / (time.time() - start - reset_used_time), reset_used_time / reset_num
-        #         )
-        #     )
-        #     print("seed:{}, success".format(env.engine.global_random_seed))
-        #     print(list(env.engine.curriculum_manager.recent_success.dict.values()))
-        #     break
+    frames = []
+
+    # create env
+    env = MyEnv(
+        dict(
+            use_render=False,
+            # if you have a screen and OpenGL suppor, you can set use_render=True to use 3D rendering
+            manual_control=True,  # we usually manually control the car to test environment
+            num_scenarios=4,
+            log_level=logging.CRITICAL
+        )
+    )  # suppress logging message
+    for i in range(4):
+        # reset
+        o, info = env.reset(seed=i)
+        print("Load map with shape: {}".format(info["current_map"]))
+        # you can set window=True and remove generate_gif() if you have a screen.
+        # Or just use 3D rendering and remove all stuff related to env.render()
+        frame = env.render(
+            mode="topdown",
+            window=False,  # turn me on, if you have screen
+            scaling=3,
+            camera_position=(50, 0),
+            screen_size=(400, 400)
+        )
+        frames.append(frame)
+    cv2.imwrite("demo.png", cv2.cvtColor(cv2.hconcat(frames), cv2.COLOR_RGB2BGR))
+    env.close()
+
+from IPython.display import Image
+
+Image(open("demo.png", 'rb').read())
diff --git a/metadrive/utils/__init__.py b/metadrive/utils/__init__.py
index 67c397704..632fd39b3 100644
--- a/metadrive/utils/__init__.py
+++ b/metadrive/utils/__init__.py
@@ -1,13 +1,3 @@
-from inspect import getsource
-from textwrap import dedent
-import pygame
-from PIL import Image
-from pygments import highlight
-from pygments.formatters import TerminalFormatter
-from pygments.lexers import PythonLexer
-from pygments.token import Keyword, Name, Comment, String, Error, \
-    Number, Operator, Generic, Token, Whitespace, Punctuation
-
 from metadrive.utils.config import Config, merge_config_with_unknown_keys, merge_config
 from metadrive.utils.coordinates_shift import panda_heading, panda_vector, metadrive_heading, metadrive_vector
 from metadrive.utils.math import safe_clip, clip, norm, distance_greater, safe_clip_for_small_array, Vector
@@ -15,173 +5,4 @@
 from metadrive.utils.registry import get_metadrive_class
 from metadrive.utils.utils import is_mac, import_pygame, recursive_equal, setup_logger, merge_dicts, \
     concat_step_infos, is_win, time_me
-
-
-def generate_gif(frames, gif_name="demo.gif", is_pygame_surface=False, duration=30):
-    """
-
-    Args:
-        frames: a list of images or pygame surfaces
-        gif_name: name of the file
-        is_pygame_surface: convert pygame surface to PIL.image
-        duration: controlling the duration of each frame, unit: ms
-
-    Returns:
-
-    """
-    assert gif_name.endswith("gif"), "File name should end with .gif"
-    imgs = [pygame.surfarray.array3d(frame) if is_pygame_surface else frame for frame in frames]
-    imgs = [Image.fromarray(img) for img in imgs]
-    imgs[0].save(gif_name, save_all=True, append_images=imgs[1:], duration=duration, loop=0)
-
-
-CONFIG = {
-    Token: ('', ''),
-    Whitespace: ('gray', 'brightblack'),
-    Comment: ('black', 'green'),
-    Keyword: ('blue', 'brightblue'),
-    Keyword.Type: ('cyan', 'brightcyan'),
-    Operator.Word: ('magenta', 'brightmagenta'),
-    Name: ('red', 'brightcyan'),
-    Name.Attribute: ('magenta', 'brightcyan'),
-    Name.Builtin: ('magenta', 'brightcyan'),
-    Name.Builtin.Pseudo: ('magenta', 'brightcyan'),
-    Name.Class: ('cyan', 'brightcyan'),
-    Name.Constant: ('magenta', 'brightcyan'),
-    Name.Decorator: ('magenta', 'brightcyan'),
-    Name.Entity: ('magenta', 'brightcyan'),
-    Name.Exception: ('magenta', 'brightcyan'),
-    Name.Function: ('magenta', 'brightcyan'),
-    Name.Function.Magic: ('magenta', 'brightcyan'),
-    Name.Property: ('magenta', 'brightcyan'),
-    Name.Label: ('magenta', 'brightcyan'),
-    Name.Namespace: ('magenta', 'brightcyan'),
-    Name.Other: ('green', 'brightcyan'),
-    Name.Tag: ('magenta', 'brightcyan'),
-    Name.Variable: ('red', 'brightcyan'),
-    Name.Variable.Class: ('red', 'brightcyan'),
-    Name.Variable.Global: ('red', 'brightcyan'),
-    Name.Variable.Instance: ('red', 'brightcyan'),
-    Name.Variable.Magic: ('red', 'brightcyan'),
-    String: ('yellow', 'yellow'),
-    Number: ('blue', 'blue'),
-    Number.Float: ('green', 'blue'),
-    Punctuation: ('magenta', 'blue'),
-    Generic.Deleted: ('brightred', 'brightred'),
-    Generic.Inserted: ('green', 'brightgreen'),
-    Generic.Heading: ('**', '**'),
-    Generic.Subheading: ('*magenta*', '*brightmagenta*'),
-    Generic.Prompt: ('**', '**'),
-    Generic.Error: ('brightred', 'brightred'),
-    Error: ('_brightred_', '_brightred_'),
-}
-
-FUNC = {
-    Token: ('', ''),
-    Whitespace: ('gray', 'brightblack'),
-    Comment: ('green', 'green'),
-    Keyword: ('blue', 'brightblue'),
-    Keyword.Type: ('cyan', 'brightcyan'),
-    Operator.Word: ('magenta', 'brightmagenta'),
-    Name: ('black', 'brightcyan'),
-    Name.Attribute: ('magenta', 'brightcyan'),
-    Name.Builtin: ('magenta', 'brightcyan'),
-    Name.Builtin.Pseudo: ('magenta', 'brightcyan'),
-    Name.Class: ('cyan', 'brightcyan'),
-    Name.Constant: ('magenta', 'brightcyan'),
-    Name.Decorator: ('magenta', 'brightcyan'),
-    Name.Entity: ('magenta', 'brightcyan'),
-    Name.Exception: ('magenta', 'brightcyan'),
-    Name.Function: ('magenta', 'brightcyan'),
-    Name.Function.Magic: ('magenta', 'brightcyan'),
-    Name.Property: ('magenta', 'brightcyan'),
-    Name.Label: ('magenta', 'brightcyan'),
-    Name.Namespace: ('magenta', 'brightcyan'),
-    Name.Other: ('green', 'brightcyan'),
-    Name.Tag: ('magenta', 'brightcyan'),
-    Name.Variable: ('black', 'brightcyan'),
-    String: ('yellow', 'yellow'),
-    Number: ('blue', 'blue'),
-    Number.Float: ('green', 'blue'),
-    Punctuation: ('magenta', 'blue'),
-    Generic.Deleted: ('brightred', 'brightred'),
-    Generic.Inserted: ('green', 'brightgreen'),
-    Generic.Heading: ('**', '**'),
-    Generic.Subheading: ('*magenta*', '*brightmagenta*'),
-    Generic.Prompt: ('**', '**'),
-    Generic.Error: ('brightred', 'brightred'),
-    Error: ('_brightred_', '_brightred_'),
-}
-
-FUNC_2 = {
-    Token: ('', ''),
-    Whitespace: ('gray', 'brightblack'),
-    Comment: ('black', 'green'),
-    Keyword: ('blue', 'brightblue'),
-    Keyword.Type: ('cyan', 'brightcyan'),
-    Operator.Word: ('magenta', 'brightmagenta'),
-    Name: ('red', 'brightcyan'),
-    Name.Attribute: ('magenta', 'brightcyan'),
-    Name.Builtin: ('magenta', 'brightcyan'),
-    Name.Builtin.Pseudo: ('magenta', 'brightcyan'),
-    Name.Class: ('cyan', 'brightcyan'),
-    Name.Constant: ('magenta', 'brightcyan'),
-    Name.Decorator: ('magenta', 'brightcyan'),
-    Name.Entity: ('magenta', 'brightcyan'),
-    Name.Exception: ('magenta', 'brightcyan'),
-    Name.Function: ('magenta', 'brightcyan'),
-    Name.Function.Magic: ('magenta', 'brightcyan'),
-    Name.Property: ('magenta', 'brightcyan'),
-    Name.Label: ('magenta', 'brightcyan'),
-    Name.Namespace: ('magenta', 'brightcyan'),
-    Name.Other: ('green', 'brightcyan'),
-    Name.Tag: ('magenta', 'brightcyan'),
-    Name.Variable: ('red', 'brightcyan'),
-    Name.Variable.Class: ('red', 'brightcyan'),
-    Name.Variable.Global: ('red', 'brightcyan'),
-    Name.Variable.Instance: ('red', 'brightcyan'),
-    Name.Variable.Magic: ('red', 'brightcyan'),
-    String: ('black', 'black'),
-    Number: ('blue', 'blue'),
-    Number.Float: ('green', 'blue'),
-    Punctuation: ('magenta', 'blue'),
-    Generic.Deleted: ('brightred', 'brightred'),
-    Generic.Inserted: ('green', 'brightgreen'),
-    Generic.Heading: ('**', '**'),
-    Generic.Subheading: ('*magenta*', '*brightmagenta*'),
-    Generic.Prompt: ('**', '**'),
-    Generic.Error: ('brightred', 'brightred'),
-    Error: ('_brightred_', '_brightred_'),
-}
-
-
-def print_source(x, start_end=None, colorscheme=FUNC, **kwargs):
-    """
-    Print the source code of module x
-    Args:
-        colorscheme: color scheme of the output
-        x: python module
-        start_end: a tuple consists of start line content and end line content
-    Returns:
-
-    """
-    code = get_source(x, start_end)
-
-    print(highlight(code, PythonLexer(), TerminalFormatter(colorscheme=colorscheme, **kwargs)))
-
-
-def get_source(x, start_end=None):
-    """
-    Print the source code of module x
-    Args:
-        x: python module
-        start_end: a tuple consists of start line content and end line content
-    Returns:
-
-    """
-    code = getsource(x)
-    if start_end:
-        dict_start = code.find(start_end[0])
-        dict_end = code.find(start_end[1])
-        code = code[dict_start:dict_end + 1]
-    return dedent(code)
+from metadrive.utils.doc_utils import print_source, list_files, get_source, generate_gif, CONFIG, FUNC, FUNC_2
diff --git a/metadrive/utils/doc_utils.py b/metadrive/utils/doc_utils.py
new file mode 100644
index 000000000..aa8e1569c
--- /dev/null
+++ b/metadrive/utils/doc_utils.py
@@ -0,0 +1,194 @@
+from inspect import getsource
+from pathlib import Path
+from textwrap import dedent
+
+import pygame
+from PIL import Image
+from pygments import highlight
+from pygments.formatters import TerminalFormatter
+from pygments.lexers import PythonLexer
+from pygments.token import Keyword, Name, Comment, String, Error, \
+    Number, Operator, Generic, Token, Whitespace, Punctuation
+
+
+def generate_gif(frames, gif_name="demo.gif", is_pygame_surface=False, duration=30):
+    """
+
+    Args:
+        frames: a list of images or pygame surfaces
+        gif_name: name of the file
+        is_pygame_surface: convert pygame surface to PIL.image
+        duration: controlling the duration of each frame, unit: ms
+
+    Returns:
+
+    """
+    assert gif_name.endswith("gif"), "File name should end with .gif"
+    imgs = [pygame.surfarray.array3d(frame) if is_pygame_surface else frame for frame in frames]
+    imgs = [Image.fromarray(img) for img in imgs]
+    imgs[0].save(gif_name, save_all=True, append_images=imgs[1:], duration=duration, loop=0)
+
+
+CONFIG = {
+    Token: ('', ''),
+    Whitespace: ('gray', 'brightblack'),
+    Comment: ('black', 'green'),
+    Keyword: ('blue', 'brightblue'),
+    Keyword.Type: ('cyan', 'brightcyan'),
+    Operator.Word: ('magenta', 'brightmagenta'),
+    Name: ('red', 'brightcyan'),
+    Name.Attribute: ('magenta', 'brightcyan'),
+    Name.Builtin: ('magenta', 'brightcyan'),
+    Name.Builtin.Pseudo: ('magenta', 'brightcyan'),
+    Name.Class: ('cyan', 'brightcyan'),
+    Name.Constant: ('magenta', 'brightcyan'),
+    Name.Decorator: ('magenta', 'brightcyan'),
+    Name.Entity: ('magenta', 'brightcyan'),
+    Name.Exception: ('magenta', 'brightcyan'),
+    Name.Function: ('magenta', 'brightcyan'),
+    Name.Function.Magic: ('magenta', 'brightcyan'),
+    Name.Property: ('magenta', 'brightcyan'),
+    Name.Label: ('magenta', 'brightcyan'),
+    Name.Namespace: ('magenta', 'brightcyan'),
+    Name.Other: ('green', 'brightcyan'),
+    Name.Tag: ('magenta', 'brightcyan'),
+    Name.Variable: ('red', 'brightcyan'),
+    Name.Variable.Class: ('red', 'brightcyan'),
+    Name.Variable.Global: ('red', 'brightcyan'),
+    Name.Variable.Instance: ('red', 'brightcyan'),
+    Name.Variable.Magic: ('red', 'brightcyan'),
+    String: ('yellow', 'yellow'),
+    Number: ('blue', 'blue'),
+    Number.Float: ('green', 'blue'),
+    Punctuation: ('magenta', 'blue'),
+    Generic.Deleted: ('brightred', 'brightred'),
+    Generic.Inserted: ('green', 'brightgreen'),
+    Generic.Heading: ('**', '**'),
+    Generic.Subheading: ('*magenta*', '*brightmagenta*'),
+    Generic.Prompt: ('**', '**'),
+    Generic.Error: ('brightred', 'brightred'),
+    Error: ('_brightred_', '_brightred_'),
+}
+
+FUNC = {
+    Token: ('', ''),
+    Whitespace: ('gray', 'brightblack'),
+    Comment: ('green', 'green'),
+    Keyword: ('blue', 'brightblue'),
+    Keyword.Type: ('cyan', 'brightcyan'),
+    Operator.Word: ('magenta', 'brightmagenta'),
+    Name: ('black', 'brightcyan'),
+    Name.Attribute: ('magenta', 'brightcyan'),
+    Name.Builtin: ('magenta', 'brightcyan'),
+    Name.Builtin.Pseudo: ('magenta', 'brightcyan'),
+    Name.Class: ('cyan', 'brightcyan'),
+    Name.Constant: ('magenta', 'brightcyan'),
+    Name.Decorator: ('magenta', 'brightcyan'),
+    Name.Entity: ('magenta', 'brightcyan'),
+    Name.Exception: ('magenta', 'brightcyan'),
+    Name.Function: ('magenta', 'brightcyan'),
+    Name.Function.Magic: ('magenta', 'brightcyan'),
+    Name.Property: ('magenta', 'brightcyan'),
+    Name.Label: ('magenta', 'brightcyan'),
+    Name.Namespace: ('magenta', 'brightcyan'),
+    Name.Other: ('green', 'brightcyan'),
+    Name.Tag: ('magenta', 'brightcyan'),
+    Name.Variable: ('black', 'brightcyan'),
+    String: ('yellow', 'yellow'),
+    Number: ('blue', 'blue'),
+    Number.Float: ('green', 'blue'),
+    Punctuation: ('magenta', 'blue'),
+    Generic.Deleted: ('brightred', 'brightred'),
+    Generic.Inserted: ('green', 'brightgreen'),
+    Generic.Heading: ('**', '**'),
+    Generic.Subheading: ('*magenta*', '*brightmagenta*'),
+    Generic.Prompt: ('**', '**'),
+    Generic.Error: ('brightred', 'brightred'),
+    Error: ('_brightred_', '_brightred_'),
+}
+
+FUNC_2 = {
+    Token: ('', ''),
+    Whitespace: ('gray', 'brightblack'),
+    Comment: ('black', 'green'),
+    Keyword: ('blue', 'brightblue'),
+    Keyword.Type: ('cyan', 'brightcyan'),
+    Operator.Word: ('magenta', 'brightmagenta'),
+    Name: ('red', 'brightcyan'),
+    Name.Attribute: ('magenta', 'brightcyan'),
+    Name.Builtin: ('magenta', 'brightcyan'),
+    Name.Builtin.Pseudo: ('magenta', 'brightcyan'),
+    Name.Class: ('cyan', 'brightcyan'),
+    Name.Constant: ('magenta', 'brightcyan'),
+    Name.Decorator: ('magenta', 'brightcyan'),
+    Name.Entity: ('magenta', 'brightcyan'),
+    Name.Exception: ('magenta', 'brightcyan'),
+    Name.Function: ('magenta', 'brightcyan'),
+    Name.Function.Magic: ('magenta', 'brightcyan'),
+    Name.Property: ('magenta', 'brightcyan'),
+    Name.Label: ('magenta', 'brightcyan'),
+    Name.Namespace: ('magenta', 'brightcyan'),
+    Name.Other: ('green', 'brightcyan'),
+    Name.Tag: ('magenta', 'brightcyan'),
+    Name.Variable: ('red', 'brightcyan'),
+    Name.Variable.Class: ('red', 'brightcyan'),
+    Name.Variable.Global: ('red', 'brightcyan'),
+    Name.Variable.Instance: ('red', 'brightcyan'),
+    Name.Variable.Magic: ('red', 'brightcyan'),
+    String: ('black', 'black'),
+    Number: ('blue', 'blue'),
+    Number.Float: ('green', 'blue'),
+    Punctuation: ('magenta', 'blue'),
+    Generic.Deleted: ('brightred', 'brightred'),
+    Generic.Inserted: ('green', 'brightgreen'),
+    Generic.Heading: ('**', '**'),
+    Generic.Subheading: ('*magenta*', '*brightmagenta*'),
+    Generic.Prompt: ('**', '**'),
+    Generic.Error: ('brightred', 'brightred'),
+    Error: ('_brightred_', '_brightred_'),
+}
+
+
+def print_source(x, start_end=None, colorscheme=FUNC, **kwargs):
+    """
+    Print the source code of module x
+    Args:
+        colorscheme: color scheme of the output
+        x: python module
+        start_end: a tuple consists of start line content and end line content
+    Returns:
+
+    """
+    code = get_source(x, start_end)
+
+    print(highlight(code, PythonLexer(), TerminalFormatter(colorscheme=colorscheme, **kwargs)))
+
+
+def get_source(x, start_end=None):
+    """
+    Print the source code of module x
+    Args:
+        x: python module
+        start_end: a tuple consists of start line content and end line content
+    Returns:
+
+    """
+    code = getsource(x)
+    if start_end:
+        dict_start = code.find(start_end[0])
+        dict_end = code.find(start_end[1])
+        code = code[dict_start:dict_end + 1]
+    return dedent(code)
+
+
+def list_files(path, prefix='', depth=2, current_depth=0):
+    """
+    List files given a path
+    """
+    path = Path(path)
+    if path.is_dir() and current_depth < depth:
+        print(prefix + path.name + '/')
+        for child in path.iterdir():
+            list_files(child, prefix + '    ', depth, current_depth=current_depth + 1)
+    else:
+        print(prefix + path.name)
diff --git a/metadrive/utils/draw_top_down_map.py b/metadrive/utils/draw_top_down_map.py
index 9280de815..fa4927699 100644
--- a/metadrive/utils/draw_top_down_map.py
+++ b/metadrive/utils/draw_top_down_map.py
@@ -2,7 +2,7 @@
 
 import numpy as np
 import cv2
-from metadrive.obs.top_down_renderer import draw_top_down_map_native as native_draw
+from metadrive.engine.top_down_renderer import draw_top_down_map_native as native_draw
 from metadrive.utils.utils import import_pygame
 
 pygame, gfxdraw = import_pygame()
diff --git a/metadrive/utils/vertex.py b/metadrive/utils/vertex.py
index 280693c98..5a0ec6567 100644
--- a/metadrive/utils/vertex.py
+++ b/metadrive/utils/vertex.py
@@ -63,8 +63,8 @@ def is_anticlockwise(points):
     sum = 0
     n = len(points)
     for i in range(n):
-        x1, y1 = points[i]
-        x2, y2 = points[(i + 1) % n]  # The next point, wrapping around to the first
+        x1, y1 = points[i][:2]
+        x2, y2 = points[(i + 1) % n][:2]  # The next point, wrapping around to the first
         sum += (x2 - x1) * (y2 + y1)
     return sum > 0