diff --git a/src/embed_tests/Python.EmbeddingTest.csproj b/src/embed_tests/Python.EmbeddingTest.csproj
index 2edf4f515..fc887d815 100644
--- a/src/embed_tests/Python.EmbeddingTest.csproj
+++ b/src/embed_tests/Python.EmbeddingTest.csproj
@@ -100,6 +100,7 @@
     <Compile Include="TestNamedArguments.cs" />
     <Compile Include="TestPyWith.cs" />
     <Compile Include="TestRuntime.cs" />
+    <Compile Include="TestPyScope.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\runtime\Python.Runtime.csproj">
diff --git a/src/embed_tests/TestPyScope.cs b/src/embed_tests/TestPyScope.cs
new file mode 100644
index 000000000..49c15a3a1
--- /dev/null
+++ b/src/embed_tests/TestPyScope.cs
@@ -0,0 +1,372 @@
+using System;
+using NUnit.Framework;
+using Python.Runtime;
+
+namespace Python.EmbeddingTest
+{
+    public class PyScopeTest
+    {
+        private PyScope ps;
+
+        [SetUp]
+        public void SetUp()
+        {
+            using (Py.GIL())
+            {
+                ps = Py.CreateScope("test");
+            }                
+        }
+
+        [TearDown]
+        public void Dispose()
+        {
+            using (Py.GIL())
+            {
+                ps.Dispose();
+                ps = null;
+            }
+        }
+
+        /// <summary>
+        /// Eval a Python expression and obtain its return value.
+        /// </summary>
+        [Test]
+        public void TestEval()
+        {
+            using (Py.GIL())
+            {
+                ps.Set("a", 1);
+                var result = ps.Eval<int>("a + 2");
+                Assert.AreEqual(3, result);
+            }                
+        }
+
+        /// <summary>
+        /// Exec Python statements and obtain the variables created.
+        /// </summary>
+        [Test]
+        public void TestExec()
+        {
+            using (Py.GIL())
+            {
+                ps.Set("bb", 100); //declare a global variable
+                ps.Set("cc", 10); //declare a local variable
+                ps.Exec("aa = bb + cc + 3");
+                var result = ps.Get<int>("aa");
+                Assert.AreEqual(113, result);
+            }
+        }
+
+        /// <summary>
+        /// Compile an expression into an ast object;
+        /// Execute the ast and obtain its return value.
+        /// </summary>
+        [Test]
+        public void TestCompileExpression()
+        {
+            using (Py.GIL())
+            {
+                ps.Set("bb", 100); //declare a global variable
+                ps.Set("cc", 10); //declare a local variable
+                PyObject script = PythonEngine.Compile("bb + cc + 3", "", RunFlagType.Eval);
+                var result = ps.Execute<int>(script);
+                Assert.AreEqual(113, result);
+            }
+        }
+
+        /// <summary>
+        /// Compile Python statements into an ast object;
+        /// Execute the ast;
+        /// Obtain the local variables created.
+        /// </summary>
+        [Test]
+        public void TestCompileStatements()
+        {
+            using (Py.GIL())
+            {
+                ps.Set("bb", 100); //declare a global variable
+                ps.Set("cc", 10); //declare a local variable
+                PyObject script = PythonEngine.Compile("aa = bb + cc + 3", "", RunFlagType.File);
+                ps.Execute(script);
+                var result = ps.Get<int>("aa");
+                Assert.AreEqual(113, result);
+            }
+        }
+
+        /// <summary>
+        /// Create a function in the scope, then the function can read variables in the scope.
+        /// It cannot write the variables unless it uses the 'global' keyword.
+        /// </summary>
+        [Test]
+        public void TestScopeFunction()
+        {
+            using (Py.GIL())
+            {
+                ps.Set("bb", 100);
+                ps.Set("cc", 10);
+                ps.Exec(
+                    "def func1():\n" +
+                    "    bb = cc + 10\n");
+                dynamic func1 = ps.Get("func1");
+                func1(); //call the function, it can be called any times
+                var result = ps.Get<int>("bb");
+                Assert.AreEqual(100, result);
+
+                ps.Set("bb", 100);
+                ps.Set("cc", 10);
+                ps.Exec(
+                    "def func2():\n" +
+                    "    global bb\n" +
+                    "    bb = cc + 10\n");
+                dynamic func2 = ps.Get("func2");
+                func2();
+                result = ps.Get<int>("bb");
+                Assert.AreEqual(20, result);
+            }
+        }
+
+        /// <summary>
+        /// Create a class in the scope, the class can read variables in the scope.
+        /// Its methods can write the variables with the help of 'global' keyword.
+        /// </summary>
+        [Test]
+        public void TestScopeClass()
+        {
+            using (Py.GIL())
+            {
+                dynamic _ps = ps;
+                _ps.bb = 100;
+                ps.Exec(
+                    "class Class1():\n" +
+                    "    def __init__(self, value):\n" +
+                    "        self.value = value\n" +
+                    "    def call(self, arg):\n" +
+                    "        return self.value + bb + arg\n" + //use scope variables
+                    "    def update(self, arg):\n" +
+                    "        global bb\n" +
+                    "        bb = self.value + arg\n"  //update scope variable
+                );
+                dynamic obj1 = _ps.Class1(20);
+                var result = obj1.call(10).As<int>();
+                Assert.AreEqual(130, result);
+
+                obj1.update(10);
+                result = ps.Get<int>("bb");
+                Assert.AreEqual(30, result);
+            }
+        }
+
+        /// <summary>
+        /// Import a python module into the session.
+        /// Equivalent to the Python "import" statement.
+        /// </summary>
+        [Test]
+        public void TestImportModule()
+        {
+            using (Py.GIL())
+            {
+                dynamic sys = ps.Import("sys");
+                Assert.IsTrue(ps.Contains("sys"));
+
+                ps.Exec("sys.attr1 = 2");
+                var value1 = ps.Eval<int>("sys.attr1");
+                var value2 = sys.attr1.As<int>();
+                Assert.AreEqual(2, value1);
+                Assert.AreEqual(2, value2);
+
+                //import as
+                ps.Import("sys", "sys1");
+                Assert.IsTrue(ps.Contains("sys1"));
+            }
+        }
+
+        /// <summary>
+        /// Create a scope and import variables from a scope, 
+        /// exec Python statements in the scope then discard it.
+        /// </summary>
+        [Test]
+        public void TestImportScope()
+        {
+            using (Py.GIL())
+            {
+                ps.Set("bb", 100);
+                ps.Set("cc", 10);
+
+                using (var scope = Py.CreateScope())
+                {
+                    scope.Import(ps, "ps");
+                    scope.Exec("aa = ps.bb + ps.cc + 3");
+                    var result = scope.Get<int>("aa");
+                    Assert.AreEqual(113, result);
+                }
+
+                Assert.IsFalse(ps.Contains("aa"));
+            }
+        }
+
+        /// <summary>
+        /// Create a scope and import variables from a scope, 
+        /// exec Python statements in the scope then discard it.
+        /// </summary>
+        [Test]
+        public void TestImportAllFromScope()
+        {
+            using (Py.GIL())
+            {
+                ps.Set("bb", 100);
+                ps.Set("cc", 10);
+
+                using (var scope = ps.NewScope())
+                {
+                    scope.Exec("aa = bb + cc + 3");
+                    var result = scope.Get<int>("aa");
+                    Assert.AreEqual(113, result);
+                }
+
+                Assert.IsFalse(ps.Contains("aa"));
+            }
+        }
+
+        /// <summary>
+        /// Create a scope and import variables from a scope, 
+        /// call the function imported.
+        /// </summary>
+        [Test]
+        public void TestImportScopeFunction()
+        {
+            using (Py.GIL())
+            {
+                ps.Set("bb", 100);
+                ps.Set("cc", 10);
+                ps.Exec(
+                    "def func1():\n" +
+                    "    return cc + bb\n");
+
+                using (PyScope scope = ps.NewScope())
+                {
+                    //'func1' is imported from the origion scope
+                    scope.Exec(
+                        "def func2():\n" +
+                        "    return func1() - cc - bb\n");
+                    dynamic func2 = scope.Get("func2");
+
+                    var result1 = func2().As<int>();
+                    Assert.AreEqual(0, result1);
+
+                    scope.Set("cc", 20);//it has no effect on the globals of 'func1'
+                    var result2 = func2().As<int>();
+                    Assert.AreEqual(-10, result2);
+                    scope.Set("cc", 10); //rollback
+
+                    ps.Set("cc", 20);
+                    var result3 = func2().As<int>();
+                    Assert.AreEqual(10, result3);
+                    ps.Set("cc", 10); //rollback
+                }
+            }
+        }
+
+        /// <summary>
+        /// Import a python module into the session with a new name.
+        /// Equivalent to the Python "import .. as .." statement.
+        /// </summary>
+        [Test]
+        public void TestImportScopeByName()
+        {
+            using (Py.GIL())
+            {
+                ps.Set("bb", 100);
+
+                using (var scope = Py.CreateScope())
+                {
+                    scope.ImportAll("test");
+                    //scope.ImportModule("test");
+
+                    Assert.IsTrue(scope.Contains("bb"));
+                }                    
+            }
+        }
+
+        /// <summary>
+        /// Use the locals() and globals() method just like in python module
+        /// </summary>
+        [Test]
+        public void TestVariables()
+        {
+            (ps.Variables() as dynamic)["ee"] = new PyInt(200);
+            var a0 = ps.Get<int>("ee");
+            Assert.AreEqual(200, a0);
+
+            ps.Exec("locals()['ee'] = 210");
+            var a1 = ps.Get<int>("ee");
+            Assert.AreEqual(210, a1);
+
+            ps.Exec("globals()['ee'] = 220");
+            var a2 = ps.Get<int>("ee");
+            Assert.AreEqual(220, a2);
+
+            using (var item = ps.Variables())
+            {
+                item["ee"] = new PyInt(230);
+            }
+            var a3 = ps.Get<int>("ee");
+            Assert.AreEqual(230, a3);
+        }
+
+        /// <summary>
+        /// Share a pyscope by multiple threads.
+        /// </summary>
+        [Test]
+        public void TestThread()
+        {
+            //After the proposal here https://github.com/pythonnet/pythonnet/pull/419 complished,
+            //the BeginAllowThreads statement blow and the last EndAllowThreads statement
+            //should be removed.
+            dynamic _ps = ps;
+            var ts = PythonEngine.BeginAllowThreads();
+            using (Py.GIL())
+            {
+                _ps.res = 0;
+                _ps.bb = 100;
+                _ps.th_cnt = 0;
+                //add function to the scope 
+                //can be call many times, more efficient than ast 
+                ps.Exec(
+                    "def update():\n" +
+                    "    global res, th_cnt\n" +
+                    "    res += bb + 1\n" +
+                    "    th_cnt += 1\n"
+                );
+            }
+            int th_cnt = 3;
+            for (int i =0; i< th_cnt; i++)
+            {
+                System.Threading.Thread th = new System.Threading.Thread(()=>
+                {
+                    using (Py.GIL())
+                    {
+                        //ps.GetVariable<dynamic>("update")(); //call the scope function dynamicly
+                        _ps.update();
+                    }
+                });
+                th.Start();
+            }
+            //equivalent to Thread.Join, make the main thread join the GIL competition
+            int cnt = 0;
+            while(cnt != th_cnt)
+            {
+                using (Py.GIL())
+                {
+                    cnt = ps.Get<int>("th_cnt");
+                }
+                System.Threading.Thread.Sleep(10);
+            }
+            using (Py.GIL())
+            {
+                var result = ps.Get<int>("res");
+                Assert.AreEqual(101* th_cnt, result);
+            }
+            PythonEngine.EndAllowThreads(ts);
+        }
+    }
+}
diff --git a/src/runtime/Python.Runtime.csproj b/src/runtime/Python.Runtime.csproj
index 2fd66ad73..ee1a3c701 100644
--- a/src/runtime/Python.Runtime.csproj
+++ b/src/runtime/Python.Runtime.csproj
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
@@ -127,6 +127,7 @@
     <Compile Include="pylong.cs" />
     <Compile Include="pynumber.cs" />
     <Compile Include="pyobject.cs" />
+    <Compile Include="pyscope.cs" />
     <Compile Include="pysequence.cs" />
     <Compile Include="pystring.cs" />
     <Compile Include="pythonengine.cs" />
diff --git a/src/runtime/pyobject.cs b/src/runtime/pyobject.cs
index 80704c59e..b7df2a924 100644
--- a/src/runtime/pyobject.cs
+++ b/src/runtime/pyobject.cs
@@ -96,6 +96,27 @@ public object AsManagedObject(Type t)
             }
             return result;
         }
+        
+        /// <summary>
+        /// As Method
+        /// </summary>
+        /// <remarks>
+        /// Return a managed object of the given type, based on the
+        /// value of the Python object.
+        /// </remarks>
+        public T As<T>()
+        {
+            if (typeof(T) == typeof(PyObject) || typeof(T) == typeof(object))
+            {
+                return (T)(this as object);
+            }
+            object result;
+            if (!Converter.ToManaged(obj, typeof(T), out result, false))
+            {
+                throw new InvalidCastException("cannot convert object to target type");
+            }
+            return (T)result;
+        }
 
 
         /// <summary>
diff --git a/src/runtime/pyscope.cs b/src/runtime/pyscope.cs
new file mode 100644
index 000000000..1991772dc
--- /dev/null
+++ b/src/runtime/pyscope.cs
@@ -0,0 +1,655 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Dynamic;
+
+namespace Python.Runtime
+{
+    public class PyScopeException : Exception
+    {
+        public PyScopeException(string message)
+            : base(message)
+        {
+
+        }
+    }
+
+    /// <summary>
+    /// Classes/methods have this attribute must be used with GIL obtained.
+    /// </summary>
+    public class PyGILAttribute : Attribute
+    {
+    }
+
+    [PyGIL]
+    public class PyScope : DynamicObject, IDisposable
+    {
+        public readonly string Name;
+
+        /// <summary>
+        /// the python Module object the scope associated with.
+        /// </summary>
+        internal readonly IntPtr obj;
+
+        /// <summary>
+        /// the variable dict of the scope.
+        /// </summary>
+        internal readonly IntPtr variables;
+
+        private bool _isDisposed;
+
+        /// <summary>
+        /// The Manager this scope associated with.
+        /// It provides scopes this scope can import.
+        /// </summary>
+        internal readonly PyScopeManager Manager;
+
+        /// <summary>
+        /// event which will be triggered after the scope disposed.
+        /// </summary>
+        public event Action<PyScope> OnDispose;
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <remarks>
+        /// Create a scope based on a Python Module.
+        /// </remarks>
+        internal PyScope(IntPtr ptr, PyScopeManager manager)
+        {
+            if (Runtime.PyObject_Type(ptr) != Runtime.PyModuleType)
+            {
+                throw new PyScopeException("object is not a module");
+            }
+            Manager = manager ?? PyScopeManager.Global;
+            obj = ptr;
+            //Refcount of the variables not increase
+            variables = Runtime.PyModule_GetDict(obj);
+            if (variables == IntPtr.Zero)
+            {
+                throw new PythonException();
+            }
+            Runtime.PyDict_SetItemString(
+                variables, "__builtins__",
+                Runtime.PyEval_GetBuiltins()
+            );
+            this.Name = this.Get<string>("__name__");
+        }
+
+        /// <summary>
+        /// return the variable dict of the scope.
+        /// </summary>
+        /// <returns></returns>
+        public PyDict Variables()
+        {
+            Runtime.XIncref(variables);
+            return new PyDict(variables);
+        }
+
+        /// <summary>
+        /// Create a scope, and import all from this scope
+        /// </summary>
+        /// <returns></returns>
+        public PyScope NewScope()
+        {
+            var scope = Manager.Create();
+            scope.ImportAll(this);
+            return scope;
+        }
+
+        /// <summary>
+        /// Import method
+        /// </summary>
+        /// <remarks>
+        /// Import a scope or a module of given name,
+        /// scope will be looked up first.
+        /// </remarks>
+        public dynamic Import(string name, string asname = null)
+        {
+            Check();
+            if (String.IsNullOrEmpty(asname))
+            {
+                asname = name;
+            }
+            PyScope scope;
+            Manager.TryGet(name, out scope);
+            if (scope != null)
+            {
+                Import(scope, asname);
+                return scope;
+            }
+            else
+            {
+                PyObject module = PythonEngine.ImportModule(name);
+                Import(module, asname);
+                return module;
+            }            
+        }
+
+        /// <summary>
+        /// Import method
+        /// </summary>
+        /// <remarks>
+        /// Import a scope as a variable of given name.
+        /// </remarks>
+        public void Import(PyScope scope, string asname)
+        {
+            this.Set(asname, scope.obj);
+        }
+
+        /// <summary>
+        /// Import Method
+        /// </summary>
+        /// <remarks>
+        /// The 'import .. as ..' statement in Python.
+        /// Import a module as a variable into the scope.
+        /// </remarks>
+        public void Import(PyObject module, string asname = null)
+        {
+            if (String.IsNullOrEmpty(asname))
+            {
+                asname = module.GetAttr("__name__").As<string>();
+            }
+            Set(asname, module);
+        }
+
+        /// <summary>
+        /// ImportAll Method
+        /// </summary>
+        /// <remarks>
+        /// The 'import * from ..' statement in Python.
+        /// Import all content of a scope/module of given name into the scope, scope will be looked up first.
+        /// </remarks>
+        public void ImportAll(string name)
+        {
+            PyScope scope;
+            Manager.TryGet(name, out scope);
+            if (scope != null)
+            {
+                ImportAll(scope);
+                return;
+            }
+            else
+            {
+                PyObject module = PythonEngine.ImportModule(name);
+                ImportAll(module);
+            }
+        }
+
+        /// <summary>
+        /// ImportAll Method
+        /// </summary>
+        /// <remarks>
+        /// Import all variables of the scope into this scope.
+        /// </remarks>
+        public void ImportAll(PyScope scope)
+        {
+            int result = Runtime.PyDict_Update(variables, scope.variables);
+            if (result < 0)
+            {
+                throw new PythonException();
+            }
+        }
+
+        /// <summary>
+        /// ImportAll Method
+        /// </summary>
+        /// <remarks>
+        /// Import all variables of the module into this scope.
+        /// </remarks>
+        public void ImportAll(PyObject module)
+        {
+            if (Runtime.PyObject_Type(module.obj) != Runtime.PyModuleType)
+            {
+                throw new PyScopeException("object is not a module");
+            }
+            var module_dict = Runtime.PyModule_GetDict(module.obj);
+            int result = Runtime.PyDict_Update(variables, module_dict);
+            if (result < 0)
+            {
+                throw new PythonException();
+            }
+        }
+
+        /// <summary>
+        /// ImportAll Method
+        /// </summary>
+        /// <remarks>
+        /// Import all variables in the dictionary into this scope.
+        /// </remarks>
+        public void ImportAll(PyDict dict)
+        {
+            int result = Runtime.PyDict_Update(variables, dict.obj);
+            if (result < 0)
+            {
+                throw new PythonException();
+            }
+        }
+
+        /// <summary>
+        /// Execute method
+        /// </summary>
+        /// <remarks>
+        /// Execute a Python ast and return the result as a PyObject.
+        /// The ast can be either an expression or stmts.
+        /// </remarks>
+        public PyObject Execute(PyObject script, PyDict locals = null)
+        {
+            Check();
+            IntPtr _locals = locals == null ? variables : locals.obj;
+            IntPtr ptr = Runtime.PyEval_EvalCode(script.Handle, variables, _locals);
+            Runtime.CheckExceptionOccurred();
+            if (ptr == Runtime.PyNone)
+            {
+                Runtime.XDecref(ptr);
+                return null;
+            }
+            return new PyObject(ptr);
+        }
+
+        /// <summary>
+        /// Execute method
+        /// </summary>
+        /// <remarks>
+        /// Execute a Python ast and return the result as a PyObject,
+        /// and convert the result to a Managed Object of given type.
+        /// The ast can be either an expression or stmts.
+        /// </remarks>
+        public T Execute<T>(PyObject script, PyDict locals = null)
+        {
+            Check();
+            PyObject pyObj = Execute(script, locals);
+            if (pyObj == null)
+            {
+                return default(T);
+            }
+            var obj = pyObj.As<T>();
+            return obj;
+        }
+
+        /// <summary>
+        /// Eval method
+        /// </summary>
+        /// <remarks>
+        /// Evaluate a Python expression and return the result as a PyObject
+        /// or null if an exception is raised.
+        /// </remarks>
+        public PyObject Eval(string code, PyDict locals = null)
+        {
+            Check();
+            IntPtr _locals = locals == null ? variables : locals.obj;
+            var flag = (IntPtr)Runtime.Py_eval_input;
+            IntPtr ptr = Runtime.PyRun_String(
+                code, flag, variables, _locals
+            );
+            Runtime.CheckExceptionOccurred();
+            return new PyObject(ptr);
+        }
+
+        /// <summary>
+        /// Evaluate a Python expression
+        /// </summary>
+        /// <remarks>
+        /// Evaluate a Python expression 
+        /// and  convert the result to a Managed Object of given type.
+        /// </remarks>
+        public T Eval<T>(string code, PyDict locals = null)
+        {
+            Check();
+            PyObject pyObj = Eval(code, locals);
+            var obj = pyObj.As<T>();
+            return obj;
+        }
+
+        /// <summary>
+        /// Exec Method
+        /// </summary>
+        /// <remarks>
+        /// Exec a Python script and save its local variables in the current local variable dict.
+        /// </remarks>
+        public void Exec(string code, PyDict locals = null)
+        {
+            Check();
+            IntPtr _locals = locals == null ? variables : locals.obj;
+            Exec(code, variables, _locals);
+        }
+
+        private void Exec(string code, IntPtr _globals, IntPtr _locals)
+        {
+            var flag = (IntPtr)Runtime.Py_file_input;
+            IntPtr ptr = Runtime.PyRun_String(
+                code, flag, _globals, _locals
+            );
+            Runtime.CheckExceptionOccurred();
+            if (ptr != Runtime.PyNone)
+            {
+                throw new PythonException();
+            }
+            Runtime.XDecref(ptr);
+        }
+
+        /// <summary>
+        /// Set Variable Method
+        /// </summary>
+        /// <remarks>
+        /// Add a new variable to the variables dict if it not exist
+        /// or update its value if the variable exists.
+        /// </remarks>
+        public void Set(string name, object value)
+        {
+            IntPtr _value = Converter.ToPython(value, value?.GetType());
+            Set(name, _value);
+            Runtime.XDecref(_value);
+        }
+
+        private void Set(string name, IntPtr value)
+        {
+            Check();
+            using (var pyKey = new PyString(name))
+            {
+                int r = Runtime.PyObject_SetItem(variables, pyKey.obj, value);
+                if (r < 0)
+                {
+                    throw new PythonException();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Remove Method
+        /// </summary>
+        /// <remarks>
+        /// Remove a variable from the variables dict.
+        /// </remarks>
+        public void Remove(string name)
+        {
+            Check();
+            using (var pyKey = new PyString(name))
+            {
+                int r = Runtime.PyObject_DelItem(variables, pyKey.obj);
+                if (r < 0)
+                {
+                    throw new PythonException();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Contains Method
+        /// </summary>
+        /// <remarks>
+        /// Returns true if the variable exists in the scope.
+        /// </remarks>
+        public bool Contains(string name)
+        {
+            Check();
+            using (var pyKey = new PyString(name))
+            {
+                return Runtime.PyMapping_HasKey(variables, pyKey.obj) != 0;
+            }
+        }
+
+        /// <summary>
+        /// Get Method
+        /// </summary>
+        /// <remarks>
+        /// Returns the value of the variable of given name.
+        /// If the variable does not exist, throw an Exception.
+        /// </remarks>
+        public PyObject Get(string name)
+        {
+            PyObject scope;
+            var state = TryGet(name, out scope);
+            if(!state)
+            {
+                throw new PyScopeException($"The scope of name '{Name}' has no attribute '{name}'");
+            }
+            return scope;
+        }
+
+        /// <summary>
+        /// TryGet Method
+        /// </summary>
+        /// <remarks>
+        /// Returns the value of the variable, local variable first.
+        /// If the variable does not exist, return null.
+        /// </remarks>
+        public bool TryGet(string name, out PyObject value)
+        {
+            Check();
+            using (var pyKey = new PyString(name))
+            {
+                if (Runtime.PyMapping_HasKey(variables, pyKey.obj) != 0)
+                {
+                    IntPtr op = Runtime.PyObject_GetItem(variables, pyKey.obj);
+                    if (op == IntPtr.Zero)
+                    {
+                        throw new PythonException();
+                    }
+                    if (op == Runtime.PyNone)
+                    {
+                        Runtime.XDecref(op);
+                        value = null;
+                        return true;
+                    }
+                    value = new PyObject(op);
+                    return true;
+                }
+                else
+                {
+                    value = null;
+                    return false;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Get Method
+        /// </summary>
+        /// <remarks>
+        /// Obtain the value of the variable of given name, 
+        /// and convert the result to a Managed Object of given type.
+        /// If the variable does not exist, throw an Exception.
+        /// </remarks>
+        public T Get<T>(string name)
+        {
+            Check();
+            PyObject pyObj = Get(name);
+            if (pyObj == null)
+            {
+                return default(T);
+            }
+            return pyObj.As<T>();
+        }
+
+        /// <summary>
+        /// TryGet Method
+        /// </summary>
+        /// <remarks>
+        /// Obtain the value of the variable of given name, 
+        /// and convert the result to a Managed Object of given type.
+        /// If the variable does not exist, return false.
+        /// </remarks>
+        public bool TryGet<T>(string name, out T value)
+        {
+            Check();
+            PyObject pyObj;
+            var result = TryGet(name, out pyObj);
+            if (!result)
+            {
+                value = default(T);
+                return false;
+            }            
+            if (pyObj == null)
+            {
+                if(typeof(T).IsValueType)
+                {
+                    throw new PyScopeException($"The value of the attribute '{name}' is None which cannot be convert to '{typeof(T).ToString()}'");
+                }
+                else
+                {
+                    value = default(T);
+                    return true;
+                }                
+            }
+            value = pyObj.As<T>();
+            return true;
+        }
+
+        public override bool TryGetMember(GetMemberBinder binder, out object result)
+        {
+            result = this.Get(binder.Name);
+            return true;
+        }
+
+        public override bool TrySetMember(SetMemberBinder binder, object value)
+        {
+            this.Set(binder.Name, value);
+            return true;
+        }
+
+        private void Check()
+        {
+            if (_isDisposed)
+            {
+                throw new PyScopeException($"The scope of name '{Name}' object has been disposed");
+            }
+        }
+
+        public void Dispose()
+        {
+            if (_isDisposed)
+            {
+                return;
+            }
+            _isDisposed = true;
+            Runtime.XDecref(obj);
+            this.OnDispose?.Invoke(this);
+        }
+
+        ~PyScope()
+        {
+            Dispose();
+        }
+    }
+
+    public class PyScopeManager
+    {
+        public readonly static PyScopeManager Global = new PyScopeManager();
+
+        private Dictionary<string, PyScope> NamedScopes = new Dictionary<string, PyScope>();
+
+        internal PyScope NewScope(string name)
+        {
+            if (name == null)
+            {
+                name = "";
+            }
+            var module = Runtime.PyModule_New(name);
+            if (module == IntPtr.Zero)
+            {
+                throw new PythonException();
+            }
+            return new PyScope(module, this);
+        }
+
+        /// <summary>
+        /// Create Method
+        /// </summary>
+        /// <remarks>
+        /// Create an anonymous scope.
+        /// </remarks>
+        [PyGIL]
+        public PyScope Create()
+        {
+            var scope = this.NewScope(null);
+            return scope;
+        }
+
+        /// <summary>
+        /// Create Method
+        /// </summary>
+        /// <remarks>
+        /// Create an named scope of given name.
+        /// </remarks>
+        [PyGIL]
+        public PyScope Create(string name)
+        {
+            if (String.IsNullOrEmpty(name))
+            {
+                throw new ArgumentNullException(nameof(name));
+            }
+            if (name != null && Contains(name))
+            {
+                throw new PyScopeException($"A scope of name '{name}' does already exist");
+            }
+            var scope = this.NewScope(name);
+            scope.OnDispose += Remove;
+            NamedScopes[name] = scope;
+            return scope;
+        }
+
+        /// <summary>
+        /// Contains Method
+        /// </summary>
+        /// <remarks>
+        /// return true if the scope exists in this manager.
+        /// </remarks>
+        public bool Contains(string name)
+        {
+            return NamedScopes.ContainsKey(name);
+        }
+
+        /// <summary>
+        /// Get Method
+        /// </summary>
+        /// <remarks>
+        /// Find the scope in this manager.
+        /// If the scope not exist, an Exception will be thrown.
+        /// </remarks>
+        public PyScope Get(string name)
+        {
+            if (String.IsNullOrEmpty(name))
+            {
+                throw new ArgumentNullException(nameof(name));
+            }
+            if (NamedScopes.ContainsKey(name))
+            {
+                return NamedScopes[name];
+            }
+            throw new PyScopeException($"There is no scope named '{name}' registered in this manager");
+        }
+
+        /// <summary>
+        /// Get Method
+        /// </summary>
+        /// <remarks>
+        /// Try to find the scope in this manager.
+        /// </remarks>
+        public bool TryGet(string name, out PyScope scope)
+        {
+            return NamedScopes.TryGetValue(name, out scope);
+        }
+
+        /// <summary>
+        /// Remove Method
+        /// </summary>
+        /// <remarks>
+        /// remove the scope from this manager.
+        /// </remarks>
+        public void Remove(PyScope scope)
+        {
+            NamedScopes.Remove(scope.Name);
+        }
+
+        [PyGIL]
+        public void Clear()
+        {
+            var scopes = NamedScopes.Values.ToList();
+            foreach (var scope in scopes)
+            {
+                scope.Dispose();
+            }
+        }
+    }
+}
diff --git a/src/runtime/pythonengine.cs b/src/runtime/pythonengine.cs
index 9ddd85da6..556da698f 100644
--- a/src/runtime/pythonengine.cs
+++ b/src/runtime/pythonengine.cs
@@ -294,6 +294,7 @@ public static void Shutdown()
         {
             if (initialized)
             {
+                PyScopeManager.Global.Clear();
                 Marshal.FreeHGlobal(_pythonHome);
                 _pythonHome = IntPtr.Zero;
                 Marshal.FreeHGlobal(_programName);
@@ -421,6 +422,13 @@ public static PyObject ModuleFromString(string name, string code)
             return new PyObject(m);
         }
 
+        public static PyObject Compile(string code, string filename = "", RunFlagType mode = RunFlagType.File)
+        {
+            var flag = (IntPtr)mode;
+            IntPtr ptr = Runtime.Py_CompileString(code, filename, flag);
+            Runtime.CheckExceptionOccurred();
+            return new PyObject(ptr);
+        }
 
         /// <summary>
         /// Eval Method
@@ -539,6 +547,18 @@ public static GILState GIL()
             return new GILState();
         }
 
+        public static PyScope CreateScope()
+        {
+            var scope = PyScopeManager.Global.Create();
+            return scope;
+        }
+
+        public static PyScope CreateScope(string name)
+        {
+            var scope = PyScopeManager.Global.Create(name);
+            return scope;
+        }
+        
         public class GILState : IDisposable
         {
             private IntPtr state;
diff --git a/src/runtime/runtime.cs b/src/runtime/runtime.cs
index 9ee693cf3..a24b6f6d4 100644
--- a/src/runtime/runtime.cs
+++ b/src/runtime/runtime.cs
@@ -707,6 +707,9 @@ public static extern int Py_Main(
         [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyRun_String(string code, IntPtr st, IntPtr globals, IntPtr locals);
 
+        [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr PyEval_EvalCode(IntPtr co, IntPtr globals, IntPtr locals);
+
         [DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr Py_CompileString(string code, string file, IntPtr tok);