diff --git a/src/Microsoft.Scripting/HostBridge/BridgeManager.cs b/src/Microsoft.Scripting/HostBridge/BridgeManager.cs
index 801737a..8c54f6a 100644
--- a/src/Microsoft.Scripting/HostBridge/BridgeManager.cs
+++ b/src/Microsoft.Scripting/HostBridge/BridgeManager.cs
@@ -28,7 +28,7 @@ public BridgeManager(JavaScriptEngine engine)
             classBridges_ = new Dictionary<Type, ClassBridge>();
         }
 
-        public ClassBridge GetBridge(Type type)
+        public ClassBridge GetBridge(Type type, TaskFactory taskFactory)
         {
             ClassBridge result;
             if (classBridges_.TryGetValue(type, out result))
@@ -37,7 +37,7 @@ public ClassBridge GetBridge(Type type)
             }
             else
             {
-                result = new ClassBridge(type, this);
+                result = new ClassBridge(type, this, taskFactory);
                 classBridges_.Add(type, result);
             }
 
diff --git a/src/Microsoft.Scripting/HostBridge/ClassBridge.cs b/src/Microsoft.Scripting/HostBridge/ClassBridge.cs
index 17d4433..a0a408e 100644
--- a/src/Microsoft.Scripting/HostBridge/ClassBridge.cs
+++ b/src/Microsoft.Scripting/HostBridge/ClassBridge.cs
@@ -22,7 +22,7 @@ internal class ClassBridge
         private BridgeManager manager_;
         private HostClassMode hostMode_;
 
-        public ClassBridge(Type type, BridgeManager manager)
+        public ClassBridge(Type type, BridgeManager manager, TaskFactory taskFactory)
         {
             Debug.Assert(type != null && manager != null);
             if (type == null)
@@ -54,7 +54,7 @@ public ClassBridge(Type type, BridgeManager manager)
             instanceMethods_ = new List<MethodModel>();
             staticMethods_ = new List<MethodModel>();
 
-            InitializeBridge();
+            InitializeBridge(taskFactory);
         }
 
         internal void AddRef()
@@ -92,7 +92,7 @@ private bool ShouldProjectMember(MemberInfo member)
                          member.GetCustomAttribute<JavaScriptHostMemberAttribute>() != null);
         }
 
-        private void InitializeBridge()
+        private void InitializeBridge(TaskFactory taskFactory)
         {
             ClassBridge baseTypeBridge = null;
             if (typeInfo_.BaseType != null)
@@ -100,7 +100,7 @@ private void InitializeBridge()
                 if (hostMode_ == HostClassMode.FullClass ||
                     (hostMode_ == HostClassMode.OptIn && IsOptedIn(typeInfo_.BaseType)))
                 { 
-                    baseTypeBridge = manager_.GetBridge(typeInfo_.BaseType);
+                    baseTypeBridge = manager_.GetBridge(typeInfo_.BaseType, taskFactory);
                 }
             }
 
@@ -146,12 +146,12 @@ private void InitializeBridge()
             
             foreach (var methodGroup in instanceMethods)
             {
-                BridgeMethod(engine, methodGroup.ToArray(), true, Prototype);
+                BridgeMethod(engine, methodGroup.ToArray(), true, Prototype, taskFactory);
             }
 
             foreach (var methodGroup in staticMethods)
             {
-                BridgeMethod(engine, methodGroup.ToArray(), false, Constructor);
+                BridgeMethod(engine, methodGroup.ToArray(), false, Constructor, taskFactory);
             }
 
             // todo: events
@@ -180,7 +180,7 @@ private void BridgeProperty(JavaScriptEngine engine, PropertyInfo property, bool
             }
         }
 
-        private void BridgeMethod(JavaScriptEngine engine, MethodInfo[] methodGroup, bool isInstance, JavaScriptObject targetObject)
+        private void BridgeMethod(JavaScriptEngine engine, MethodInfo[] methodGroup, bool isInstance, JavaScriptObject targetObject, TaskFactory taskFactory)
         {
             MethodModel methodModel;
             
@@ -192,7 +192,7 @@ private void BridgeMethod(JavaScriptEngine engine, MethodInfo[] methodGroup, boo
                 {
                     // todo: enable async to have names
                     // fn = engine.CreateFunction(methodModel.AsyncEntryPoint, methodModel.FullName, AsyncHostFunctionKind.Promise);
-                    fn = engine.CreateFunction(methodModel.AsyncEntryPoint, AsyncHostFunctionKind.Promise);
+                    fn = engine.CreateFunction(methodModel.AsyncEntryPoint, taskFactory, AsyncHostFunctionKind.Promise);
                 }
                 else
                 {
diff --git a/src/Microsoft.Scripting/JavaScript/JavaScriptConverter.cs b/src/Microsoft.Scripting/JavaScript/JavaScriptConverter.cs
index 35acafa..df93576 100644
--- a/src/Microsoft.Scripting/JavaScript/JavaScriptConverter.cs
+++ b/src/Microsoft.Scripting/JavaScript/JavaScriptConverter.cs
@@ -276,7 +276,7 @@ public JavaScriptValue FromObject(object o)
             }
         }
 
-        public JavaScriptValue FromObjectViaNewBridge(object o)
+        public JavaScriptValue FromObjectViaNewBridge(object o, TaskFactory taskFactory)
         {
             var eng = GetEngine();
             if (o == null)
@@ -329,11 +329,16 @@ public JavaScriptValue FromObjectViaNewBridge(object o)
             }
             else
             {
-                ClassBridge cb = hostBridge_.GetBridge(t);
+                ClassBridge cb = hostBridge_.GetBridge(t, taskFactory);
                 return cb.ProjectObject(o);
             }
         }
 
+        public JavaScriptValue FromObjectViaNewBridge(object o)
+        {
+            return FromObjectViaNewBridge(o, Task.Factory);
+        }
+
         public object ToObject(JavaScriptValue val)
         {
             switch (val.Type)
diff --git a/src/Microsoft.Scripting/JavaScript/JavaScriptEngine.cs b/src/Microsoft.Scripting/JavaScript/JavaScriptEngine.cs
index 2a0c597..e62db9f 100644
--- a/src/Microsoft.Scripting/JavaScript/JavaScriptEngine.cs
+++ b/src/Microsoft.Scripting/JavaScript/JavaScriptEngine.cs
@@ -671,8 +671,8 @@ public JavaScriptFunction CreateFunction(JavaScriptCallableFunction hostFunction
 
             return CreateObjectFromHandle(resultHandle) as JavaScriptFunction;
         }
-
-        public JavaScriptFunction CreateFunction(JavaScriptCallableAsyncFunction hostFunction, AsyncHostFunctionKind functionMarshalingKind = AsyncHostFunctionKind.Promise)
+        
+        public JavaScriptFunction CreateFunction(JavaScriptCallableAsyncFunction hostFunction, TaskFactory taskFactory, AsyncHostFunctionKind functionMarshalingKind = AsyncHostFunctionKind.Promise)
         {
             if (hostFunction == null)
                 throw new ArgumentNullException(nameof(hostFunction));
@@ -708,7 +708,9 @@ public JavaScriptFunction CreateFunction(JavaScriptCallableAsyncFunction hostFun
 
                     var promise = Promise_.Construct(new[] { promiseInit });
 
-                    Task.Run(async () =>
+                    var runner = (taskFactory == Task.Factory ? (Func < Func<Task>, Task> )Task.Run : taskFactory.StartNew);
+
+                    runner(async () =>
                     {
                         JavaScriptValue resultValue = null;
                         bool succeeded = false;
@@ -768,6 +770,11 @@ public JavaScriptFunction CreateFunction(JavaScriptCallableAsyncFunction hostFun
             return CreateObjectFromHandle(resultHandle) as JavaScriptFunction;
         }
 
+        public JavaScriptFunction CreateFunction(JavaScriptCallableAsyncFunction hostFunction, AsyncHostFunctionKind functionMarshalingKind = AsyncHostFunctionKind.Promise)
+        {
+            return CreateFunction(hostFunction, Task.Factory, functionMarshalingKind);
+        }
+
         public JavaScriptFunction CreateFunction(JavaScriptCallableAsyncFunction hostFunction, string name, AsyncHostFunctionKind functionMarshalingKind = AsyncHostFunctionKind.Promise)
         {
             return null;
diff --git a/src/Microsoft.Scripting/Microsoft.Scripting.csproj b/src/Microsoft.Scripting/Microsoft.Scripting.csproj
index 83dc467..87d344c 100644
--- a/src/Microsoft.Scripting/Microsoft.Scripting.csproj
+++ b/src/Microsoft.Scripting/Microsoft.Scripting.csproj
@@ -34,6 +34,7 @@
     <DefineConstants>TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="Errors.cs" />