diff --git a/.gitignore b/.gitignore
index 9de9409..174b65e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,21 +1,143 @@
-/[Ll]ibrary/
-/[Tt]emp/
-/[Oo]bj/
-/[Bb]uild/
+# Unity
 
-# Autogenerated VS/MD solution and project files
-*.csproj
-*.unityproj
-*.sln
-*.suo
-*.tmp
-*.user
-*.userprefs
 *.pidb
-*.booproj
+*.suo
+*.userprefs
+*.vsmdi
+*.testsettings
+*/bin
+*/obj
+*/publish
+$tf
+TestResults
+!*.sln
+!*.csproj
+!*/*.csproj
+[Ll]ibrary/
+[Tt]emp/
+[Oo]bj/
 
-# Unity3D generated meta files
-*.pidb.meta
+# VS2013
 
-# Unity3D Generated File On Crash Reports
-sysinfo.txt
+# Build Folders (you can keep bin if you'd like, to store dlls and pdbs)
+[Bb]in/
+[Oo]bj/
+
+# mstest test results
+TestResults
+
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+
+# User-specific files
+*.suo
+*.user
+*.sln.docstates
+
+# Build results
+[Dd]ebug/
+[Rr]elease/
+x64/
+*_i.c
+*_p.c
+*.ilk
+# *.meta # already ignored in Unity section
+*.obj
+*.pch
+*.pdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.log
+*.vspscc
+*.vssscc
+.builds
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opensdf
+*.sdf
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*
+
+# NCrunch
+*.ncrunch*
+.*crunch*.local.xml
+
+# Installshield output folder 
+[Ee]xpress
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish
+
+# Publish Web Output
+*.Publish.xml
+
+# NuGet Packages Directory
+packages
+
+# Windows Azure Build Output
+csx
+*.build.csdef
+
+# Windows Store app package directory
+AppPackages/
+
+# Others
+[Bb]in
+[Oo]bj
+sql
+TestResults
+[Tt]est[Rr]esult*
+*.Cache
+ClientBin
+[Ss]tyle[Cc]op.*
+~$*
+*.dbmdl
+Generated_Code #added for RIA/Silverlight projects
+
+# Backup & report files from converting an old project file to a newer
+# Visual Studio version. Backup files are not needed, because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+Assets/WSATestCertificate.pfx
+.vs/
+
+Assembly-CSharp\.csproj
+
+UniRx\.Async\.csproj
+
+UniRx\.Async\.Editor\.csproj
+
+UniRx\.Async\.Tests\.csproj
+
+UniTask\.sln
+
+RuntimeUnitTestToolkit\.csproj
diff --git a/Assets/RuntimeUnitTestToolkit.meta b/Assets/RuntimeUnitTestToolkit.meta
new file mode 100644
index 0000000..aa095c6
--- /dev/null
+++ b/Assets/RuntimeUnitTestToolkit.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 894f21dfce4e82343a91661e1ec1a455
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/RuntimeUnitTestToolkit/Editor.meta b/Assets/RuntimeUnitTestToolkit/Editor.meta
new file mode 100644
index 0000000..903f676
--- /dev/null
+++ b/Assets/RuntimeUnitTestToolkit/Editor.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 959c1472a5d812843bedf9341e87af3b
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/RuntimeUnitTestToolkit/Editor/HierarchyTreeBuilder.cs b/Assets/RuntimeUnitTestToolkit/Editor/HierarchyTreeBuilder.cs
new file mode 100644
index 0000000..9a2adc2
--- /dev/null
+++ b/Assets/RuntimeUnitTestToolkit/Editor/HierarchyTreeBuilder.cs
@@ -0,0 +1,133 @@
+#if UNITY_EDITOR
+
+using System;
+using UnityEngine;
+
+namespace RuntimeUnitTestToolkit.Editor
+{
+    // functional declarative construction like flutter.
+
+    internal interface IBuilder
+    {
+        GameObject GameObject { get; }
+        T GetComponent<T>();
+    }
+
+    internal class Builder<T> : IBuilder
+        where T : Component
+    {
+        public T Component1 { get; private set; }
+        public GameObject GameObject { get; private set; }
+
+        public Transform Transform { get { return GameObject.transform; } }
+        public RectTransform RectTransform { get { return GameObject.GetComponent<RectTransform>(); } }
+
+        public Action<GameObject> SetTarget
+        {
+            set
+            {
+                value(this.GameObject);
+            }
+        }
+
+
+        public IBuilder Child
+        {
+            set
+            {
+                value.GameObject.transform.SetParent(GameObject.transform);
+            }
+        }
+
+        public IBuilder[] Children
+        {
+            set
+            {
+                foreach (var item in value)
+                {
+                    item.GameObject.transform.SetParent(GameObject.transform);
+                }
+            }
+        }
+
+        public Builder(string name)
+        {
+            this.GameObject = new GameObject(name);
+            this.Component1 = GameObject.AddComponent<T>();
+        }
+
+        public Builder(string name, out T referenceSelf) // out primary reference.
+        {
+            this.GameObject = new GameObject(name);
+            this.Component1 = GameObject.AddComponent<T>();
+            referenceSelf = this.Component1;
+        }
+
+        public TComponent GetComponent<TComponent>()
+        {
+            return this.GameObject.GetComponent<TComponent>();
+        }
+    }
+
+    internal class Builder<T1, T2> : Builder<T1>
+        where T1 : Component
+        where T2 : Component
+    {
+        public T2 Component2 { get; private set; }
+
+        public Builder(string name)
+            : base(name)
+        {
+            this.Component2 = GameObject.AddComponent<T2>();
+        }
+
+        public Builder(string name, out T1 referenceSelf)
+            : base(name, out referenceSelf)
+        {
+            this.Component2 = GameObject.AddComponent<T2>();
+        }
+    }
+
+    internal class Builder<T1, T2, T3> : Builder<T1, T2>
+        where T1 : Component
+        where T2 : Component
+        where T3 : Component
+    {
+        public T3 Component3 { get; private set; }
+
+        public Builder(string name)
+            : base(name)
+        {
+            this.Component3 = GameObject.AddComponent<T3>();
+        }
+
+        public Builder(string name, out T1 referenceSelf)
+            : base(name, out referenceSelf)
+        {
+            this.Component3 = GameObject.AddComponent<T3>();
+        }
+    }
+
+    internal class Builder<T1, T2, T3, T4> : Builder<T1, T2, T3>
+        where T1 : Component
+        where T2 : Component
+        where T3 : Component
+        where T4 : Component
+    {
+        public T4 Component4 { get; private set; }
+
+        public Builder(string name)
+            : base(name)
+        {
+            this.Component4 = GameObject.AddComponent<T4>();
+        }
+
+        public Builder(string name, out T1 referenceSelf)
+            : base(name, out referenceSelf)
+        {
+            this.Component4 = GameObject.AddComponent<T4>();
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/RuntimeUnitTestToolkit/Editor/HierarchyTreeBuilder.cs.meta b/Assets/RuntimeUnitTestToolkit/Editor/HierarchyTreeBuilder.cs.meta
new file mode 100644
index 0000000..82c8e9b
--- /dev/null
+++ b/Assets/RuntimeUnitTestToolkit/Editor/HierarchyTreeBuilder.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8760bbbab905a534eb6fb7b61b736926
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/RuntimeUnitTestToolkit/Editor/UnitTestBuilder.MenuItems.cs b/Assets/RuntimeUnitTestToolkit/Editor/UnitTestBuilder.MenuItems.cs
new file mode 100644
index 0000000..9ec1c54
--- /dev/null
+++ b/Assets/RuntimeUnitTestToolkit/Editor/UnitTestBuilder.MenuItems.cs
@@ -0,0 +1,341 @@
+#if UNITY_EDITOR
+using UnityEditor;
+
+// Settings MenuItems.
+
+public static partial class UnitTestBuilder
+{
+    [MenuItem("Test/Settings/ScriptBackend/Mono", validate = true, priority = 1)]
+    static bool ValidateScriptBackendMono()
+    {
+        Menu.SetChecked("Test/Settings/ScriptBackend/Mono", LoadOrGetDefaultSettings().ScriptBackend == ScriptingImplementation.Mono2x);
+        return true;
+    }
+
+    [MenuItem("Test/Settings/ScriptBackend/Mono", validate = false, priority = 1)]
+    static void ScriptBackendMono()
+    {
+        var settings = LoadOrGetDefaultSettings();
+        settings.UseCurrentScriptBackend = false;
+        settings.ScriptBackend = ScriptingImplementation.Mono2x;
+        SaveSettings(settings);
+    }
+
+    [MenuItem("Test/Settings/ScriptBackend/IL2CPP", validate = true, priority = 2)]
+    static bool ValidateScriptBackendIL2CPP()
+    {
+        Menu.SetChecked("Test/Settings/ScriptBackend/IL2CPP", LoadOrGetDefaultSettings().ScriptBackend == ScriptingImplementation.IL2CPP);
+        return true;
+    }
+
+    [MenuItem("Test/Settings/ScriptBackend/IL2CPP", validate = false, priority = 2)]
+    static void ScriptBackendIL2CPP()
+    {
+        var settings = LoadOrGetDefaultSettings();
+        settings.UseCurrentScriptBackend = false;
+        settings.ScriptBackend = ScriptingImplementation.IL2CPP;
+        SaveSettings(settings);
+    }
+
+    [MenuItem("Test/Settings/AutoRunPlayer", validate = true, priority = 3)]
+    static bool ValidateAutoRun()
+    {
+        Menu.SetChecked("Test/Settings/AutoRunPlayer", LoadOrGetDefaultSettings().AutoRunPlayer);
+        return true;
+    }
+
+    [MenuItem("Test/Settings/AutoRunPlayer", validate = false, priority = 3)]
+    static void AutoRun()
+    {
+        var settings = LoadOrGetDefaultSettings();
+        settings.AutoRunPlayer = !settings.AutoRunPlayer;
+        SaveSettings(settings);
+    }
+
+    [MenuItem("Test/Settings/Headless", validate = true, priority = 4)]
+    static bool ValidateHeadless()
+    {
+        Menu.SetChecked("Test/Settings/Headless", LoadOrGetDefaultSettings().Headless);
+        return true;
+    }
+
+    [MenuItem("Test/Settings/Headless", validate = false, priority = 4)]
+    static void Headless()
+    {
+        var settings = LoadOrGetDefaultSettings();
+        settings.Headless = !settings.Headless;
+        SaveSettings(settings);
+    }
+
+    [MenuItem("Test/Settings/DisableAutoClose", validate = true, priority = 5)]
+    static bool ValidateDisableAutoClose()
+    {
+        Menu.SetChecked("Test/Settings/DisableAutoClose", LoadOrGetDefaultSettings().DisableAutoClose);
+        return true;
+    }
+
+    [MenuItem("Test/Settings/DisableAutoClose", validate = false, priority = 5)]
+    static void DisableAutoClose()
+    {
+        var settings = LoadOrGetDefaultSettings();
+        settings.DisableAutoClose = !settings.DisableAutoClose;
+        SaveSettings(settings);
+    }
+
+    // generated
+
+    /*
+     * 
+  void Main()
+{
+var sb = new StringBuilder();
+
+var p = 1;
+foreach (var target in Enum.GetNames(typeof(BuildTarget)))
+{
+    var path = $"Test/Settings/BuildTarget/{target}";
+    var priority = p++;
+
+    var template = $@"
+[MenuItem(""{path}"", validate = true, priority = {priority})]
+static bool ValidateBuildTarget{target}()
+{{
+Menu.SetChecked(""{path}"", LoadOrGetDefaultSettings().BuildTarget == BuildTarget.{target});
+return true;
+}}
+
+[MenuItem(""{path}"", validate = false, priority = {priority})]
+static void BuildTarget{target}()
+{{
+var settings = LoadOrGetDefaultSettings();
+settings.UseCurrentBuildTarget = false;
+settings.BuildTarget = BuildTarget.{target};
+SaveSettings(settings);
+}}";
+
+    sb.AppendLine(template);
+}
+
+sb.ToString().Dump();
+}
+
+public enum BuildTarget
+{
+StandaloneWindows,
+StandaloneWindows64,
+StandaloneLinux,
+StandaloneLinux64,
+StandaloneOSX,
+WebGL,
+iOS,
+Android,
+WSAPlayer,
+PS4,
+XboxOne,
+Switch,
+}
+    */
+
+
+    [MenuItem("Test/Settings/BuildTarget/StandaloneWindows", validate = true, priority = 1)]
+    static bool ValidateBuildTargetStandaloneWindows()
+    {
+        Menu.SetChecked("Test/Settings/BuildTarget/StandaloneWindows", LoadOrGetDefaultSettings().BuildTarget == BuildTarget.StandaloneWindows);
+        return true;
+    }
+
+    [MenuItem("Test/Settings/BuildTarget/StandaloneWindows", validate = false, priority = 1)]
+    static void BuildTargetStandaloneWindows()
+    {
+        var settings = LoadOrGetDefaultSettings();
+        settings.UseCurrentBuildTarget = false;
+        settings.BuildTarget = BuildTarget.StandaloneWindows;
+        SaveSettings(settings);
+    }
+
+    [MenuItem("Test/Settings/BuildTarget/StandaloneWindows64", validate = true, priority = 2)]
+    static bool ValidateBuildTargetStandaloneWindows64()
+    {
+        Menu.SetChecked("Test/Settings/BuildTarget/StandaloneWindows64", LoadOrGetDefaultSettings().BuildTarget == BuildTarget.StandaloneWindows64);
+        return true;
+    }
+
+    [MenuItem("Test/Settings/BuildTarget/StandaloneWindows64", validate = false, priority = 2)]
+    static void BuildTargetStandaloneWindows64()
+    {
+        var settings = LoadOrGetDefaultSettings();
+        settings.UseCurrentBuildTarget = false;
+        settings.BuildTarget = BuildTarget.StandaloneWindows64;
+        SaveSettings(settings);
+    }
+
+    [MenuItem("Test/Settings/BuildTarget/StandaloneLinux", validate = true, priority = 3)]
+    static bool ValidateBuildTargetStandaloneLinux()
+    {
+        Menu.SetChecked("Test/Settings/BuildTarget/StandaloneLinux", LoadOrGetDefaultSettings().BuildTarget == BuildTarget.StandaloneLinux);
+        return true;
+    }
+
+    [MenuItem("Test/Settings/BuildTarget/StandaloneLinux", validate = false, priority = 3)]
+    static void BuildTargetStandaloneLinux()
+    {
+        var settings = LoadOrGetDefaultSettings();
+        settings.UseCurrentBuildTarget = false;
+        settings.BuildTarget = BuildTarget.StandaloneLinux;
+        SaveSettings(settings);
+    }
+
+    [MenuItem("Test/Settings/BuildTarget/StandaloneLinux64", validate = true, priority = 4)]
+    static bool ValidateBuildTargetStandaloneLinux64()
+    {
+        Menu.SetChecked("Test/Settings/BuildTarget/StandaloneLinux64", LoadOrGetDefaultSettings().BuildTarget == BuildTarget.StandaloneLinux64);
+        return true;
+    }
+
+    [MenuItem("Test/Settings/BuildTarget/StandaloneLinux64", validate = false, priority = 4)]
+    static void BuildTargetStandaloneLinux64()
+    {
+        var settings = LoadOrGetDefaultSettings();
+        settings.UseCurrentBuildTarget = false;
+        settings.BuildTarget = BuildTarget.StandaloneLinux64;
+        SaveSettings(settings);
+    }
+
+    [MenuItem("Test/Settings/BuildTarget/StandaloneOSX", validate = true, priority = 5)]
+    static bool ValidateBuildTargetStandaloneOSX()
+    {
+        Menu.SetChecked("Test/Settings/BuildTarget/StandaloneOSX", LoadOrGetDefaultSettings().BuildTarget == BuildTarget.StandaloneOSX);
+        return true;
+    }
+
+    [MenuItem("Test/Settings/BuildTarget/StandaloneOSX", validate = false, priority = 5)]
+    static void BuildTargetStandaloneOSX()
+    {
+        var settings = LoadOrGetDefaultSettings();
+        settings.UseCurrentBuildTarget = false;
+        settings.BuildTarget = BuildTarget.StandaloneOSX;
+        SaveSettings(settings);
+    }
+
+    [MenuItem("Test/Settings/BuildTarget/WebGL", validate = true, priority = 6)]
+    static bool ValidateBuildTargetWebGL()
+    {
+        Menu.SetChecked("Test/Settings/BuildTarget/WebGL", LoadOrGetDefaultSettings().BuildTarget == BuildTarget.WebGL);
+        return true;
+    }
+
+    [MenuItem("Test/Settings/BuildTarget/WebGL", validate = false, priority = 6)]
+    static void BuildTargetWebGL()
+    {
+        var settings = LoadOrGetDefaultSettings();
+        settings.UseCurrentBuildTarget = false;
+        settings.BuildTarget = BuildTarget.WebGL;
+        SaveSettings(settings);
+    }
+
+    [MenuItem("Test/Settings/BuildTarget/iOS", validate = true, priority = 7)]
+    static bool ValidateBuildTargetiOS()
+    {
+        Menu.SetChecked("Test/Settings/BuildTarget/iOS", LoadOrGetDefaultSettings().BuildTarget == BuildTarget.iOS);
+        return true;
+    }
+
+    [MenuItem("Test/Settings/BuildTarget/iOS", validate = false, priority = 7)]
+    static void BuildTargetiOS()
+    {
+        var settings = LoadOrGetDefaultSettings();
+        settings.UseCurrentBuildTarget = false;
+        settings.BuildTarget = BuildTarget.iOS;
+        SaveSettings(settings);
+    }
+
+    [MenuItem("Test/Settings/BuildTarget/Android", validate = true, priority = 8)]
+    static bool ValidateBuildTargetAndroid()
+    {
+        Menu.SetChecked("Test/Settings/BuildTarget/Android", LoadOrGetDefaultSettings().BuildTarget == BuildTarget.Android);
+        return true;
+    }
+
+    [MenuItem("Test/Settings/BuildTarget/Android", validate = false, priority = 8)]
+    static void BuildTargetAndroid()
+    {
+        var settings = LoadOrGetDefaultSettings();
+        settings.UseCurrentBuildTarget = false;
+        settings.BuildTarget = BuildTarget.Android;
+        SaveSettings(settings);
+    }
+
+    [MenuItem("Test/Settings/BuildTarget/WSAPlayer", validate = true, priority = 9)]
+    static bool ValidateBuildTargetWSAPlayer()
+    {
+        Menu.SetChecked("Test/Settings/BuildTarget/WSAPlayer", LoadOrGetDefaultSettings().BuildTarget == BuildTarget.WSAPlayer);
+        return true;
+    }
+
+    [MenuItem("Test/Settings/BuildTarget/WSAPlayer", validate = false, priority = 9)]
+    static void BuildTargetWSAPlayer()
+    {
+        var settings = LoadOrGetDefaultSettings();
+        settings.UseCurrentBuildTarget = false;
+        settings.BuildTarget = BuildTarget.WSAPlayer;
+        SaveSettings(settings);
+    }
+
+    [MenuItem("Test/Settings/BuildTarget/PS4", validate = true, priority = 10)]
+    static bool ValidateBuildTargetPS4()
+    {
+        Menu.SetChecked("Test/Settings/BuildTarget/PS4", LoadOrGetDefaultSettings().BuildTarget == BuildTarget.PS4);
+        return true;
+    }
+
+    [MenuItem("Test/Settings/BuildTarget/PS4", validate = false, priority = 10)]
+    static void BuildTargetPS4()
+    {
+        var settings = LoadOrGetDefaultSettings();
+        settings.UseCurrentBuildTarget = false;
+        settings.BuildTarget = BuildTarget.PS4;
+        SaveSettings(settings);
+    }
+
+    [MenuItem("Test/Settings/BuildTarget/XboxOne", validate = true, priority = 11)]
+    static bool ValidateBuildTargetXboxOne()
+    {
+        Menu.SetChecked("Test/Settings/BuildTarget/XboxOne", LoadOrGetDefaultSettings().BuildTarget == BuildTarget.XboxOne);
+        return true;
+    }
+
+    [MenuItem("Test/Settings/BuildTarget/XboxOne", validate = false, priority = 11)]
+    static void BuildTargetXboxOne()
+    {
+        var settings = LoadOrGetDefaultSettings();
+        settings.UseCurrentBuildTarget = false;
+        settings.BuildTarget = BuildTarget.XboxOne;
+        SaveSettings(settings);
+    }
+
+    [MenuItem("Test/Settings/BuildTarget/Switch", validate = true, priority = 12)]
+    static bool ValidateBuildTargetSwitch()
+    {
+        Menu.SetChecked("Test/Settings/BuildTarget/Switch", LoadOrGetDefaultSettings().BuildTarget == BuildTarget.Switch);
+        return true;
+    }
+
+    [MenuItem("Test/Settings/BuildTarget/Switch", validate = false, priority = 12)]
+    static void BuildTargetSwitch()
+    {
+        var settings = LoadOrGetDefaultSettings();
+        settings.UseCurrentBuildTarget = false;
+        settings.BuildTarget = BuildTarget.Switch;
+        SaveSettings(settings);
+    }
+
+
+
+
+
+
+
+
+}
+
+#endif
diff --git a/Assets/RuntimeUnitTestToolkit/Editor/UnitTestBuilder.MenuItems.cs.meta b/Assets/RuntimeUnitTestToolkit/Editor/UnitTestBuilder.MenuItems.cs.meta
new file mode 100644
index 0000000..7c99172
--- /dev/null
+++ b/Assets/RuntimeUnitTestToolkit/Editor/UnitTestBuilder.MenuItems.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 12bdad0556e999f4aa82da29415d361f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/RuntimeUnitTestToolkit/Editor/UnitTestBuilder.cs b/Assets/RuntimeUnitTestToolkit/Editor/UnitTestBuilder.cs
new file mode 100644
index 0000000..8ca1068
--- /dev/null
+++ b/Assets/RuntimeUnitTestToolkit/Editor/UnitTestBuilder.cs
@@ -0,0 +1,515 @@
+#if UNITY_EDITOR
+
+using RuntimeUnitTestToolkit;
+using RuntimeUnitTestToolkit.Editor;
+using System;
+using UnityEditor;
+using UnityEditor.Build.Reporting;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.SceneManagement;
+using UnityEngine.UI;
+
+internal class RuntimeUnitTestSettings
+{
+    public ScriptingImplementation ScriptBackend;
+    public bool UseCurrentScriptBackend;
+    public BuildTarget BuildTarget;
+    public bool UseCurrentBuildTarget;
+
+    public bool Headless;
+    public bool AutoRunPlayer;
+    public bool DisableAutoClose;
+
+    public RuntimeUnitTestSettings()
+    {
+        UseCurrentBuildTarget = true;
+        UseCurrentScriptBackend = true;
+        Headless = false;
+        AutoRunPlayer = true;
+        DisableAutoClose = false;
+    }
+
+    public override string ToString()
+    {
+        return $"{ScriptBackend} {BuildTarget} Headless:{Headless} AutoRunPlayer:{AutoRunPlayer} DisableAutoClose:{DisableAutoClose}";
+    }
+}
+
+// no namespace(because invoke from commandline)
+public static partial class UnitTestBuilder
+{
+    const string SettingsKeyBase = "RuntimeUnitTest.Settings.";
+
+    [MenuItem("Test/BuildUnitTest")]
+    public static void BuildUnitTest()
+    {
+        var settings = new RuntimeUnitTestSettings(); // default
+
+        string buildPath = null;
+
+        if (Application.isBatchMode) // from commandline
+        {
+            settings.AutoRunPlayer = false;
+            settings.DisableAutoClose = false;
+
+            var cmdArgs = Environment.GetCommandLineArgs();
+            for (int i = 0; i < cmdArgs.Length; i++)
+            {
+                if (string.Equals(cmdArgs[i].Trim('-', '/'), "ScriptBackend", StringComparison.OrdinalIgnoreCase))
+                {
+                    settings.UseCurrentScriptBackend = false;
+                    var str = cmdArgs[++i];
+                    if (str.StartsWith("mono", StringComparison.OrdinalIgnoreCase))
+                    {
+                        settings.ScriptBackend = ScriptingImplementation.Mono2x;
+                    }
+                    else if (str.StartsWith("IL2CPP", StringComparison.OrdinalIgnoreCase))
+                    {
+                        settings.ScriptBackend = ScriptingImplementation.IL2CPP;
+                    }
+                    else
+                    {
+                        settings.ScriptBackend = (ScriptingImplementation)Enum.Parse(typeof(ScriptingImplementation), str, true);
+                    }
+                }
+                else if (string.Equals(cmdArgs[i].Trim('-', '/'), "BuildTarget", StringComparison.OrdinalIgnoreCase))
+                {
+                    settings.UseCurrentBuildTarget = false;
+                    settings.BuildTarget = (BuildTarget)Enum.Parse(typeof(BuildTarget), cmdArgs[++i], true);
+                }
+                else if (string.Equals(cmdArgs[i].Trim('-', '/'), "Headless", StringComparison.OrdinalIgnoreCase))
+                {
+                    settings.Headless = true;
+                }
+                else if (string.Equals(cmdArgs[i].Trim('-', '/'), "buildPath", StringComparison.OrdinalIgnoreCase))
+                {
+                    buildPath = cmdArgs[++i];
+                }
+            }
+        }
+        else
+        {
+            var key = SettingsKeyBase + Application.productName;
+            var settingsValue = EditorPrefs.GetString(key, null);
+            try
+            {
+                if (!string.IsNullOrWhiteSpace(settingsValue))
+                {
+                    settings = JsonUtility.FromJson<RuntimeUnitTestSettings>(settingsValue);
+                }
+            }
+            catch
+            {
+                UnityEngine.Debug.LogError("Fail to load RuntimeUnitTest settings");
+                EditorPrefs.SetString(key, null);
+            }
+        }
+
+        if (settings.UseCurrentBuildTarget)
+        {
+            settings.BuildTarget = EditorUserBuildSettings.activeBuildTarget;
+        }
+        if (settings.UseCurrentScriptBackend)
+        {
+            settings.ScriptBackend = PlayerSettings.GetScriptingBackend(ToBuildTargetGroup(settings.BuildTarget));
+        }
+
+        if (buildPath == null)
+        {
+            buildPath = $"bin/UnitTest/{settings.BuildTarget}_{settings.ScriptBackend}/test" + (IsWindows(settings.BuildTarget) ? ".exe" : "");
+        }
+
+        var originalScene = SceneManager.GetActiveScene().path;
+
+        BuildUnitTest(buildPath, settings.ScriptBackend, settings.BuildTarget, settings.Headless, settings.AutoRunPlayer, settings.DisableAutoClose);
+
+        // reopen original scene
+        if (!string.IsNullOrWhiteSpace(originalScene))
+        {
+            EditorSceneManager.OpenScene(originalScene, OpenSceneMode.Single);
+        }
+        else
+        {
+            EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects);
+        }
+    }
+
+    static RuntimeUnitTestSettings LoadOrGetDefaultSettings()
+    {
+        var key = SettingsKeyBase + Application.productName;
+
+        var settingsValue = EditorPrefs.GetString(key, null);
+        RuntimeUnitTestSettings settings = null;
+        try
+        {
+            if (!string.IsNullOrWhiteSpace(settingsValue))
+            {
+                settings = JsonUtility.FromJson<RuntimeUnitTestSettings>(settingsValue);
+            }
+        }
+        catch
+        {
+            UnityEngine.Debug.LogError("Fail to load RuntimeUnitTest settings");
+            EditorPrefs.SetString(key, null);
+            settings = null;
+        }
+
+        if (settings == null)
+        {
+            // default
+            settings = new RuntimeUnitTestSettings
+            {
+                UseCurrentBuildTarget = true,
+                UseCurrentScriptBackend = true,
+                Headless = false,
+                AutoRunPlayer = true,
+            };
+        }
+
+        return settings;
+    }
+
+    static void SaveSettings(RuntimeUnitTestSettings settings)
+    {
+        var key = SettingsKeyBase + Application.productName;
+        EditorPrefs.SetString(key, JsonUtility.ToJson(settings));
+    }
+
+    public static void BuildUnitTest(string buildPath, ScriptingImplementation scriptBackend, BuildTarget buildTarget, bool headless, bool autoRunPlayer, bool disableAutoClose)
+    {
+        var sceneName = "Assets/TempRuntimeUnitTestScene_" + DateTimeOffset.UtcNow.ToUnixTimeSeconds();
+        if (disableAutoClose)
+        {
+            sceneName += "_DisableAutoClose";
+        }
+        sceneName += ".unity";
+
+        var scene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
+
+        BuildUnitTestRunnerScene();
+
+        EditorSceneManager.MarkSceneDirty(scene);
+        AssetDatabase.SaveAssets();
+        EditorSceneManager.SaveScene(scene, sceneName, false);
+        try
+        {
+            Build(sceneName, buildPath, new RuntimeUnitTestSettings { ScriptBackend = scriptBackend, BuildTarget = buildTarget, Headless = headless, AutoRunPlayer = autoRunPlayer, DisableAutoClose = disableAutoClose });
+        }
+        finally
+        {
+            AssetDatabase.DeleteAsset(sceneName);
+        }
+    }
+
+    public static UnitTestRunner BuildUnitTestRunnerScene()
+    {
+        const string kStandardSpritePath = "UI/Skin/UISprite.psd";
+        const string kBackgroundSpritePath = "UI/Skin/Background.psd";
+        var uisprite = AssetDatabase.GetBuiltinExtraResource<Sprite>(kStandardSpritePath);
+        var background = AssetDatabase.GetBuiltinExtraResource<Sprite>(kBackgroundSpritePath);
+
+        ScrollRect buttonList;
+        VerticalLayoutGroup listLayout;
+        Scrollbar refListScrollbar;
+        ScrollRect logList;
+        Scrollbar refLogScrollbar;
+        Button clearButton;
+        Text logText;
+
+        // Flutter like coded build utility
+
+        var rootObject = new Builder<Camera>("SceneRoot")
+        {
+            Children = new IBuilder[] {
+                    new Builder<EventSystem, StandaloneInputModule>("EventSystem"),
+                    new Builder<Canvas, CanvasScaler, GraphicRaycaster>("Canvas") {
+                        Component1 = { renderMode = RenderMode.ScreenSpaceOverlay },
+                        Children = new IBuilder[] {
+                            new Builder<HorizontalLayoutGroup, CanvasRenderer>("HorizontalSplitter") {
+                                RectTransform = { anchorMin = new Vector2(0, 0), anchorMax = new Vector2(1, 1) },
+                                Component1 = { childControlWidth = true, childControlHeight = true, spacing = 10 },
+                                Children = new IBuilder[] {
+                                    new Builder<ScrollRect, CanvasRenderer>("ButtonList", out buttonList) {
+                                        RectTransform = { pivot = new Vector2(0.5f, 0.5f) },
+                                        Component1 = { horizontal =false, vertical = true, movementType = ScrollRect.MovementType.Clamped },
+                                        Children = new IBuilder[] {
+                                            new Builder<VerticalLayoutGroup, ContentSizeFitter>("ListLayoutToAttach", out listLayout) {
+                                                RectTransform = { anchorMin = new Vector2(0, 0), anchorMax = new Vector2(1, 1), pivot = new Vector2(0, 1) },
+                                                Component1  = { childControlWidth = true, childControlHeight = true, childForceExpandWidth = true, childForceExpandHeight = false, spacing = 10, padding = new RectOffset(10,20,10,10) },
+                                                Component2 = { horizontalFit = ContentSizeFitter.FitMode.Unconstrained, verticalFit = ContentSizeFitter.FitMode.PreferredSize },
+                                                SetTarget = self => { buttonList.content = self.GetComponent<RectTransform>();  },
+                                                Child = new Builder<Button, Image, LayoutElement>("ClearButton", out clearButton) {
+                                                    Component2 = { sprite = uisprite, type = Image.Type.Sliced },
+                                                    Component3 = { minHeight = 50 },
+                                                    SetTarget = self => { self.GetComponent<Button>().targetGraphic = self.GetComponent<Graphic>(); },
+                                                    Child = new Builder<Text>("ButtonText") {
+                                                        RectTransform = { anchorMin = new Vector2(0, 0), anchorMax = new Vector2(1, 1), pivot = new Vector2(0.5f, 0.5f) },
+                                                        Component1 = { text = "Clear", color = FromRGB(50, 50, 50), alignment = TextAnchor.MiddleCenter, fontSize = 24, lineSpacing = 1 }
+                                                    }
+                                                }
+                                            },
+                                            new Builder<Scrollbar,Image>("ListScrollbar", out refListScrollbar) {
+                                                RectTransform = { anchorMin = new Vector2(1, 0), anchorMax = new Vector2(1, 1) },
+                                                Component1 = { navigation = new Navigation{ mode = Navigation.Mode.None }, direction = Scrollbar.Direction.BottomToTop, size = 1.0f },
+                                                Component2 = { sprite = background, type = Image.Type.Sliced },
+                                                SetTarget = self => { buttonList.verticalScrollbar = self.GetComponent<Scrollbar>(); },
+                                                Child = new Builder<RectTransform>("Sliding Area") {
+                                                    RectTransform = { anchorMin = new Vector2(0, 0), anchorMax = new Vector2(1, 1) },
+                                                    Child = new Builder<Image>("Handle") {
+                                                        Component1 = { sprite = uisprite, type = Image.Type.Sliced },
+                                                        SetTarget = self =>
+                                                        {
+                                                            refListScrollbar.targetGraphic = self.GetComponent<Graphic>();
+                                                            refListScrollbar.handleRect = self.GetComponent<RectTransform>();
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    },
+                                    new Builder<ScrollRect, CanvasRenderer>("ScrollableText", out logList) {
+                                        RectTransform = { pivot = new Vector2(0.5f, 0.5f) },
+                                        Component1 = { horizontal =false, vertical = true, movementType = ScrollRect.MovementType.Elastic, elasticity = 0.1f },
+                                        Children = new IBuilder[] {
+                                            new Builder<Text, ContentSizeFitter>("Log", out logText) {
+                                                RectTransform = { anchorMin = new Vector2(0, 0), anchorMax = new Vector2(1, 1), pivot = new Vector2(0, 1) },
+                                                Component1  = { fontSize = 24, lineSpacing = 1, supportRichText = true, alignment = TextAnchor.UpperLeft, horizontalOverflow = HorizontalWrapMode.Wrap, verticalOverflow = VerticalWrapMode.Truncate  },
+                                                Component2 = { horizontalFit = ContentSizeFitter.FitMode.Unconstrained, verticalFit = ContentSizeFitter.FitMode.PreferredSize },
+                                                SetTarget = self => { logList.content = self.GetComponent<RectTransform>(); }
+                                            },
+                                            new Builder<Scrollbar,Image>("LogScrollbar", out refLogScrollbar) {
+                                                RectTransform = { anchorMin = new Vector2(1, 0), anchorMax = new Vector2(1, 1) },
+                                                Component1 = { navigation = new Navigation{ mode = Navigation.Mode.None }, direction = Scrollbar.Direction.BottomToTop, size = 1.0f },
+                                                Component2 = { sprite = background, type = Image.Type.Sliced },
+                                                SetTarget = self => { logList.verticalScrollbar = self.GetComponent<Scrollbar>(); },
+                                                Child = new Builder<RectTransform>("Sliding Area2") {
+                                                    RectTransform = { anchorMin = new Vector2(0, 0), anchorMax = new Vector2(1, 1) },
+                                                    Child = new Builder<Image>("Handle2") {
+                                                        Component1 = { sprite = uisprite, type = Image.Type.Sliced },
+                                                        SetTarget = self =>
+                                                        {
+                                                            refLogScrollbar.targetGraphic = self.GetComponent<Graphic>();
+                                                            refLogScrollbar.handleRect = self.GetComponent<RectTransform>();
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    },
+                                }
+                            }
+                        }
+                    }
+                }
+        };
+
+        // size modify after build complete:)
+        {
+            var rect = GameObject.Find("HorizontalSplitter").GetComponent<RectTransform>();
+            rect.offsetMin = new Vector2(0, 0);
+            rect.offsetMax = new Vector2(0, 0);
+        }
+        {
+            var rect = GameObject.Find("ListLayoutToAttach").GetComponent<RectTransform>();
+            rect.offsetMin = new Vector2(0, 0);
+            rect.offsetMax = new Vector2(0, 0);
+        }
+        {
+            var rect = GameObject.Find("ListScrollbar").GetComponent<RectTransform>();
+            rect.offsetMin = new Vector2(0, 0);
+            rect.offsetMax = new Vector2(0, 0);
+            rect.sizeDelta = new Vector2(30, 0);
+        }
+        {
+            var rect = GameObject.Find("ClearButton").GetComponent<RectTransform>();
+            rect.offsetMin = new Vector2(0, 0);
+            rect.offsetMax = new Vector2(0, 0);
+        }
+        {
+            var rect = GameObject.Find("Sliding Area").GetComponent<RectTransform>();
+            rect.offsetMin = new Vector2(0, 0);
+            rect.offsetMax = new Vector2(0, 0);
+            rect.sizeDelta = new Vector2(-20, -20);
+        }
+        {
+            var rect = GameObject.Find("Handle").GetComponent<RectTransform>();
+            rect.offsetMin = new Vector2(0, 0);
+            rect.offsetMax = new Vector2(0, 0);
+            rect.sizeDelta = new Vector2(20, 20);
+        }
+        {
+            var rect = GameObject.Find("ButtonText").GetComponent<RectTransform>();
+            rect.offsetMin = new Vector2(0, 0);
+            rect.offsetMax = new Vector2(0, 0);
+        }
+        {
+            var rect = GameObject.Find("Log").GetComponent<RectTransform>();
+            rect.offsetMin = new Vector2(15, 0);
+            rect.offsetMax = new Vector2(-20, 0);
+        }
+        {
+            var rect = GameObject.Find("LogScrollbar").GetComponent<RectTransform>();
+            rect.offsetMin = new Vector2(-30, 0);
+            rect.offsetMax = new Vector2(0, 0);
+            rect.sizeDelta = new Vector2(30, 0);
+        }
+        {
+            var rect = GameObject.Find("Sliding Area2").GetComponent<RectTransform>();
+            rect.offsetMin = new Vector2(0, 0);
+            rect.offsetMax = new Vector2(0, 0);
+            rect.sizeDelta = new Vector2(-20, -20);
+        }
+        {
+            var rect = GameObject.Find("Handle2").GetComponent<RectTransform>();
+            rect.offsetMin = new Vector2(0, 0);
+            rect.offsetMax = new Vector2(0, 0);
+            rect.sizeDelta = new Vector2(20, 20);
+        }
+
+        // add test script
+        var runner = rootObject.GameObject.AddComponent<UnitTestRunner>();
+        runner.clearButton = clearButton;
+        runner.list = listLayout.gameObject.GetComponent<RectTransform>();
+        runner.listScrollBar = refListScrollbar;
+        runner.logText = logText;
+        runner.logScrollBar = refLogScrollbar;
+
+        return runner;
+    }
+
+    static void Build(string sceneName, string buildPath, RuntimeUnitTestSettings settings)
+    {
+        var options = BuildOptions.BuildScriptsOnly | BuildOptions.IncludeTestAssemblies;
+        if (settings.AutoRunPlayer)
+        {
+            options |= BuildOptions.AutoRunPlayer;
+        }
+        if (settings.Headless)
+        {
+            options |= BuildOptions.EnableHeadlessMode;
+        }
+
+        var targetGroup = ToBuildTargetGroup(settings.BuildTarget);
+        var currentBackend = PlayerSettings.GetScriptingBackend(targetGroup);
+        if (currentBackend != settings.ScriptBackend)
+        {
+            UnityEngine.Debug.Log("Modify ScriptBackend to " + settings.ScriptBackend);
+            PlayerSettings.SetScriptingBackend(targetGroup, settings.ScriptBackend);
+        }
+
+        var buildOptions = new BuildPlayerOptions
+        {
+            target = settings.BuildTarget,
+            targetGroup = targetGroup,
+            options = options,
+            scenes = new[] { sceneName },
+            locationPathName = buildPath
+        };
+
+        UnityEngine.Debug.Log("UnitTest Build Start, " + settings.ToString());
+
+        var buildReport = BuildPipeline.BuildPlayer(buildOptions);
+
+        if (currentBackend != settings.ScriptBackend)
+        {
+            UnityEngine.Debug.Log("Restore ScriptBackend to " + currentBackend);
+            PlayerSettings.SetScriptingBackend(targetGroup, currentBackend);
+        }
+
+        if (buildReport.summary.result != BuildResult.Succeeded)
+        {
+            // Note: show error summary?
+            // Debug.LogError(buildReport.SummarizeErrors());
+            UnityEngine.Debug.LogError("UnitTest Build Failed.");
+        }
+        else
+        {
+            UnityEngine.Debug.Log("UnitTest Build Completed, binary located: " + buildOptions.locationPathName);
+        }
+    }
+
+    static Color FromRGB(int r, int g, int b)
+    {
+        return new Color(r / 255f, g / 255f, b / 255f);
+    }
+
+    static bool IsWindows(BuildTarget buildTarget)
+    {
+        switch (buildTarget)
+        {
+            case BuildTarget.StandaloneWindows:
+            case BuildTarget.StandaloneWindows64:
+            case BuildTarget.WSAPlayer:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    static BuildTargetGroup ToBuildTargetGroup(BuildTarget buildTarget)
+    {
+#pragma warning disable CS0618
+        switch (buildTarget)
+        {
+            case BuildTarget.StandaloneOSX:
+            case (BuildTarget)3:
+            case BuildTarget.StandaloneOSXIntel:
+            case BuildTarget.StandaloneOSXIntel64:
+            case BuildTarget.StandaloneWindows:
+            case BuildTarget.StandaloneWindows64:
+            case BuildTarget.StandaloneLinux:
+            case BuildTarget.StandaloneLinux64:
+            case BuildTarget.StandaloneLinuxUniversal:
+                return BuildTargetGroup.Standalone;
+            case (BuildTarget)6:
+            case (BuildTarget)7:
+            case BuildTarget.WebGL:
+                return BuildTargetGroup.WebGL;
+            case BuildTarget.iOS:
+                return BuildTargetGroup.iOS;
+            case BuildTarget.PS3:
+                return BuildTargetGroup.PS3;
+            case BuildTarget.PS4:
+                return BuildTargetGroup.PS4;
+            case BuildTarget.XBOX360:
+                return BuildTargetGroup.XBOX360;
+            case BuildTarget.Android:
+                return BuildTargetGroup.Android;
+            case BuildTarget.WSAPlayer:
+                return BuildTargetGroup.WSA;
+            case BuildTarget.WP8Player:
+                return BuildTargetGroup.WP8;
+            case BuildTarget.Tizen:
+                return BuildTargetGroup.Tizen;
+            case BuildTarget.PSP2:
+                return BuildTargetGroup.PSP2;
+            case BuildTarget.PSM:
+                return BuildTargetGroup.PSM;
+            case BuildTarget.XboxOne:
+                return BuildTargetGroup.XboxOne;
+            case BuildTarget.SamsungTV:
+                return BuildTargetGroup.SamsungTV;
+            case BuildTarget.N3DS:
+                return BuildTargetGroup.N3DS;
+            case BuildTarget.WiiU:
+                return BuildTargetGroup.WiiU;
+            case BuildTarget.tvOS:
+                return BuildTargetGroup.tvOS;
+            case BuildTarget.Switch:
+                return BuildTargetGroup.Switch;
+            case BuildTarget.Lumin:
+                return BuildTargetGroup.Lumin;
+            case BuildTarget.BlackBerry:
+                return BuildTargetGroup.BlackBerry;
+            case BuildTarget.NoTarget:
+            default:
+                return BuildTargetGroup.Unknown;
+        }
+#pragma warning restore CS0618
+
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/RuntimeUnitTestToolkit/Editor/UnitTestBuilder.cs.meta b/Assets/RuntimeUnitTestToolkit/Editor/UnitTestBuilder.cs.meta
new file mode 100644
index 0000000..bf66c58
--- /dev/null
+++ b/Assets/RuntimeUnitTestToolkit/Editor/UnitTestBuilder.cs.meta
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 3518da33b6245d341a0ef3670ee9268b
+timeCreated: 1488689723
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/RuntimeUnitTestToolkit/RuntimeUnitTestToolkit.asmdef b/Assets/RuntimeUnitTestToolkit/RuntimeUnitTestToolkit.asmdef
new file mode 100644
index 0000000..e7d7e8a
--- /dev/null
+++ b/Assets/RuntimeUnitTestToolkit/RuntimeUnitTestToolkit.asmdef
@@ -0,0 +1,16 @@
+{
+    "name": "RuntimeUnitTestToolkit",
+    "references": [
+    ],
+    "optionalUnityReferences": [
+        "TestAssemblies"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": []
+}
\ No newline at end of file
diff --git a/Assets/RuntimeUnitTestToolkit/RuntimeUnitTestToolkit.asmdef.meta b/Assets/RuntimeUnitTestToolkit/RuntimeUnitTestToolkit.asmdef.meta
new file mode 100644
index 0000000..5ad198b
--- /dev/null
+++ b/Assets/RuntimeUnitTestToolkit/RuntimeUnitTestToolkit.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 14c4fea4b238088479114ba2ffe195f9
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/RuntimeUnitTestToolkit/UnitTestRunner.cs b/Assets/RuntimeUnitTestToolkit/UnitTestRunner.cs
new file mode 100644
index 0000000..ff7041c
--- /dev/null
+++ b/Assets/RuntimeUnitTestToolkit/UnitTestRunner.cs
@@ -0,0 +1,450 @@
+using NUnit.Framework;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using UnityEngine;
+using UnityEngine.Events;
+using UnityEngine.TestTools;
+using UnityEngine.UI;
+
+namespace RuntimeUnitTestToolkit
+{
+    public class UnitTestRunner : MonoBehaviour
+    {
+        // object is IEnumerator or Func<IEnumerator>
+        Dictionary<string, List<KeyValuePair<string, object>>> tests = new Dictionary<string, List<KeyValuePair<string, object>>>();
+
+        List<Pair> additionalActionsOnFirst = new List<Pair>();
+
+        public Button clearButton;
+        public RectTransform list;
+        public Scrollbar listScrollBar;
+
+        public Text logText;
+        public Scrollbar logScrollBar;
+
+        readonly Color passColor = new Color(0f, 1f, 0f, 1f); // green
+        readonly Color failColor = new Color(1f, 0f, 0f, 1f); // red
+        readonly Color normalColor = new Color(1f, 1f, 1f, 1f); // white
+
+        bool allTestGreen = true;
+
+        void Start()
+        {
+            try
+            {
+                UnityEngine.Application.logMessageReceived += (a, b, c) =>
+                {
+                    logText.text += "[" + c + "]" + a + "\n";
+                };
+
+                // register all test types
+                foreach (var item in GetTestTargetTypes())
+                {
+                    RegisterAllMethods(item);
+                }
+
+                var executeAll = new List<Func<Coroutine>>();
+                foreach (var ___item in tests)
+                {
+                    var actionList = ___item; // be careful, capture in lambda
+
+                    executeAll.Add(() => StartCoroutine(RunTestInCoroutine(actionList)));
+                    Add(actionList.Key, () => StartCoroutine(RunTestInCoroutine(actionList)));
+                }
+
+                var executeAllButton = Add("Run All Tests", () => StartCoroutine(ExecuteAllInCoroutine(executeAll)));
+
+                clearButton.gameObject.GetComponent<Image>().color = new Color(170 / 255f, 170 / 255f, 170 / 255f, 1);
+                executeAllButton.gameObject.GetComponent<Image>().color = new Color(250 / 255f, 150 / 255f, 150 / 255f, 1);
+                executeAllButton.transform.SetSiblingIndex(1);
+
+                additionalActionsOnFirst.Reverse();
+                foreach (var item in additionalActionsOnFirst)
+                {
+                    var newButton = GameObject.Instantiate(clearButton);
+                    newButton.name = item.Name;
+                    newButton.onClick.RemoveAllListeners();
+                    newButton.GetComponentInChildren<Text>().text = item.Name;
+                    newButton.onClick.AddListener(item.Action);
+                    newButton.transform.SetParent(list);
+                    newButton.transform.SetSiblingIndex(1);
+                }
+
+                clearButton.onClick.AddListener(() =>
+                {
+                    logText.text = "";
+                    foreach (var btn in list.GetComponentsInChildren<Button>())
+                    {
+                        btn.interactable = true;
+                        btn.GetComponent<Image>().color = normalColor;
+                    }
+                    executeAllButton.gameObject.GetComponent<Image>().color = new Color(250 / 255f, 150 / 255f, 150 / 255f, 1);
+                });
+
+                listScrollBar.value = 1;
+                logScrollBar.value = 1;
+
+                if (Application.isBatchMode)
+                {
+                    // run immediately in player
+                    StartCoroutine(ExecuteAllInCoroutine(executeAll));
+                }
+            }
+            catch (Exception ex)
+            {
+                if (Application.isBatchMode)
+                {
+                    // when failed(can not start runner), quit immediately.
+                    WriteToConsole(ex.ToString());
+                    Application.Quit(1);
+                }
+                else
+                {
+                    throw;
+                }
+            }
+        }
+
+        Button Add(string title, UnityAction test)
+        {
+            var newButton = GameObject.Instantiate(clearButton);
+            newButton.name = title;
+            newButton.onClick.RemoveAllListeners();
+            newButton.GetComponentInChildren<Text>().text = title;
+            newButton.onClick.AddListener(test);
+
+            newButton.transform.SetParent(list);
+            return newButton;
+        }
+
+        static IEnumerable<Type> GetTestTargetTypes()
+        {
+            foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                var n = assembly.FullName;
+                if (n.StartsWith("UnityEngine")) continue;
+                if (n.StartsWith("mscorlib")) continue;
+                if (n.StartsWith("System")) continue;
+
+                foreach (var item in assembly.GetTypes())
+                {
+                    foreach (var method in item.GetMethods())
+                    {
+                        var t1 = method.GetCustomAttribute<TestAttribute>(true);
+                        if (t1 != null)
+                        {
+                            yield return item;
+                            break;
+                        }
+                        var t2 = method.GetCustomAttribute<UnityTestAttribute>(true);
+                        if (t2 != null)
+                        {
+                            yield return item;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        public void AddTest(string group, string title, Action test)
+        {
+            List<KeyValuePair<string, object>> list;
+            if (!tests.TryGetValue(group, out list))
+            {
+                list = new List<KeyValuePair<string, object>>();
+                tests[group] = list;
+            }
+
+            list.Add(new KeyValuePair<string, object>(title, test));
+        }
+
+        public void AddAsyncTest(string group, string title, Func<IEnumerator> asyncTestCoroutine)
+        {
+            List<KeyValuePair<string, object>> list;
+            if (!tests.TryGetValue(group, out list))
+            {
+                list = new List<KeyValuePair<string, object>>();
+                tests[group] = list;
+            }
+
+            list.Add(new KeyValuePair<string, object>(title, asyncTestCoroutine));
+        }
+
+        public void AddCutomAction(string name, UnityAction action)
+        {
+            additionalActionsOnFirst.Add(new Pair { Name = name, Action = action });
+        }
+
+
+        public void RegisterAllMethods<T>()
+            where T : new()
+        {
+            RegisterAllMethods(typeof(T));
+        }
+
+        public void RegisterAllMethods(Type testType)
+        {
+            try
+            {
+                var test = Activator.CreateInstance(testType);
+
+                var methods = testType.GetMethods(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public);
+                foreach (var item in methods)
+                {
+                    try
+                    {
+                        var iteratorTest = item.GetCustomAttribute<UnityEngine.TestTools.UnityTestAttribute>(true);
+                        if (iteratorTest != null)
+                        {
+                            if (item.GetParameters().Length == 0 && item.ReturnType == typeof(IEnumerator))
+                            {
+                                var factory = (Func<IEnumerator>)Delegate.CreateDelegate(typeof(Func<IEnumerator>), test, item);
+                                AddAsyncTest(factory.Target.GetType().Name, factory.Method.Name, factory);
+                            }
+                            else
+                            {
+                                UnityEngine.Debug.Log(testType.Name + "." + item.Name + " currently does not supported in RuntumeUnitTestToolkit(multiple parameter or return type is invalid).");
+                            }
+                        }
+
+                        var standardTest = item.GetCustomAttribute<NUnit.Framework.TestAttribute>(true);
+                        if (standardTest != null)
+                        {
+                            if (item.GetParameters().Length == 0 && item.ReturnType == typeof(void))
+                            {
+                                var invoke = (Action)Delegate.CreateDelegate(typeof(Action), test, item);
+                                AddTest(invoke.Target.GetType().Name, invoke.Method.Name, invoke);
+                            }
+                            else
+                            {
+                                UnityEngine.Debug.Log(testType.Name + "." + item.Name + " currently does not supported in RuntumeUnitTestToolkit(multiple parameter or return type is invalid).");
+                            }
+                        }
+                    }
+                    catch (Exception e)
+                    {
+                        UnityEngine.Debug.LogError(testType.Name + "." + item.Name + " failed to register method, exception: " + e.ToString());
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.LogException(ex);
+            }
+        }
+
+        System.Collections.IEnumerator ScrollLogToEndNextFrame()
+        {
+            yield return null;
+            yield return null;
+            logScrollBar.value = 0;
+        }
+
+        IEnumerator RunTestInCoroutine(KeyValuePair<string, List<KeyValuePair<string, object>>> actionList)
+        {
+            Button self = null;
+            foreach (var btn in list.GetComponentsInChildren<Button>())
+            {
+                btn.interactable = false;
+                if (btn.name == actionList.Key) self = btn;
+            }
+            if (self != null)
+            {
+                self.GetComponent<Image>().color = normalColor;
+            }
+
+            var allGreen = true;
+
+            logText.text += "<color=yellow>" + actionList.Key + "</color>\n";
+            WriteToConsole("Begin Test Class: " + actionList.Key);
+            yield return null;
+
+            var totalExecutionTime = new List<double>();
+            foreach (var item2 in actionList.Value)
+            {
+                // before start, cleanup
+                GC.Collect();
+                GC.WaitForPendingFinalizers();
+                GC.Collect();
+
+                logText.text += "<color=teal>" + item2.Key + "</color>\n";
+                yield return null;
+
+                var v = item2.Value;
+
+                var methodStopwatch = System.Diagnostics.Stopwatch.StartNew();
+                Exception exception = null;
+                if (v is Action)
+                {
+                    try
+                    {
+                        ((Action)v).Invoke();
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ex;
+                    }
+                }
+                else
+                {
+                    var coroutineFactory = (Func<IEnumerator>)v;
+                    IEnumerator coroutine = null;
+                    try
+                    {
+                        coroutine = coroutineFactory();
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ex;
+                    }
+                    if (exception == null)
+                    {
+                        yield return StartCoroutine(UnwrapEnumerator(coroutine, ex =>
+                        {
+                            exception = ex;
+                        }));
+                    }
+                }
+
+                methodStopwatch.Stop();
+                totalExecutionTime.Add(methodStopwatch.Elapsed.TotalMilliseconds);
+                if (exception == null)
+                {
+                    logText.text += "OK, " + methodStopwatch.Elapsed.TotalMilliseconds.ToString("0.00") + "ms\n";
+                    WriteToConsoleResult(item2.Key + ", " + methodStopwatch.Elapsed.TotalMilliseconds.ToString("0.00") + "ms", true);
+                }
+                else
+                {
+                    // found match line...
+                    var line = string.Join("\n", exception.StackTrace.Split('\n').Where(x => x.Contains(actionList.Key) || x.Contains(item2.Key)).ToArray());
+                    logText.text += "<color=red>" + exception.Message + "\n" + line + "</color>\n";
+                    WriteToConsoleResult(item2.Key + ", " + exception.Message, false);
+                    WriteToConsole(line);
+                    allGreen = false;
+                    allTestGreen = false;
+                }
+            }
+
+            logText.text += "[" + actionList.Key + "]" + totalExecutionTime.Sum().ToString("0.00") + "ms\n\n";
+            foreach (var btn in list.GetComponentsInChildren<Button>()) btn.interactable = true;
+            if (self != null)
+            {
+                self.GetComponent<Image>().color = allGreen ? passColor : failColor;
+            }
+
+            yield return StartCoroutine(ScrollLogToEndNextFrame());
+
+
+        }
+
+        IEnumerator ExecuteAllInCoroutine(List<Func<Coroutine>> tests)
+        {
+            allTestGreen = true;
+
+            foreach (var item in tests)
+            {
+                yield return item();
+            }
+
+            if (Application.isBatchMode)
+            {
+                var scene = UnityEngine.SceneManagement.SceneManager.GetActiveScene();
+                bool disableAutoClose = (scene.name.Contains("DisableAutoClose"));
+
+                if (allTestGreen)
+                {
+                    WriteToConsole("Test Complete Successfully");
+                    if (!disableAutoClose)
+                    {
+                        Application.Quit();
+                    }
+                }
+                else
+                {
+                    WriteToConsole("Test Failed, please see [NG] log.");
+                    if (!disableAutoClose)
+                    {
+                        Application.Quit(1);
+                    }
+                }
+            }
+        }
+
+        IEnumerator UnwrapEnumerator(IEnumerator enumerator, Action<Exception> exceptionCallback)
+        {
+            var hasNext = true;
+            while (hasNext)
+            {
+                try
+                {
+                    hasNext = enumerator.MoveNext();
+                }
+                catch (Exception ex)
+                {
+                    exceptionCallback(ex);
+                    hasNext = false;
+                }
+
+                if (hasNext)
+                {
+                    // unwrap self for bug of Unity
+                    // https://issuetracker.unity3d.com/issues/does-not-stop-coroutine-when-it-throws-exception-in-movenext-at-first-frame
+                    var moreCoroutine = enumerator.Current as IEnumerator;
+                    if (moreCoroutine != null)
+                    {
+                        yield return StartCoroutine(UnwrapEnumerator(moreCoroutine, ex =>
+                        {
+                            exceptionCallback(ex);
+                            hasNext = false;
+                        }));
+                    }
+                    else
+                    {
+                        yield return enumerator.Current;
+                    }
+                }
+            }
+        }
+
+        static void WriteToConsole(string msg)
+        {
+            if (Application.isBatchMode)
+            {
+                Console.WriteLine(msg);
+            }
+        }
+
+        static void WriteToConsoleResult(string msg, bool green)
+        {
+            if (Application.isBatchMode)
+            {
+                if (!green)
+                {
+                    var currentForeground = Console.ForegroundColor;
+                    Console.ForegroundColor = ConsoleColor.Red;
+                    Console.Write("[NG]");
+                    Console.ForegroundColor = currentForeground;
+                }
+                else
+                {
+                    var currentForeground = Console.ForegroundColor;
+                    Console.ForegroundColor = ConsoleColor.Green;
+                    Console.Write("[OK]");
+                    Console.ForegroundColor = currentForeground;
+                }
+
+                System.Console.WriteLine(msg);
+            }
+        }
+
+        struct Pair
+        {
+            public string Name;
+            public UnityAction Action;
+        }
+    }
+}
diff --git a/Assets/RuntimeUnitTestToolkit/UnitTestRunner.cs.meta b/Assets/RuntimeUnitTestToolkit/UnitTestRunner.cs.meta
new file mode 100644
index 0000000..01a2248
--- /dev/null
+++ b/Assets/RuntimeUnitTestToolkit/UnitTestRunner.cs.meta
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 660baed073888b8438569f57e42679b2
+timeCreated: 1476793308
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/RuntimeUnitTestToolkit/package.json b/Assets/RuntimeUnitTestToolkit/package.json
new file mode 100644
index 0000000..af2f8ed
--- /dev/null
+++ b/Assets/RuntimeUnitTestToolkit/package.json
@@ -0,0 +1,11 @@
+{
+    "name": "jp.cysharp.runtimeunittesttoolkit",
+    "displayName": "RuntimeUnitTestToolkit",
+    "version": "2.0.0",
+    "unity": "2018.3",
+    "description": "CLI/GUI Frontend of Unity Test Runner to test on any platform.",
+    "keywords": ["test"],
+    "category": "Tests",
+    "dependencies": {
+    }
+}
\ No newline at end of file
diff --git a/Assets/RuntimeUnitTestToolkit/package.json.meta b/Assets/RuntimeUnitTestToolkit/package.json.meta
new file mode 100644
index 0000000..61eb2c1
--- /dev/null
+++ b/Assets/RuntimeUnitTestToolkit/package.json.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: b7883c7ac5d6ea4409a229aeab14e796
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Scenes.meta b/Assets/Scenes.meta
new file mode 100644
index 0000000..9e3e79d
--- /dev/null
+++ b/Assets/Scenes.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3e4672a57ce755a44805bc58b4ddea29
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Scenes/SandboxMain.cs b/Assets/Scenes/SandboxMain.cs
new file mode 100644
index 0000000..158da1d
--- /dev/null
+++ b/Assets/Scenes/SandboxMain.cs
@@ -0,0 +1,20 @@
+using System.Collections;
+using System.Collections.Generic;
+using UniRx.Async;
+using UnityEngine;
+
+public class SandboxMain : MonoBehaviour
+{
+    // Start is called before the first frame update
+    void Start()
+    {
+        RunAsync().Forget();
+    }
+
+    async UniTaskVoid RunAsync()
+    {
+        var id = await UniTask.Run(() => System.Threading.Thread.CurrentThread.ManagedThreadId, configureAwait: false);
+        UnityEngine.Debug.Log("ReturnId:" + id);
+        UnityEngine.Debug.Log("CurrentId:" + System.Threading.Thread.CurrentThread.ManagedThreadId);
+    }
+}
diff --git a/Assets/Scenes/SandboxMain.cs.meta b/Assets/Scenes/SandboxMain.cs.meta
new file mode 100644
index 0000000..fa2a677
--- /dev/null
+++ b/Assets/Scenes/SandboxMain.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f0bc6c75abb2e0b47a25aa49bfd488ed
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Scenes/SandboxMain.unity b/Assets/Scenes/SandboxMain.unity
new file mode 100644
index 0000000..c133514
--- /dev/null
+++ b/Assets/Scenes/SandboxMain.unity
@@ -0,0 +1,218 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!29 &1
+OcclusionCullingSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_OcclusionBakeSettings:
+    smallestOccluder: 5
+    smallestHole: 0.25
+    backfaceThreshold: 100
+  m_SceneGUID: 00000000000000000000000000000000
+  m_OcclusionCullingData: {fileID: 0}
+--- !u!104 &2
+RenderSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 9
+  m_Fog: 0
+  m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+  m_FogMode: 3
+  m_FogDensity: 0.01
+  m_LinearFogStart: 0
+  m_LinearFogEnd: 300
+  m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1}
+  m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
+  m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
+  m_AmbientIntensity: 1
+  m_AmbientMode: 3
+  m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1}
+  m_SkyboxMaterial: {fileID: 0}
+  m_HaloStrength: 0.5
+  m_FlareStrength: 1
+  m_FlareFadeSpeed: 3
+  m_HaloTexture: {fileID: 0}
+  m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0}
+  m_DefaultReflectionMode: 0
+  m_DefaultReflectionResolution: 128
+  m_ReflectionBounces: 1
+  m_ReflectionIntensity: 1
+  m_CustomReflection: {fileID: 0}
+  m_Sun: {fileID: 0}
+  m_IndirectSpecularColor: {r: 0, g: 0, b: 0, a: 1}
+  m_UseRadianceAmbientProbe: 0
+--- !u!157 &3
+LightmapSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 11
+  m_GIWorkflowMode: 1
+  m_GISettings:
+    serializedVersion: 2
+    m_BounceScale: 1
+    m_IndirectOutputScale: 1
+    m_AlbedoBoost: 1
+    m_EnvironmentLightingMode: 0
+    m_EnableBakedLightmaps: 0
+    m_EnableRealtimeLightmaps: 0
+  m_LightmapEditorSettings:
+    serializedVersion: 12
+    m_Resolution: 2
+    m_BakeResolution: 40
+    m_AtlasSize: 1024
+    m_AO: 0
+    m_AOMaxDistance: 1
+    m_CompAOExponent: 1
+    m_CompAOExponentDirect: 0
+    m_ExtractAmbientOcclusion: 0
+    m_Padding: 2
+    m_LightmapParameters: {fileID: 0}
+    m_LightmapsBakeMode: 1
+    m_TextureCompression: 1
+    m_FinalGather: 0
+    m_FinalGatherFiltering: 1
+    m_FinalGatherRayCount: 256
+    m_ReflectionCompression: 2
+    m_MixedBakeMode: 2
+    m_BakeBackend: 0
+    m_PVRSampling: 1
+    m_PVRDirectSampleCount: 32
+    m_PVRSampleCount: 500
+    m_PVRBounces: 2
+    m_PVREnvironmentSampleCount: 500
+    m_PVREnvironmentReferencePointCount: 2048
+    m_PVRFilteringMode: 2
+    m_PVRDenoiserTypeDirect: 0
+    m_PVRDenoiserTypeIndirect: 0
+    m_PVRDenoiserTypeAO: 0
+    m_PVRFilterTypeDirect: 0
+    m_PVRFilterTypeIndirect: 0
+    m_PVRFilterTypeAO: 0
+    m_PVREnvironmentMIS: 0
+    m_PVRCulling: 1
+    m_PVRFilteringGaussRadiusDirect: 1
+    m_PVRFilteringGaussRadiusIndirect: 5
+    m_PVRFilteringGaussRadiusAO: 2
+    m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+    m_PVRFilteringAtrousPositionSigmaIndirect: 2
+    m_PVRFilteringAtrousPositionSigmaAO: 1
+    m_ExportTrainingData: 0
+    m_TrainingDataDestination: TrainingData
+  m_LightingDataAsset: {fileID: 0}
+  m_UseShadowmask: 1
+--- !u!196 &4
+NavMeshSettings:
+  serializedVersion: 2
+  m_ObjectHideFlags: 0
+  m_BuildSettings:
+    serializedVersion: 2
+    agentTypeID: 0
+    agentRadius: 0.5
+    agentHeight: 2
+    agentSlope: 45
+    agentClimb: 0.4
+    ledgeDropHeight: 0
+    maxJumpAcrossDistance: 0
+    minRegionArea: 2
+    manualCellSize: 0
+    cellSize: 0.16666667
+    manualTileSize: 0
+    tileSize: 256
+    accuratePlacement: 0
+    debug:
+      m_Flags: 0
+  m_NavMeshData: {fileID: 0}
+--- !u!1 &519420028
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 519420032}
+  - component: {fileID: 519420031}
+  - component: {fileID: 519420029}
+  - component: {fileID: 519420030}
+  m_Layer: 0
+  m_Name: Main Camera
+  m_TagString: MainCamera
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!81 &519420029
+AudioListener:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 519420028}
+  m_Enabled: 1
+--- !u!114 &519420030
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 519420028}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: f0bc6c75abb2e0b47a25aa49bfd488ed, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+--- !u!20 &519420031
+Camera:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 519420028}
+  m_Enabled: 1
+  serializedVersion: 2
+  m_ClearFlags: 2
+  m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0}
+  m_projectionMatrixMode: 1
+  m_GateFitMode: 2
+  m_FOVAxisMode: 0
+  m_SensorSize: {x: 36, y: 24}
+  m_LensShift: {x: 0, y: 0}
+  m_FocalLength: 50
+  m_NormalizedViewPortRect:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  near clip plane: 0.3
+  far clip plane: 1000
+  field of view: 60
+  orthographic: 1
+  orthographic size: 5
+  m_Depth: -1
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_RenderingPath: -1
+  m_TargetTexture: {fileID: 0}
+  m_TargetDisplay: 0
+  m_TargetEye: 0
+  m_HDR: 1
+  m_AllowMSAA: 0
+  m_AllowDynamicResolution: 0
+  m_ForceIntoRT: 0
+  m_OcclusionCulling: 0
+  m_StereoConvergence: 10
+  m_StereoSeparation: 0.022
+--- !u!4 &519420032
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 519420028}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: -10}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
diff --git a/Assets/Scenes/SandboxMain.unity.meta b/Assets/Scenes/SandboxMain.unity.meta
new file mode 100644
index 0000000..c1e3c88
--- /dev/null
+++ b/Assets/Scenes/SandboxMain.unity.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 2cda990e2423bbf4892e6590ba056729
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Tests.meta b/Assets/Tests.meta
new file mode 100644
index 0000000..d480194
--- /dev/null
+++ b/Assets/Tests.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b831a4cf04cbe4b48ae74498484ec8c1
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Tests/AsyncTest.cs b/Assets/Tests/AsyncTest.cs
new file mode 100644
index 0000000..ac50945
--- /dev/null
+++ b/Assets/Tests/AsyncTest.cs
@@ -0,0 +1,384 @@
+#if !(UNITY_4_5 || UNITY_4_6 || UNITY_4_7 || UNITY_5_0 || UNITY_5_1 || UNITY_5_2)
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using UnityEngine;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using UnityEngine.UI;
+using UnityEngine.Scripting;
+using UniRx;
+using UniRx.Async;
+using UnityEngine.SceneManagement;
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+using System.Threading.Tasks;
+#endif
+using UnityEngine.Networking;
+
+#if !UNITY_2019_3_OR_NEWER
+using UnityEngine.Experimental.LowLevel;
+#else
+using UnityEngine.LowLevel;
+#endif
+
+#if !UNITY_WSA
+using Unity.Jobs;
+#endif
+using Unity.Collections;
+using System.Threading;
+using NUnit.Framework;
+using UnityEngine.TestTools;
+using FluentAssertions;
+
+namespace UniRx.AsyncTests
+{
+    public class AsyncTest
+    {
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#if !UNITY_WSA
+
+        public struct MyJob : IJob
+        {
+            public int loopCount;
+            public NativeArray<int> inOut;
+            public int result;
+
+            public void Execute()
+            {
+                result = 0;
+                for (int i = 0; i < loopCount; i++)
+                {
+                    result++;
+                }
+                inOut[0] = result;
+            }
+        }
+
+        [UnityTest]
+        public IEnumerator DelayAnd() => UniTask.ToCoroutine(async () =>
+        {
+            await UniTask.Yield(PlayerLoopTiming.PostLateUpdate);
+
+            var time = Time.realtimeSinceStartup;
+
+            Time.timeScale = 0.5f;
+            try
+            {
+                await UniTask.Delay(TimeSpan.FromSeconds(3));
+
+                var elapsed = Time.realtimeSinceStartup - time;
+                ((int)Math.Round(TimeSpan.FromSeconds(elapsed).TotalSeconds, MidpointRounding.ToEven)).Should().Be(6);
+            }
+            finally
+            {
+                Time.timeScale = 1.0f;
+            }
+        });
+
+        [UnityTest]
+        public IEnumerator DelayIgnore() => UniTask.ToCoroutine(async () =>
+        {
+            var time = Time.realtimeSinceStartup;
+
+            Time.timeScale = 0.5f;
+            try
+            {
+                await UniTask.Delay(TimeSpan.FromSeconds(3), ignoreTimeScale: true);
+
+                var elapsed = Time.realtimeSinceStartup - time;
+                ((int)Math.Round(TimeSpan.FromSeconds(elapsed).TotalSeconds, MidpointRounding.ToEven)).Should().Be(3);
+            }
+            finally
+            {
+                Time.timeScale = 1.0f;
+            }
+        });
+
+        [UnityTest]
+        public IEnumerator WhenAll() => UniTask.ToCoroutine(async () =>
+        {
+            var a = UniTask.FromResult(999);
+            var b = UniTask.Yield(PlayerLoopTiming.Update, CancellationToken.None).AsAsyncUnitUniTask();
+            var c = UniTask.DelayFrame(99);
+
+            var (a2, b2, c2) = await UniTask.WhenAll(a, b, c);
+            a2.Should().Be(999);
+            b2.Should().Be(AsyncUnit.Default);
+            c2.Should().Be(99);
+        });
+
+        [UnityTest]
+        public IEnumerator WhenAny() => UniTask.ToCoroutine(async () =>
+        {
+            var a = UniTask.FromResult(999);
+            var b = UniTask.Yield(PlayerLoopTiming.Update, CancellationToken.None).AsAsyncUnitUniTask();
+            var c = UniTask.DelayFrame(99);
+
+            var (win, a2, b2, c2) = await UniTask.WhenAny(a, b, c);
+            win.Should().Be(0);
+            a2.hasResult.Should().Be(true);
+            a2.result0.Should().Be(999);
+            b2.hasResult.Should().Be(false);
+            c2.hasResult.Should().Be(false);
+        });
+
+        [UnityTest]
+        public IEnumerator BothEnumeratorCheck() => UniTask.ToCoroutine(async () =>
+        {
+            await ToaruCoroutineEnumerator(); // wait 5 frame:)
+            await ToaruCoroutineEnumerator().ConfigureAwait(PlayerLoopTiming.PostLateUpdate);
+        });
+
+        [UnityTest]
+        public IEnumerator JobSystem() => UniTask.ToCoroutine(async () =>
+        {
+            var job = new MyJob() { loopCount = 999, inOut = new NativeArray<int>(1, Allocator.TempJob) };
+            JobHandle.ScheduleBatchedJobs();
+            await job.Schedule();
+            job.inOut[0].Should().Be(999);
+            job.inOut.Dispose();
+        });
+
+        class MyMyClass
+        {
+            public int MyProperty { get; set; }
+        }
+
+        [UnityTest]
+        public IEnumerator WaitUntil() => UniTask.ToCoroutine(async () =>
+        {
+            bool t = false;
+
+            UniTask.DelayFrame(10, PlayerLoopTiming.PostLateUpdate).ContinueWith(_ => t = true).Forget();
+
+            var startFrame = Time.frameCount;
+            await UniTask.WaitUntil(() => t, PlayerLoopTiming.EarlyUpdate);
+
+            var diff = Time.frameCount - startFrame;
+            diff.Should().Be(11);
+        });
+
+        [UnityTest]
+        public IEnumerator WaitWhile() => UniTask.ToCoroutine(async () =>
+        {
+            bool t = true;
+
+            UniTask.DelayFrame(10, PlayerLoopTiming.PostLateUpdate).ContinueWith(_ => t = false).Forget();
+
+            var startFrame = Time.frameCount;
+            await UniTask.WaitWhile(() => t, PlayerLoopTiming.EarlyUpdate);
+
+            var diff = Time.frameCount - startFrame;
+            diff.Should().Be(11);
+        });
+
+        [UnityTest]
+        public IEnumerator WaitUntilValueChanged() => UniTask.ToCoroutine(async () =>
+        {
+            var v = new MyMyClass { MyProperty = 99 };
+
+            UniTask.DelayFrame(10, PlayerLoopTiming.PostLateUpdate).ContinueWith(_ => v.MyProperty = 1000).Forget();
+
+            var startFrame = Time.frameCount;
+            await UniTask.WaitUntilValueChanged(v, x => x.MyProperty, PlayerLoopTiming.EarlyUpdate);
+
+            var diff = Time.frameCount - startFrame;
+            diff.Should().Be(11);
+        });
+
+        [UnityTest]
+        public IEnumerator SwitchTo() => UniTask.ToCoroutine(async () =>
+        {
+            await UniTask.Yield();
+
+            var currentThreadId = Thread.CurrentThread.ManagedThreadId;
+
+            UnityEngine.Debug.Log("Before:" + currentThreadId);
+
+
+            await UniTask.SwitchToThreadPool();
+            //await UniTask.SwitchToThreadPool();
+            //await UniTask.SwitchToThreadPool();
+
+
+            
+
+
+
+            var switchedThreadId = Thread.CurrentThread.ManagedThreadId;
+
+            UnityEngine.Debug.Log("After:" + switchedThreadId);
+
+
+            currentThreadId.Should().NotBe(switchedThreadId);
+
+
+            await UniTask.Yield();
+
+            var switchedThreadId2 = Thread.CurrentThread.ManagedThreadId;
+
+            currentThreadId.Should().Be(switchedThreadId2);
+        });
+
+        //[UnityTest]
+        //public IEnumerator ObservableConversion() => UniTask.ToCoroutine(async () =>
+        //{
+        //    var v = await Observable.Range(1, 10).ToUniTask();
+        //    v.Is(10);
+
+        //    v = await Observable.Range(1, 10).ToUniTask(useFirstValue: true);
+        //    v.Is(1);
+
+        //    v = await UniTask.DelayFrame(10).ToObservable().ToTask();
+        //    v.Is(10);
+
+        //    v = await UniTask.FromResult(99).ToObservable();
+        //    v.Is(99);
+        //});
+
+        //[UnityTest]
+        //public IEnumerator AwaitableReactiveProperty() => UniTask.ToCoroutine(async () =>
+        //{
+        //    var rp1 = new ReactiveProperty<int>(99);
+
+        //    UniTask.DelayFrame(100).ContinueWith(x => rp1.Value = x).Forget();
+
+        //    await rp1;
+
+        //    rp1.Value.Is(100);
+
+        //    // var delay2 = UniTask.DelayFrame(10);
+        //    // var (a, b ) = await UniTask.WhenAll(rp1.WaitUntilValueChangedAsync(), delay2);
+
+        //});
+
+        //[UnityTest]
+        //public IEnumerator AwaitableReactiveCommand() => UniTask.ToCoroutine(async () =>
+        //{
+        //    var rc = new ReactiveCommand<int>();
+
+        //    UniTask.DelayFrame(100).ContinueWith(x => rc.Execute(x)).Forget();
+
+        //    var v = await rc;
+
+        //    v.Is(100);
+        //});
+
+        [UnityTest]
+        public IEnumerator ExceptionlessCancellation() => UniTask.ToCoroutine(async () =>
+        {
+            var cts = new CancellationTokenSource();
+
+            UniTask.DelayFrame(10).ContinueWith(_ => cts.Cancel()).Forget();
+
+            var first = Time.frameCount;
+            var (canceled, value) = await UniTask.DelayFrame(100, cancellationToken: cts.Token).SuppressCancellationThrow();
+
+            (Time.frameCount - first).Should().Be(11); // 10 frame canceled
+            canceled.Should().Be(true);
+        });
+
+        [UnityTest]
+        public IEnumerator ExceptionCancellation() => UniTask.ToCoroutine(async () =>
+        {
+            var cts = new CancellationTokenSource();
+
+            UniTask.DelayFrame(10).ContinueWith(_ => cts.Cancel()).Forget();
+
+            bool occur = false;
+            try
+            {
+                var value = await UniTask.DelayFrame(100, cancellationToken: cts.Token);
+            }
+            catch (OperationCanceledException)
+            {
+                occur = true;
+            }
+            occur.Should().BeTrue();
+        });
+
+        IEnumerator ToaruCoroutineEnumerator()
+        {
+            yield return null;
+            yield return null;
+            yield return null;
+            yield return null;
+            yield return null;
+        }
+
+        [UnityTest]
+        public IEnumerator ExceptionUnobserved1() => UniTask.ToCoroutine(async () =>
+        {
+            bool calledEx = false;
+            Action<Exception> action = exx =>
+            {
+                calledEx = true;
+                exx.Message.Should().Be("MyException");
+            };
+
+            UniTaskScheduler.UnobservedTaskException += action;
+
+            var ex = InException1();
+            ex = default(UniTask);
+
+            await UniTask.DelayFrame(3);
+
+            GC.Collect();
+            GC.WaitForPendingFinalizers();
+            GC.Collect();
+
+            await UniTask.DelayFrame(1);
+
+            calledEx.Should().BeTrue();
+
+            UniTaskScheduler.UnobservedTaskException -= action;
+        });
+
+        [UnityTest]
+        public IEnumerator ExceptionUnobserved2() => UniTask.ToCoroutine(async () =>
+        {
+            bool calledEx = false;
+            Action<Exception> action = exx =>
+            {
+                calledEx = true;
+                exx.Message.Should().Be("MyException");
+            };
+
+            UniTaskScheduler.UnobservedTaskException += action;
+
+            var ex = InException2();
+            ex = default(UniTask<int>);
+
+            await UniTask.DelayFrame(3);
+
+            GC.Collect();
+            GC.WaitForPendingFinalizers();
+            GC.Collect();
+
+            await UniTask.DelayFrame(1);
+
+            calledEx.Should().BeTrue();
+
+            UniTaskScheduler.UnobservedTaskException -= action;
+        });
+
+        async UniTask InException1()
+        {
+            await UniTask.Yield();
+            throw new Exception("MyException");
+        }
+
+        async UniTask<int> InException2()
+        {
+            await UniTask.Yield();
+            throw new Exception("MyException");
+        }
+
+#endif
+#endif
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/Tests/AsyncTest.cs.meta b/Assets/Tests/AsyncTest.cs.meta
new file mode 100644
index 0000000..94123d0
--- /dev/null
+++ b/Assets/Tests/AsyncTest.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5e9960810a8f0634cb4aea38c563d947
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Tests/RunTest.cs b/Assets/Tests/RunTest.cs
new file mode 100644
index 0000000..b6caa46
--- /dev/null
+++ b/Assets/Tests/RunTest.cs
@@ -0,0 +1,96 @@
+#if !(UNITY_4_5 || UNITY_4_6 || UNITY_4_7 || UNITY_5_0 || UNITY_5_1 || UNITY_5_2)
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using UnityEngine;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using UnityEngine.UI;
+using UnityEngine.Scripting;
+using UniRx;
+using UniRx.Async;
+using UnityEngine.SceneManagement;
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+using System.Threading.Tasks;
+#endif
+using UnityEngine.Networking;
+
+#if !UNITY_2019_3_OR_NEWER
+using UnityEngine.Experimental.LowLevel;
+#else
+using UnityEngine.LowLevel;
+#endif
+
+#if !UNITY_WSA
+using Unity.Jobs;
+#endif
+using Unity.Collections;
+using System.Threading;
+using NUnit.Framework;
+using UnityEngine.TestTools;
+using FluentAssertions;
+
+namespace UniRx.AsyncTests
+{
+    public class RunTest
+    {
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#if !UNITY_WSA
+
+        //[UnityTest]
+        //public IEnumerator RunThread() => UniTask.ToCoroutine(async () =>
+        //{
+        //    var main = Thread.CurrentThread.ManagedThreadId;
+        //    var v = await UniTask.Run(() => { return System.Threading.Thread.CurrentThread.ManagedThreadId; }, false);
+        //    UnityEngine.Debug.Log("Ret Value is:" + v);
+        //    UnityEngine.Debug.Log("Run Here and id:" + System.Threading.Thread.CurrentThread.ManagedThreadId);
+        //    //v.Should().Be(3);
+        //    main.Should().NotBe(Thread.CurrentThread.ManagedThreadId);
+        //});
+
+        [UnityTest]
+        public IEnumerator RunThreadConfigure() => UniTask.ToCoroutine(async () =>
+        {
+            var main = Thread.CurrentThread.ManagedThreadId;
+            var v = await UniTask.Run(() => 3, true);
+            v.Should().Be(3);
+            main.Should().Be(Thread.CurrentThread.ManagedThreadId);
+        });
+
+        //[UnityTest]
+        //public IEnumerator RunThreadException() => UniTask.ToCoroutine(async () =>
+        //{
+        //    var main = Thread.CurrentThread.ManagedThreadId;
+        //    try
+        //    {
+        //        await UniTask.Run<int>(() => throw new Exception(), false);
+        //    }
+        //    catch
+        //    {
+        //        main.Should().NotBe(Thread.CurrentThread.ManagedThreadId);
+        //    }
+        //});
+
+        [UnityTest]
+        public IEnumerator RunThreadExceptionConfigure() => UniTask.ToCoroutine(async () =>
+        {
+            var main = Thread.CurrentThread.ManagedThreadId;
+            try
+            {
+                await UniTask.Run<int>(() => throw new Exception(), true);
+            }
+            catch
+            {
+                main.Should().Be(Thread.CurrentThread.ManagedThreadId);
+            }
+        });
+
+
+#endif
+#endif
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/Tests/RunTest.cs.meta b/Assets/Tests/RunTest.cs.meta
new file mode 100644
index 0000000..cf61c6d
--- /dev/null
+++ b/Assets/Tests/RunTest.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3510f39953ed3074cb2e0f04d3a3f807
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Tests/Shims.cs b/Assets/Tests/Shims.cs
new file mode 100644
index 0000000..cb44f7d
--- /dev/null
+++ b/Assets/Tests/Shims.cs
@@ -0,0 +1,144 @@
+using NUnit.Framework;
+using System;
+
+namespace Xunit
+{
+    public class FactAttribute : TestAttribute
+    {
+
+    }
+}
+
+// Shims of FluentAssertions
+namespace FluentAssertions
+{
+    public static class FluentAssertionsExtensions
+    {
+        public static Int Should(this int value)
+        {
+            return new Int(value);
+        }
+
+        public static Bool Should(this bool value)
+        {
+            return new Bool(value);
+        }
+
+        public static ExceptionAssertion Should(this Exception value)
+        {
+            return new ExceptionAssertion(value);
+        }
+
+        public static Generic<T> Should<T>(this T value)
+        {
+            return new Generic<T>(value);
+        }
+
+        public class Generic<T>
+        {
+            readonly T actual;
+
+            public Generic(T value)
+            {
+                actual = value;
+            }
+
+            public void Be(T expected)
+            {
+                Assert.AreEqual(expected, actual);
+            }
+
+            public void NotBe(T expected)
+            {
+                Assert.AreNotEqual(expected, actual);
+            }
+
+            public void BeNull()
+            {
+                Assert.IsNull(actual);
+            }
+
+            public void NotBeNull()
+            {
+                Assert.IsNotNull(actual);
+            }
+        }
+
+        public class Bool
+        {
+            readonly bool actual;
+
+            public Bool(bool value)
+            {
+                actual = value;
+            }
+
+            public void Be(bool expected)
+            {
+                Assert.AreEqual(expected, actual);
+            }
+
+            public void NotBe(bool expected)
+            {
+                Assert.AreNotEqual(expected, actual);
+            }
+
+            public void BeTrue()
+            {
+                Assert.AreEqual(true, actual);
+            }
+
+            public void BeFalse()
+            {
+                Assert.AreEqual(false, actual);
+            }
+        }
+
+        public class Int
+        {
+            readonly int actual;
+
+            public Int(int value)
+            {
+                actual = value;
+            }
+
+            public void Be(int expected)
+            {
+                Assert.AreEqual(expected, actual);
+            }
+
+            public void NotBe(int expected)
+            {
+                Assert.AreNotEqual(expected, actual);
+            }
+
+            public void BeCloseTo(int expected, int delta)
+            {
+                if (expected - delta <= actual && actual <= expected + delta)
+                {
+                    // OK.
+                }
+                else
+                {
+                    Assert.Fail($"Fail BeCloseTo, actual {actual} but expected:{expected} +- {delta}");
+                }
+            }
+        }
+
+        public class ExceptionAssertion
+        {
+            readonly Exception actual;
+
+            public ExceptionAssertion(Exception actual)
+            {
+                this.actual = actual;
+            }
+
+            public void BeAssignableTo<T>()
+            {
+                typeof(T).IsAssignableFrom(actual.GetType());
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Assets/Tests/Shims.cs.meta b/Assets/Tests/Shims.cs.meta
new file mode 100644
index 0000000..06a21d7
--- /dev/null
+++ b/Assets/Tests/Shims.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f76a88025d2f76a4bae09aaa268da103
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Tests/UniRx.Async.Tests.asmdef b/Assets/Tests/UniRx.Async.Tests.asmdef
new file mode 100644
index 0000000..bd3030c
--- /dev/null
+++ b/Assets/Tests/UniRx.Async.Tests.asmdef
@@ -0,0 +1,20 @@
+{
+    "name": "UniRx.Async.Tests",
+    "references": [
+        "UnityEngine.TestRunner",
+        "UnityEditor.TestRunner",
+        "UniRx.Async"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "nunit.framework.dll"
+    ],
+    "autoReferenced": false,
+    "defineConstraints": [
+        "UNITY_INCLUDE_TESTS"
+    ],
+    "versionDefines": []
+}
\ No newline at end of file
diff --git a/Assets/Tests/UniRx.Async.Tests.asmdef.meta b/Assets/Tests/UniRx.Async.Tests.asmdef.meta
new file mode 100644
index 0000000..af495a2
--- /dev/null
+++ b/Assets/Tests/UniRx.Async.Tests.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 9fbc684c31ac15b42809d42b62f6eb5f
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Tests/WhenAnyTest.cs b/Assets/Tests/WhenAnyTest.cs
new file mode 100644
index 0000000..f78bb4a
--- /dev/null
+++ b/Assets/Tests/WhenAnyTest.cs
@@ -0,0 +1,44 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using UnityEngine;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using UnityEngine.UI;
+using UnityEngine.Scripting;
+using UniRx;
+using UniRx.Async;
+using Unity.Collections;
+using System.Threading;
+using NUnit.Framework;
+using UnityEngine.TestTools;
+using FluentAssertions;
+
+namespace UniRx.AsyncTests
+{
+    public class WhenAnyTest
+    {
+        [UnityTest]
+        public IEnumerator WhenAnyCanceled() => UniTask.ToCoroutine(async () =>
+        {
+            var cts = new CancellationTokenSource();
+            var successDelayTask = UniTask.Delay(TimeSpan.FromSeconds(1));
+            var cancelTask = UniTask.Delay(TimeSpan.FromSeconds(1), cancellationToken: cts.Token);
+            cts.CancelAfterSlim(200);
+
+            try
+            {
+                var r = await UniTask.WhenAny(new[] { successDelayTask, cancelTask });
+            }
+            catch (Exception ex)
+            {
+                ex.Should().BeAssignableTo<OperationCanceledException>();
+            }
+        });
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/Tests/WhenAnyTest.cs.meta b/Assets/Tests/WhenAnyTest.cs.meta
new file mode 100644
index 0000000..d1fe0e9
--- /dev/null
+++ b/Assets/Tests/WhenAnyTest.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0a07d2ea8baf390408279a29510f4953
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async.meta b/Assets/UniRx.Async.meta
new file mode 100644
index 0000000..e996cef
--- /dev/null
+++ b/Assets/UniRx.Async.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 38249c6f05d584f44a219b4c97790f99
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/AsyncUnit.cs b/Assets/UniRx.Async/AsyncUnit.cs
new file mode 100644
index 0000000..1a8f09d
--- /dev/null
+++ b/Assets/UniRx.Async/AsyncUnit.cs
@@ -0,0 +1,28 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or 
+
+using System;
+
+namespace UniRx.Async
+{
+    public struct AsyncUnit : IEquatable<AsyncUnit>
+    {
+        public static readonly AsyncUnit Default = new AsyncUnit();
+
+        public override int GetHashCode()
+        {
+            return 0;
+        }
+
+        public bool Equals(AsyncUnit other)
+        {
+            return true;
+        }
+
+        public override string ToString()
+        {
+            return "()";
+        }
+    }
+}
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/AsyncUnit.cs.meta b/Assets/UniRx.Async/AsyncUnit.cs.meta
new file mode 100644
index 0000000..e0ee132
--- /dev/null
+++ b/Assets/UniRx.Async/AsyncUnit.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4f95ac245430d304bb5128d13b6becc8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/CancellationTokenEqualityComparer.cs b/Assets/UniRx.Async/CancellationTokenEqualityComparer.cs
new file mode 100644
index 0000000..72cdea2
--- /dev/null
+++ b/Assets/UniRx.Async/CancellationTokenEqualityComparer.cs
@@ -0,0 +1,25 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+
+namespace UniRx.Async
+{
+    public class CancellationTokenEqualityComparer : IEqualityComparer<CancellationToken>
+    {
+        public static readonly IEqualityComparer<CancellationToken> Default = new CancellationTokenEqualityComparer();
+
+        public bool Equals(CancellationToken x, CancellationToken y)
+        {
+            return x.Equals(y);
+        }
+
+        public int GetHashCode(CancellationToken obj)
+        {
+            return obj.GetHashCode();
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/CancellationTokenEqualityComparer.cs.meta b/Assets/UniRx.Async/CancellationTokenEqualityComparer.cs.meta
new file mode 100644
index 0000000..a4fe3fd
--- /dev/null
+++ b/Assets/UniRx.Async/CancellationTokenEqualityComparer.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7d739f510b125b74fa7290ac4335e46e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/CancellationTokenExtensions.cs b/Assets/UniRx.Async/CancellationTokenExtensions.cs
new file mode 100644
index 0000000..8bfe4be
--- /dev/null
+++ b/Assets/UniRx.Async/CancellationTokenExtensions.cs
@@ -0,0 +1,76 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Threading;
+
+namespace UniRx.Async
+{
+    public static class CancellationTokenExtensions
+    {
+        static readonly Action<object> cancellationTokenCallback = Callback;
+
+        public static (UniTask, CancellationTokenRegistration) ToUniTask(this CancellationToken cts)
+        {
+            if (cts.IsCancellationRequested)
+            {
+                return (UniTask.FromCanceled(cts), default(CancellationTokenRegistration));
+            }
+
+            var promise = new UniTaskCompletionSource<AsyncUnit>();
+            return (promise.Task, cts.RegisterWithoutCaptureExecutionContext(cancellationTokenCallback, promise));
+        }
+
+        static void Callback(object state)
+        {
+            var promise = (UniTaskCompletionSource<AsyncUnit>)state;
+            promise.TrySetResult(AsyncUnit.Default);
+        }
+
+        public static CancellationTokenRegistration RegisterWithoutCaptureExecutionContext(this CancellationToken cancellationToken, Action callback)
+        {
+            var restoreFlow = false;
+            if (!ExecutionContext.IsFlowSuppressed())
+            {
+                ExecutionContext.SuppressFlow();
+                restoreFlow = true;
+            }
+
+            try
+            {
+                return cancellationToken.Register(callback, false);
+            }
+            finally
+            {
+                if (restoreFlow)
+                {
+                    ExecutionContext.RestoreFlow();
+                }
+            }
+        }
+
+        public static CancellationTokenRegistration RegisterWithoutCaptureExecutionContext(this CancellationToken cancellationToken, Action<object> callback, object state)
+        {
+            var restoreFlow = false;
+            if (!ExecutionContext.IsFlowSuppressed())
+            {
+                ExecutionContext.SuppressFlow();
+                restoreFlow = true;
+            }
+
+            try
+            {
+                return cancellationToken.Register(callback, state, false);
+            }
+            finally
+            {
+                if (restoreFlow)
+                {
+                    ExecutionContext.RestoreFlow();
+                }
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/CancellationTokenExtensions.cs.meta b/Assets/UniRx.Async/CancellationTokenExtensions.cs.meta
new file mode 100644
index 0000000..28a6958
--- /dev/null
+++ b/Assets/UniRx.Async/CancellationTokenExtensions.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4be7209f04146bd45ac5ee775a5f7c26
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/CancellationTokenSourceExtensions.cs b/Assets/UniRx.Async/CancellationTokenSourceExtensions.cs
new file mode 100644
index 0000000..17618d7
--- /dev/null
+++ b/Assets/UniRx.Async/CancellationTokenSourceExtensions.cs
@@ -0,0 +1,48 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Threading;
+using UnityEngine;
+using UniRx.Async.Triggers;
+using System;
+
+namespace UniRx.Async
+{
+    public static class CancellationTokenSourceExtensions
+    {
+        public static void CancelAfterSlim(this CancellationTokenSource cts, int millisecondsDelay, bool ignoreTimeScale = false, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update)
+        {
+            var delay = UniTask.Delay(millisecondsDelay, ignoreTimeScale, delayTiming, cts.Token);
+            CancelAfterCore(cts, delay).Forget();
+        }
+
+        public static void CancelAfterSlim(this CancellationTokenSource cts, TimeSpan delayTimeSpan, bool ignoreTimeScale = false, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update)
+        {
+            var delay = UniTask.Delay(delayTimeSpan, ignoreTimeScale, delayTiming, cts.Token);
+            CancelAfterCore(cts, delay).Forget();
+        }
+
+        static async UniTaskVoid CancelAfterCore(CancellationTokenSource cts, UniTask delayTask)
+        {
+            var alreadyCanceled = await delayTask.SuppressCancellationThrow();
+            if (!alreadyCanceled)
+            {
+                cts.Cancel();
+                cts.Dispose();
+            }
+        }
+
+        public static void RegisterRaiseCancelOnDestroy(this CancellationTokenSource cts, Component component)
+        {
+            RegisterRaiseCancelOnDestroy(cts, component.gameObject);
+        }
+
+        public static void RegisterRaiseCancelOnDestroy(this CancellationTokenSource cts, GameObject gameObject)
+        {
+            var trigger = gameObject.GetAsyncDestroyTrigger();
+            trigger.AddCancellationTriggerOnDestory(cts);
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/CancellationTokenSourceExtensions.cs.meta b/Assets/UniRx.Async/CancellationTokenSourceExtensions.cs.meta
new file mode 100644
index 0000000..fd09fe4
--- /dev/null
+++ b/Assets/UniRx.Async/CancellationTokenSourceExtensions.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 22d85d07f1e70ab42a7a4c25bd65e661
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/CompilerServices.meta b/Assets/UniRx.Async/CompilerServices.meta
new file mode 100644
index 0000000..867c29f
--- /dev/null
+++ b/Assets/UniRx.Async/CompilerServices.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 64b064347ca7a404494a996b072e2e29
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/CompilerServices/AsyncMethodBuilderAttribute.cs b/Assets/UniRx.Async/CompilerServices/AsyncMethodBuilderAttribute.cs
new file mode 100644
index 0000000..b9658c9
--- /dev/null
+++ b/Assets/UniRx.Async/CompilerServices/AsyncMethodBuilderAttribute.cs
@@ -0,0 +1,18 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+namespace System.Runtime.CompilerServices
+{
+    public sealed class AsyncMethodBuilderAttribute : Attribute
+    {
+        public Type BuilderType { get; }
+
+        public AsyncMethodBuilderAttribute(Type builderType)
+        {
+            BuilderType = builderType;
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/CompilerServices/AsyncMethodBuilderAttribute.cs.meta b/Assets/UniRx.Async/CompilerServices/AsyncMethodBuilderAttribute.cs.meta
new file mode 100644
index 0000000..19961df
--- /dev/null
+++ b/Assets/UniRx.Async/CompilerServices/AsyncMethodBuilderAttribute.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 02ce354d37b10454e8376062f7cbe57a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/CompilerServices/AsyncUniTaskMethodBuilder.cs b/Assets/UniRx.Async/CompilerServices/AsyncUniTaskMethodBuilder.cs
new file mode 100644
index 0000000..586f859
--- /dev/null
+++ b/Assets/UniRx.Async/CompilerServices/AsyncUniTaskMethodBuilder.cs
@@ -0,0 +1,274 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Security;
+
+namespace UniRx.Async.CompilerServices
+{
+    public struct AsyncUniTaskMethodBuilder
+    {
+        UniTaskCompletionSource promise;
+        Action moveNext;
+
+        // 1. Static Create method.
+        [DebuggerHidden]
+        public static AsyncUniTaskMethodBuilder Create()
+        {
+            var builder = new AsyncUniTaskMethodBuilder();
+            return builder;
+        }
+
+        // 2. TaskLike Task property.
+        [DebuggerHidden]
+        public UniTask Task
+        {
+            get
+            {
+                if (promise != null)
+                {
+                    return promise.Task;
+                }
+
+                if (moveNext == null)
+                {
+                    return UniTask.CompletedTask;
+                }
+                else
+                {
+                    promise = new UniTaskCompletionSource();
+                    return promise.Task;
+                }
+            }
+        }
+
+        // 3. SetException
+        [DebuggerHidden]
+        public void SetException(Exception exception)
+        {
+            if (promise == null)
+            {
+                promise = new UniTaskCompletionSource();
+            }
+            if (exception is OperationCanceledException ex)
+            {
+                promise.TrySetCanceled(ex);
+            }
+            else
+            {
+                promise.TrySetException(exception);
+            }
+        }
+
+        // 4. SetResult
+        [DebuggerHidden]
+        public void SetResult()
+        {
+            if (moveNext == null)
+            {
+            }
+            else
+            {
+                if (promise == null)
+                {
+                    promise = new UniTaskCompletionSource();
+                }
+                promise.TrySetResult();
+            }
+        }
+
+        // 5. AwaitOnCompleted
+        [DebuggerHidden]
+        public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
+            where TAwaiter : INotifyCompletion
+            where TStateMachine : IAsyncStateMachine
+        {
+            if (moveNext == null)
+            {
+                if (promise == null)
+                {
+                    promise = new UniTaskCompletionSource(); // built future.
+                }
+
+                var runner = new MoveNextRunner<TStateMachine>();
+                moveNext = runner.Run;
+                runner.StateMachine = stateMachine; // set after create delegate.
+            }
+
+            awaiter.OnCompleted(moveNext);
+        }
+
+        // 6. AwaitUnsafeOnCompleted
+        [DebuggerHidden]
+        [SecuritySafeCritical]
+        public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
+            where TAwaiter : ICriticalNotifyCompletion
+            where TStateMachine : IAsyncStateMachine
+        {
+            if (moveNext == null)
+            {
+                if (promise == null)
+                {
+                    promise = new UniTaskCompletionSource(); // built future.
+                }
+
+                var runner = new MoveNextRunner<TStateMachine>();
+                moveNext = runner.Run;
+                runner.StateMachine = stateMachine; // set after create delegate.
+            }
+
+            awaiter.UnsafeOnCompleted(moveNext);
+        }
+
+        // 7. Start
+        [DebuggerHidden]
+        public void Start<TStateMachine>(ref TStateMachine stateMachine)
+            where TStateMachine : IAsyncStateMachine
+        {
+            stateMachine.MoveNext();
+        }
+
+        // 8. SetStateMachine
+        [DebuggerHidden]
+        public void SetStateMachine(IAsyncStateMachine stateMachine)
+        {
+        }
+    }
+
+
+    public struct AsyncUniTaskMethodBuilder<T>
+    {
+        T result;
+        UniTaskCompletionSource<T> promise;
+        Action moveNext;
+
+        // 1. Static Create method.
+        [DebuggerHidden]
+        public static AsyncUniTaskMethodBuilder<T> Create()
+        {
+            var builder = new AsyncUniTaskMethodBuilder<T>();
+            return builder;
+        }
+
+        // 2. TaskLike Task property.
+        [DebuggerHidden]
+        public UniTask<T> Task
+        {
+            get
+            {
+                if (promise != null)
+                {
+                    return new UniTask<T>(promise);
+                }
+
+                if (moveNext == null)
+                {
+                    return new UniTask<T>(result);
+                }
+                else
+                {
+                    promise = new UniTaskCompletionSource<T>();
+                    return new UniTask<T>(promise);
+                }
+            }
+        }
+
+        // 3. SetException
+        [DebuggerHidden]
+        public void SetException(Exception exception)
+        {
+            if (promise == null)
+            {
+                promise = new UniTaskCompletionSource<T>();
+            }
+            if (exception is OperationCanceledException ex)
+            {
+                promise.TrySetCanceled(ex);
+            }
+            else
+            {
+                promise.TrySetException(exception);
+            }
+        }
+
+        // 4. SetResult
+        [DebuggerHidden]
+        public void SetResult(T result)
+        {
+            if (moveNext == null)
+            {
+                this.result = result;
+            }
+            else
+            {
+                if (promise == null)
+                {
+                    promise = new UniTaskCompletionSource<T>();
+                }
+                promise.TrySetResult(result);
+            }
+        }
+
+        // 5. AwaitOnCompleted
+        [DebuggerHidden]
+        public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
+            where TAwaiter : INotifyCompletion
+            where TStateMachine : IAsyncStateMachine
+        {
+            if (moveNext == null)
+            {
+                if (promise == null)
+                {
+                    promise = new UniTaskCompletionSource<T>(); // built future.
+                }
+
+                var runner = new MoveNextRunner<TStateMachine>();
+                moveNext = runner.Run;
+                runner.StateMachine = stateMachine; // set after create delegate.
+            }
+
+            awaiter.OnCompleted(moveNext);
+        }
+
+        // 6. AwaitUnsafeOnCompleted
+        [DebuggerHidden]
+        [SecuritySafeCritical]
+        public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
+            where TAwaiter : ICriticalNotifyCompletion
+            where TStateMachine : IAsyncStateMachine
+        {
+            if (moveNext == null)
+            {
+                if (promise == null)
+                {
+                    promise = new UniTaskCompletionSource<T>(); // built future.
+                }
+
+                var runner = new MoveNextRunner<TStateMachine>();
+                moveNext = runner.Run;
+                runner.StateMachine = stateMachine; // set after create delegate.
+            }
+
+            awaiter.UnsafeOnCompleted(moveNext);
+        }
+
+        // 7. Start
+        [DebuggerHidden]
+        public void Start<TStateMachine>(ref TStateMachine stateMachine)
+            where TStateMachine : IAsyncStateMachine
+        {
+            stateMachine.MoveNext();
+        }
+
+        // 8. SetStateMachine
+        [DebuggerHidden]
+        public void SetStateMachine(IAsyncStateMachine stateMachine)
+        {
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/CompilerServices/AsyncUniTaskMethodBuilder.cs.meta b/Assets/UniRx.Async/CompilerServices/AsyncUniTaskMethodBuilder.cs.meta
new file mode 100644
index 0000000..ad43cfc
--- /dev/null
+++ b/Assets/UniRx.Async/CompilerServices/AsyncUniTaskMethodBuilder.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 68d72a45afdec574ebc26e7de2c38330
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/CompilerServices/AsyncUniTaskVoidMethodBuilder.cs b/Assets/UniRx.Async/CompilerServices/AsyncUniTaskVoidMethodBuilder.cs
new file mode 100644
index 0000000..2fcd55f
--- /dev/null
+++ b/Assets/UniRx.Async/CompilerServices/AsyncUniTaskVoidMethodBuilder.cs
@@ -0,0 +1,90 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Security;
+
+namespace UniRx.Async.CompilerServices
+{
+    public struct AsyncUniTaskVoidMethodBuilder
+    {
+        Action moveNext;
+
+        // 1. Static Create method.
+        [DebuggerHidden]
+        public static AsyncUniTaskVoidMethodBuilder Create()
+        {
+            var builder = new AsyncUniTaskVoidMethodBuilder();
+            return builder;
+        }
+
+        // 2. TaskLike Task property(void)
+        public UniTaskVoid Task => default(UniTaskVoid);
+
+        // 3. SetException
+        [DebuggerHidden]
+        public void SetException(Exception exception)
+        {
+            UniTaskScheduler.PublishUnobservedTaskException(exception);
+        }
+
+        // 4. SetResult
+        [DebuggerHidden]
+        public void SetResult()
+        {
+            // do nothing
+        }
+
+        // 5. AwaitOnCompleted
+        [DebuggerHidden]
+        public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
+            where TAwaiter : INotifyCompletion
+            where TStateMachine : IAsyncStateMachine
+        {
+            if (moveNext == null)
+            {
+                var runner = new MoveNextRunner<TStateMachine>();
+                moveNext = runner.Run;
+                runner.StateMachine = stateMachine; // set after create delegate.
+            }
+
+            awaiter.OnCompleted(moveNext);
+        }
+
+        // 6. AwaitUnsafeOnCompleted
+        [DebuggerHidden]
+        [SecuritySafeCritical]
+        public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
+            where TAwaiter : ICriticalNotifyCompletion
+            where TStateMachine : IAsyncStateMachine
+        {
+            if (moveNext == null)
+            {
+                var runner = new MoveNextRunner<TStateMachine>();
+                moveNext = runner.Run;
+                runner.StateMachine = stateMachine; // set after create delegate.
+            }
+
+            awaiter.UnsafeOnCompleted(moveNext);
+        }
+
+        // 7. Start
+        [DebuggerHidden]
+        public void Start<TStateMachine>(ref TStateMachine stateMachine)
+            where TStateMachine : IAsyncStateMachine
+        {
+            stateMachine.MoveNext();
+        }
+
+        // 8. SetStateMachine
+        [DebuggerHidden]
+        public void SetStateMachine(IAsyncStateMachine stateMachine)
+        {
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/CompilerServices/AsyncUniTaskVoidMethodBuilder.cs.meta b/Assets/UniRx.Async/CompilerServices/AsyncUniTaskVoidMethodBuilder.cs.meta
new file mode 100644
index 0000000..9bcc50e
--- /dev/null
+++ b/Assets/UniRx.Async/CompilerServices/AsyncUniTaskVoidMethodBuilder.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e891aaac17b933a47a9d7fa3b8e1226f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/CompilerServices/MoveNextRunner.cs b/Assets/UniRx.Async/CompilerServices/MoveNextRunner.cs
new file mode 100644
index 0000000..ddf7a03
--- /dev/null
+++ b/Assets/UniRx.Async/CompilerServices/MoveNextRunner.cs
@@ -0,0 +1,23 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+
+namespace UniRx.Async.CompilerServices
+{
+    internal class MoveNextRunner<TStateMachine>
+        where TStateMachine : IAsyncStateMachine
+    {
+        public TStateMachine StateMachine;
+
+        [DebuggerHidden]
+        public void Run()
+        {
+            StateMachine.MoveNext();
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/CompilerServices/MoveNextRunner.cs.meta b/Assets/UniRx.Async/CompilerServices/MoveNextRunner.cs.meta
new file mode 100644
index 0000000..2cb82e0
--- /dev/null
+++ b/Assets/UniRx.Async/CompilerServices/MoveNextRunner.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 98649642833cabf44a9dc060ce4c84a1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/DiagnosticsExtensions.cs b/Assets/UniRx.Async/DiagnosticsExtensions.cs
new file mode 100644
index 0000000..041b0c3
--- /dev/null
+++ b/Assets/UniRx.Async/DiagnosticsExtensions.cs
@@ -0,0 +1,270 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Security;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+
+namespace UniRx.Async
+{
+    public static class DiagnosticsExtensions
+    {
+        static bool displayFilenames = true;
+
+        static readonly Regex typeBeautifyRegex = new Regex("`.+$", RegexOptions.Compiled);
+
+        static readonly Dictionary<Type, string> builtInTypeNames = new Dictionary<Type, string>
+        {
+            { typeof(void), "void" },
+            { typeof(bool), "bool" },
+            { typeof(byte), "byte" },
+            { typeof(char), "char" },
+            { typeof(decimal), "decimal" },
+            { typeof(double), "double" },
+            { typeof(float), "float" },
+            { typeof(int), "int" },
+            { typeof(long), "long" },
+            { typeof(object), "object" },
+            { typeof(sbyte), "sbyte" },
+            { typeof(short), "short" },
+            { typeof(string), "string" },
+            { typeof(uint), "uint" },
+            { typeof(ulong), "ulong" },
+            { typeof(ushort), "ushort" },
+            { typeof(Task), "Task" },
+            { typeof(UniTask), "UniTask" },
+            { typeof(UniTaskVoid), "UniTaskVoid" }
+        };
+
+        public static string ToStringWithCleanupAsyncStackTrace(this Exception exception)
+        {
+            if (exception == null) return "";
+
+            String message = exception.Message;
+            String s;
+
+            if (message == null || message.Length <= 0)
+            {
+                s = exception.GetType().ToString();
+            }
+            else
+            {
+                s = exception.GetType().ToString() + ": " + message;
+            }
+
+            if (exception.InnerException != null)
+            {
+                s = s + " ---> " + exception.InnerException.ToString() + Environment.NewLine + "   Exception_EndOfInnerExceptionStack";
+            }
+
+            string stackTrace = new StackTrace(exception).CleanupAsyncStackTrace();
+            if (stackTrace != null)
+            {
+                s += Environment.NewLine + stackTrace;
+            }
+
+            return s;
+        }
+
+        public static string CleanupAsyncStackTrace(this StackTrace stackTrace)
+        {
+            if (stackTrace == null) return "";
+
+            var sb = new StringBuilder();
+            for (int i = 0; i < stackTrace.FrameCount; i++)
+            {
+                var sf = stackTrace.GetFrame(i);
+
+                var mb = sf.GetMethod();
+
+                if (IgnoreLine(mb)) continue;
+                if (IsAsync(mb))
+                {
+                    sb.Append("async ");
+                    TryResolveStateMachineMethod(ref mb, out var decType);
+                }
+
+                // return type
+                if (mb is MethodInfo mi)
+                {
+                    sb.Append(BeautifyType(mi.ReturnType, false));
+                    sb.Append(" ");
+                }
+
+                // method name
+                sb.Append(BeautifyType(mb.DeclaringType, false));
+                if (!mb.IsConstructor)
+                {
+                    sb.Append(".");
+                }
+                sb.Append(mb.Name);
+                if (mb.IsGenericMethod)
+                {
+                    sb.Append("<");
+                    foreach (var item in mb.GetGenericArguments())
+                    {
+                        sb.Append(BeautifyType(item, true));
+                    }
+                    sb.Append(">");
+                }
+
+                // parameter
+                sb.Append("(");
+                sb.Append(string.Join(", ", mb.GetParameters().Select(p => BeautifyType(p.ParameterType, true) + " " + p.Name)));
+                sb.Append(")");
+
+                // file name
+                if (displayFilenames && (sf.GetILOffset() != -1))
+                {
+                    String fileName = null;
+
+                    try
+                    {
+                        fileName = sf.GetFileName();
+                    }
+                    catch (NotSupportedException)
+                    {
+                        displayFilenames = false;
+                    }
+                    catch (SecurityException)
+                    {
+                        displayFilenames = false;
+                    }
+
+                    if (fileName != null)
+                    {
+                        sb.Append(' ');
+                        sb.AppendFormat(CultureInfo.InvariantCulture, "in {0}:{1}", SimplifyPath(fileName), sf.GetFileLineNumber());
+                    }
+                }
+
+                sb.AppendLine();
+            }
+            return sb.ToString();
+        }
+
+
+        static bool IsAsync(MethodBase methodInfo)
+        {
+            var declareType = methodInfo.DeclaringType;
+            return typeof(IAsyncStateMachine).IsAssignableFrom(declareType);
+        }
+
+        // code from Ben.Demystifier/EnhancedStackTrace.Frame.cs
+        static bool TryResolveStateMachineMethod(ref MethodBase method, out Type declaringType)
+        {
+            declaringType = method.DeclaringType;
+
+            var parentType = declaringType.DeclaringType;
+            if (parentType == null)
+            {
+                return false;
+            }
+
+            var methods = parentType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly);
+            if (methods == null)
+            {
+                return false;
+            }
+
+            foreach (var candidateMethod in methods)
+            {
+                var attributes = candidateMethod.GetCustomAttributes<StateMachineAttribute>();
+                if (attributes == null)
+                {
+                    continue;
+                }
+
+                foreach (var asma in attributes)
+                {
+                    if (asma.StateMachineType == declaringType)
+                    {
+                        method = candidateMethod;
+                        declaringType = candidateMethod.DeclaringType;
+                        // Mark the iterator as changed; so it gets the + annotation of the original method
+                        // async statemachines resolve directly to their builder methods so aren't marked as changed
+                        return asma is IteratorStateMachineAttribute;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        static string BeautifyType(Type t, bool shortName)
+        {
+            if (builtInTypeNames.TryGetValue(t, out var builtin))
+            {
+                return builtin;
+            }
+            if (t.IsGenericParameter) return t.Name;
+            if (t.IsArray) return BeautifyType(t.GetElementType(), shortName) + "[]";
+            if (t.FullName?.StartsWith("System.ValueTuple") ?? false)
+            {
+                return "(" + string.Join(", ", t.GetGenericArguments().Select(x => BeautifyType(x, true))) + ")";
+            }
+            if (!t.IsGenericType) return shortName ? t.Name : t.FullName ?? t.Name;
+
+            var innerFormat = string.Join(", ", t.GetGenericArguments().Select(x => BeautifyType(x, true)));
+
+            var genericType = t.GetGenericTypeDefinition().FullName;
+            if (genericType == "System.Threading.Tasks.Task`1")
+            {
+                genericType = "Task";
+            }
+
+            return typeBeautifyRegex.Replace(genericType, "") + "<" + innerFormat + ">";
+        }
+
+        static bool IgnoreLine(MethodBase methodInfo)
+        {
+            var declareType = methodInfo.DeclaringType.FullName;
+            if (declareType == "System.Threading.ExecutionContext")
+            {
+                return true;
+            }
+            else if (declareType.StartsWith("System.Runtime.CompilerServices"))
+            {
+                return true;
+            }
+            else if (declareType.StartsWith("UniRx.Async.CompilerServices"))
+            {
+                return true;
+            }
+            else if (declareType == "System.Threading.Tasks.AwaitTaskContinuation")
+            {
+                return true;
+            }
+            else if (declareType.StartsWith("System.Threading.Tasks.Task"))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        static string SimplifyPath(string path)
+        {
+            var fi = new FileInfo(path);
+            if (fi.Directory == null)
+            {
+                return fi.Name;
+            }
+            else
+            {
+                return fi.Directory.Name + "/" + fi.Name;
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/DiagnosticsExtensions.cs.meta b/Assets/UniRx.Async/DiagnosticsExtensions.cs.meta
new file mode 100644
index 0000000..6c1f06c
--- /dev/null
+++ b/Assets/UniRx.Async/DiagnosticsExtensions.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f80fb1c9ed4c99447be1b0a47a8d980b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Editor.meta b/Assets/UniRx.Async/Editor.meta
new file mode 100644
index 0000000..c0746ba
--- /dev/null
+++ b/Assets/UniRx.Async/Editor.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 275b87293edc6634f9d72387851dbbdf
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Editor/SplitterGUILayout.cs b/Assets/UniRx.Async/Editor/SplitterGUILayout.cs
new file mode 100644
index 0000000..bca6a95
--- /dev/null
+++ b/Assets/UniRx.Async/Editor/SplitterGUILayout.cs
@@ -0,0 +1,64 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Linq;
+using System.Reflection;
+using UnityEditor;
+using UnityEngine;
+
+namespace UniRx.Async.Editor
+{
+    // reflection call of UnityEditor.SplitterGUILayout
+    internal static class SplitterGUILayout
+    {
+        static BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static;
+
+        static Lazy<Type> splitterStateType = new Lazy<Type>(() =>
+        {
+            var type = typeof(EditorWindow).Assembly.GetTypes().First(x => x.FullName == "UnityEditor.SplitterState");
+            return type;
+        });
+
+        static Lazy<ConstructorInfo> splitterStateCtor = new Lazy<ConstructorInfo>(() =>
+        {
+            var type = splitterStateType.Value;
+            return type.GetConstructor(flags, null, new Type[] { typeof(float[]), typeof(int[]), typeof(int[]) }, null);
+        });
+
+        static Lazy<Type> splitterGUILayoutType = new Lazy<Type>(() =>
+        {
+            var type = typeof(EditorWindow).Assembly.GetTypes().First(x => x.FullName == "UnityEditor.SplitterGUILayout");
+            return type;
+        });
+
+        static Lazy<MethodInfo> beginVerticalSplit = new Lazy<MethodInfo>(() =>
+        {
+            var type = splitterGUILayoutType.Value;
+            return type.GetMethod("BeginVerticalSplit", flags, null, new Type[] { splitterStateType.Value, typeof(GUILayoutOption[]) }, null);
+        });
+
+        static Lazy<MethodInfo> endVerticalSplit = new Lazy<MethodInfo>(() =>
+        {
+            var type = splitterGUILayoutType.Value;
+            return type.GetMethod("EndVerticalSplit", flags, null, Type.EmptyTypes, null);
+        });
+
+        public static object CreateSplitterState(float[] relativeSizes, int[] minSizes, int[] maxSizes)
+        {
+            return splitterStateCtor.Value.Invoke(new object[] { relativeSizes, minSizes, maxSizes });
+        }
+
+        public static void BeginVerticalSplit(object splitterState, params GUILayoutOption[] options)
+        {
+            beginVerticalSplit.Value.Invoke(null, new object[] { splitterState, options });
+        }
+
+        public static void EndVerticalSplit()
+        {
+            endVerticalSplit.Value.Invoke(null, Type.EmptyTypes);
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/Editor/SplitterGUILayout.cs.meta b/Assets/UniRx.Async/Editor/SplitterGUILayout.cs.meta
new file mode 100644
index 0000000..4d718f4
--- /dev/null
+++ b/Assets/UniRx.Async/Editor/SplitterGUILayout.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 40ef2e46f900131419e869398a8d3c9d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Editor/UniRx.Async.Editor.asmdef b/Assets/UniRx.Async/Editor/UniRx.Async.Editor.asmdef
new file mode 100644
index 0000000..429ba80
--- /dev/null
+++ b/Assets/UniRx.Async/Editor/UniRx.Async.Editor.asmdef
@@ -0,0 +1,16 @@
+{
+    "name": "UniRx.Async.Editor",
+    "references": [
+        "GUID:f51ebe6a0ceec4240a699833d6309b23"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": []
+}
\ No newline at end of file
diff --git a/Assets/UniRx.Async/Editor/UniRx.Async.Editor.asmdef.meta b/Assets/UniRx.Async/Editor/UniRx.Async.Editor.asmdef.meta
new file mode 100644
index 0000000..821b87b
--- /dev/null
+++ b/Assets/UniRx.Async/Editor/UniRx.Async.Editor.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 4129704b5a1a13841ba16f230bf24a57
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Editor/UniTaskTrackerTreeView.cs b/Assets/UniRx.Async/Editor/UniTaskTrackerTreeView.cs
new file mode 100644
index 0000000..7e03931
--- /dev/null
+++ b/Assets/UniRx.Async/Editor/UniTaskTrackerTreeView.cs
@@ -0,0 +1,180 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using UnityEngine;
+using UnityEditor;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System;
+using UnityEditor.IMGUI.Controls;
+using UniRx.Async.Internal;
+using System.Text;
+
+namespace UniRx.Async.Editor
+{
+    public class UniTaskTrackerViewItem : TreeViewItem
+    {
+        public string TaskType { get; set; }
+        public string Elapsed { get; set; }
+        public string Status { get; set; }
+
+        string position;
+        public string Position
+        {
+            get { return position; }
+            set
+            {
+                position = value;
+                PositionFirstLine = GetFirstLine(position);
+            }
+        }
+
+        public string PositionFirstLine { get; private set; }
+
+        static string GetFirstLine(string str)
+        {
+            var sb = new StringBuilder();
+            for (int i = 0; i < str.Length; i++)
+            {
+                if (str[i] == '\r' || str[i] == '\n')
+                {
+                    break;
+                }
+                sb.Append(str[i]);
+            }
+            return sb.ToString();
+        }
+
+        public UniTaskTrackerViewItem(int id) : base(id)
+        {
+
+        }
+    }
+
+    public class UniTaskTrackerTreeView : TreeView
+    {
+        const string sortedColumnIndexStateKey = "UniTaskTrackerTreeView_sortedColumnIndex";
+
+        public IReadOnlyList<TreeViewItem> CurrentBindingItems;
+
+        public UniTaskTrackerTreeView()
+            : this(new TreeViewState(), new MultiColumnHeader(new MultiColumnHeaderState(new[]
+            {
+                new MultiColumnHeaderState.Column() { headerContent = new GUIContent("TaskType"), width = 20},
+                new MultiColumnHeaderState.Column() { headerContent = new GUIContent("Elapsed"), width = 10},
+                new MultiColumnHeaderState.Column() { headerContent = new GUIContent("Status"), width = 10},
+                new MultiColumnHeaderState.Column() { headerContent = new GUIContent("Position")},
+            })))
+        {
+        }
+
+        UniTaskTrackerTreeView(TreeViewState state, MultiColumnHeader header)
+            : base(state, header)
+        {
+            rowHeight = 20;
+            showAlternatingRowBackgrounds = true;
+            showBorder = true;
+            header.sortingChanged += Header_sortingChanged;
+
+            header.ResizeToFit();
+            Reload();
+
+            header.sortedColumnIndex = SessionState.GetInt(sortedColumnIndexStateKey, 1);
+        }
+
+        public void ReloadAndSort()
+        {
+            var currentSelected = this.state.selectedIDs;
+            Reload();
+            Header_sortingChanged(this.multiColumnHeader);
+            this.state.selectedIDs = currentSelected;
+        }
+
+        private void Header_sortingChanged(MultiColumnHeader multiColumnHeader)
+        {
+            SessionState.SetInt(sortedColumnIndexStateKey, multiColumnHeader.sortedColumnIndex);
+            var index = multiColumnHeader.sortedColumnIndex;
+            var ascending = multiColumnHeader.IsSortedAscending(multiColumnHeader.sortedColumnIndex);
+
+            var items = rootItem.children.Cast<UniTaskTrackerViewItem>();
+
+            IOrderedEnumerable<UniTaskTrackerViewItem> orderedEnumerable;
+            switch (index)
+            {
+                case 0:
+                    orderedEnumerable = ascending ? items.OrderBy(item => item.TaskType) : items.OrderByDescending(item => item.TaskType);
+                    break;
+                case 1:
+                    orderedEnumerable = ascending ? items.OrderBy(item => double.Parse(item.Elapsed)) : items.OrderByDescending(item => double.Parse(item.Elapsed));
+                    break;
+                case 2:
+                    orderedEnumerable = ascending ? items.OrderBy(item => item.Status) : items.OrderByDescending(item => item.Elapsed);
+                    break;
+                case 3:
+                    orderedEnumerable = ascending ? items.OrderBy(item => item.Position) : items.OrderByDescending(item => item.PositionFirstLine);
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(index), index, null);
+            }
+
+            CurrentBindingItems = rootItem.children = orderedEnumerable.Cast<TreeViewItem>().ToList();
+            BuildRows(rootItem);
+        }
+
+        protected override TreeViewItem BuildRoot()
+        {
+            var root = new TreeViewItem { depth = -1 };
+
+            var children = new List<TreeViewItem>();
+
+            TaskTracker.ForEachActiveTask((trackingId, awaiterType, status, created, stackTrace) =>
+            {
+                children.Add(new UniTaskTrackerViewItem(trackingId) { TaskType = awaiterType, Status = status.ToString(), Elapsed = (DateTime.UtcNow - created).TotalSeconds.ToString("00.00"), Position = stackTrace });
+            });
+
+            CurrentBindingItems = children;
+            root.children = CurrentBindingItems as List<TreeViewItem>;
+            return root;
+        }
+
+        protected override bool CanMultiSelect(TreeViewItem item)
+        {
+            return false;
+        }
+
+        protected override void RowGUI(RowGUIArgs args)
+        {
+            var item = args.item as UniTaskTrackerViewItem;
+
+            for (var visibleColumnIndex = 0; visibleColumnIndex < args.GetNumVisibleColumns(); visibleColumnIndex++)
+            {
+                var rect = args.GetCellRect(visibleColumnIndex);
+                var columnIndex = args.GetColumn(visibleColumnIndex);
+
+                var labelStyle = args.selected ? EditorStyles.whiteLabel : EditorStyles.label;
+                labelStyle.alignment = TextAnchor.MiddleLeft;
+                switch (columnIndex)
+                {
+                    case 0:
+                        EditorGUI.LabelField(rect, item.TaskType, labelStyle);
+                        break;
+                    case 1:
+                        EditorGUI.LabelField(rect, item.Elapsed, labelStyle);
+                        break;
+                    case 2:
+                        EditorGUI.LabelField(rect, item.Status, labelStyle);
+                        break;
+                    case 3:
+                        EditorGUI.LabelField(rect, item.PositionFirstLine, labelStyle);
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException(nameof(columnIndex), columnIndex, null);
+                }
+            }
+        }
+    }
+
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/Editor/UniTaskTrackerTreeView.cs.meta b/Assets/UniRx.Async/Editor/UniTaskTrackerTreeView.cs.meta
new file mode 100644
index 0000000..9b34d7b
--- /dev/null
+++ b/Assets/UniRx.Async/Editor/UniTaskTrackerTreeView.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 52e2d973a2156674e8c1c9433ed031f7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Editor/UniTaskTrackerWindow.cs b/Assets/UniRx.Async/Editor/UniTaskTrackerWindow.cs
new file mode 100644
index 0000000..5acb2c4
--- /dev/null
+++ b/Assets/UniRx.Async/Editor/UniTaskTrackerWindow.cs
@@ -0,0 +1,211 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using UnityEngine;
+using UnityEditor;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System;
+using UnityEditor.IMGUI.Controls;
+using UniRx.Async.Internal;
+
+namespace UniRx.Async.Editor
+{
+    public class UniTaskTrackerWindow : EditorWindow
+    {
+        static int interval;
+
+        static UniTaskTrackerWindow window;
+
+        [MenuItem("Window/UniRx/UniTask Tracker")]
+        public static void OpenWindow()
+        {
+            if (window != null)
+            {
+                window.Close();
+            }
+
+            // will called OnEnable(singleton instance will be set).
+            GetWindow<UniTaskTrackerWindow>("UniTask Tracker").Show();
+        }
+
+        static readonly GUILayoutOption[] EmptyLayoutOption = new GUILayoutOption[0];
+
+        UniTaskTrackerTreeView treeView;
+        object splitterState;
+
+        void OnEnable()
+        {
+            window = this; // set singleton.
+            splitterState = SplitterGUILayout.CreateSplitterState(new float[] { 75f, 25f }, new int[] { 32, 32 }, null);
+            treeView = new UniTaskTrackerTreeView();
+            TaskTracker.EditorEnableState.EnableAutoReload = EditorPrefs.GetBool(TaskTracker.EnableAutoReloadKey, false);
+            TaskTracker.EditorEnableState.EnableTracking = EditorPrefs.GetBool(TaskTracker.EnableTrackingKey, false);
+            TaskTracker.EditorEnableState.EnableStackTrace = EditorPrefs.GetBool(TaskTracker.EnableStackTraceKey, false);
+        }
+
+        void OnGUI()
+        {
+            // Head
+            RenderHeadPanel();
+
+            // Splittable
+            SplitterGUILayout.BeginVerticalSplit(this.splitterState, EmptyLayoutOption);
+            {
+                // Column Tabble
+                RenderTable();
+
+                // StackTrace details
+                RenderDetailsPanel();
+            }
+            SplitterGUILayout.EndVerticalSplit();
+        }
+
+        #region HeadPanel
+
+        public static bool EnableAutoReload => TaskTracker.EditorEnableState.EnableAutoReload;
+        public static bool EnableTracking => TaskTracker.EditorEnableState.EnableTracking;
+        public static bool EnableStackTrace => TaskTracker.EditorEnableState.EnableStackTrace;
+        static readonly GUIContent EnableAutoReloadHeadContent = EditorGUIUtility.TrTextContent("Enable AutoReload", "Reload automatically.", (Texture)null);
+        static readonly GUIContent ReloadHeadContent = EditorGUIUtility.TrTextContent("Reload", "Reload View.", (Texture)null);
+        static readonly GUIContent GCHeadContent = EditorGUIUtility.TrTextContent("GC.Collect", "Invoke GC.Collect.", (Texture)null);
+        static readonly GUIContent EnableTrackingHeadContent = EditorGUIUtility.TrTextContent("Enable Tracking", "Start to track async/await UniTask. Performance impact: low", (Texture)null);
+        static readonly GUIContent EnableStackTraceHeadContent = EditorGUIUtility.TrTextContent("Enable StackTrace", "Capture StackTrace when task is started. Performance impact: high", (Texture)null);
+
+        // [Enable Tracking] | [Enable StackTrace]
+        void RenderHeadPanel()
+        {
+            EditorGUILayout.BeginVertical(EmptyLayoutOption);
+            EditorGUILayout.BeginHorizontal(EditorStyles.toolbar, EmptyLayoutOption);
+
+            if (GUILayout.Toggle(EnableAutoReload, EnableAutoReloadHeadContent, EditorStyles.toolbarButton, EmptyLayoutOption) != EnableAutoReload)
+            {
+                TaskTracker.EditorEnableState.EnableAutoReload = !EnableAutoReload;
+            }
+
+            if (GUILayout.Toggle(EnableTracking, EnableTrackingHeadContent, EditorStyles.toolbarButton, EmptyLayoutOption) != EnableTracking)
+            {
+                TaskTracker.EditorEnableState.EnableTracking = !EnableTracking;
+            }
+
+            if (GUILayout.Toggle(EnableStackTrace, EnableStackTraceHeadContent, EditorStyles.toolbarButton, EmptyLayoutOption) != EnableStackTrace)
+            {
+                TaskTracker.EditorEnableState.EnableStackTrace = !EnableStackTrace;
+            }
+
+            GUILayout.FlexibleSpace();
+
+            if (GUILayout.Button(ReloadHeadContent, EditorStyles.toolbarButton, EmptyLayoutOption))
+            {
+                TaskTracker.CheckAndResetDirty();
+                treeView.ReloadAndSort();
+                Repaint();
+            }
+
+            if (GUILayout.Button(GCHeadContent, EditorStyles.toolbarButton, EmptyLayoutOption))
+            {
+                GC.Collect(0);
+            }
+
+            EditorGUILayout.EndHorizontal();
+            EditorGUILayout.EndVertical();
+        }
+
+        #endregion
+
+        #region TableColumn
+
+        Vector2 tableScroll;
+        GUIStyle tableListStyle;
+
+        void RenderTable()
+        {
+            if (tableListStyle == null)
+            {
+                tableListStyle = new GUIStyle("CN Box");
+                tableListStyle.margin.top = 0;
+                tableListStyle.padding.left = 3;
+            }
+
+            EditorGUILayout.BeginVertical(tableListStyle, EmptyLayoutOption);
+
+            this.tableScroll = EditorGUILayout.BeginScrollView(this.tableScroll, new GUILayoutOption[]
+            {
+                GUILayout.ExpandWidth(true),
+                GUILayout.MaxWidth(2000f)
+            });
+            var controlRect = EditorGUILayout.GetControlRect(new GUILayoutOption[]
+            {
+                GUILayout.ExpandHeight(true),
+                GUILayout.ExpandWidth(true)
+            });
+
+
+            treeView?.OnGUI(controlRect);
+
+            EditorGUILayout.EndScrollView();
+            EditorGUILayout.EndVertical();
+        }
+
+        private void Update()
+        {
+            if (EnableAutoReload)
+            {
+                if (interval++ % 120 == 0)
+                {
+                    if (TaskTracker.CheckAndResetDirty())
+                    {
+                        treeView.ReloadAndSort();
+                        Repaint();
+                    }
+                }
+            }
+        }
+
+        #endregion
+
+        #region Details
+
+        static GUIStyle detailsStyle;
+        Vector2 detailsScroll;
+
+        void RenderDetailsPanel()
+        {
+            if (detailsStyle == null)
+            {
+                detailsStyle = new GUIStyle(EditorStyles.wordWrappedLabel);
+                detailsStyle.wordWrap = false;
+                detailsStyle.stretchHeight = true;
+                detailsStyle.margin.right = 15;
+            }
+
+            string message = "";
+            var selected = treeView.state.selectedIDs;
+            if (selected.Count > 0)
+            {
+                var first = selected[0];
+                var item = treeView.CurrentBindingItems.FirstOrDefault(x => x.id == first) as UniTaskTrackerViewItem;
+                if (item != null)
+                {
+                    message = item.Position;
+                }
+            }
+
+            detailsScroll = EditorGUILayout.BeginScrollView(this.detailsScroll, EmptyLayoutOption);
+            var vector = detailsStyle.CalcSize(new GUIContent(message));
+            EditorGUILayout.SelectableLabel(message, detailsStyle, new GUILayoutOption[]
+            {
+                GUILayout.ExpandHeight(true),
+                GUILayout.ExpandWidth(true),
+                GUILayout.MinWidth(vector.x),
+                GUILayout.MinHeight(vector.y)
+            });
+            EditorGUILayout.EndScrollView();
+        }
+
+        #endregion
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/Editor/UniTaskTrackerWindow.cs.meta b/Assets/UniRx.Async/Editor/UniTaskTrackerWindow.cs.meta
new file mode 100644
index 0000000..ba1b704
--- /dev/null
+++ b/Assets/UniRx.Async/Editor/UniTaskTrackerWindow.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5bee3e3860e37484aa3b861bf76d129f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/EnumerableAsyncExtensions.cs b/Assets/UniRx.Async/EnumerableAsyncExtensions.cs
new file mode 100644
index 0000000..344ccc4
--- /dev/null
+++ b/Assets/UniRx.Async/EnumerableAsyncExtensions.cs
@@ -0,0 +1,36 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Collections.Generic;
+
+namespace UniRx.Async
+{
+    public static class EnumerableAsyncExtensions
+    {
+        // overload resolver - .Select(async x => { }) : IEnumerable<UniTask<T>>
+
+        public static IEnumerable<UniTask> Select<T>(this IEnumerable<T> source, Func<T, UniTask> selector)
+        {
+            return System.Linq.Enumerable.Select(source, selector);
+        }
+
+        public static IEnumerable<UniTask<TR>> Select<T, TR>(this IEnumerable<T> source, Func<T, UniTask<TR>> selector)
+        {
+            return System.Linq.Enumerable.Select(source, selector);
+        }
+
+        public static IEnumerable<UniTask> Select<T>(this IEnumerable<T> source, Func<T, int, UniTask> selector)
+        {
+            return System.Linq.Enumerable.Select(source, selector);
+        }
+
+        public static IEnumerable<UniTask<TR>> Select<T, TR>(this IEnumerable<T> source, Func<T, int, UniTask<TR>> selector)
+        {
+            return System.Linq.Enumerable.Select(source, selector);
+        }
+    }
+}
+
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/EnumerableAsyncExtensions.cs.meta b/Assets/UniRx.Async/EnumerableAsyncExtensions.cs.meta
new file mode 100644
index 0000000..d2e4930
--- /dev/null
+++ b/Assets/UniRx.Async/EnumerableAsyncExtensions.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ff50260d74bd54c4b92cf99895549445
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/EnumeratorAsyncExtensions.cs b/Assets/UniRx.Async/EnumeratorAsyncExtensions.cs
new file mode 100644
index 0000000..5f3411e
--- /dev/null
+++ b/Assets/UniRx.Async/EnumeratorAsyncExtensions.cs
@@ -0,0 +1,149 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Collections;
+using System.Runtime.ExceptionServices;
+using System.Threading;
+using UniRx.Async.Internal;
+
+namespace UniRx.Async
+{
+    public static class EnumeratorAsyncExtensions
+    {
+        public static IAwaiter GetAwaiter(this IEnumerator enumerator)
+        {
+            var awaiter = new EnumeratorAwaiter(enumerator, CancellationToken.None);
+            if (!awaiter.IsCompleted)
+            {
+                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, awaiter);
+            }
+            return awaiter;
+        }
+
+        public static UniTask ToUniTask(this IEnumerator enumerator)
+        {
+            var awaiter = new EnumeratorAwaiter(enumerator, CancellationToken.None);
+            if (!awaiter.IsCompleted)
+            {
+                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, awaiter);
+            }
+            return new UniTask(awaiter);
+        }
+
+        public static UniTask ConfigureAwait(this IEnumerator enumerator, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            var awaiter = new EnumeratorAwaiter(enumerator, cancellationToken);
+            if (!awaiter.IsCompleted)
+            {
+                PlayerLoopHelper.AddAction(timing, awaiter);
+            }
+            return new UniTask(awaiter);
+        }
+
+        class EnumeratorAwaiter : IAwaiter, IPlayerLoopItem
+        {
+            IEnumerator innerEnumerator;
+            CancellationToken cancellationToken;
+            Action continuation;
+            AwaiterStatus status;
+            ExceptionDispatchInfo exception;
+
+            public EnumeratorAwaiter(IEnumerator innerEnumerator, CancellationToken cancellationToken)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    status = AwaiterStatus.Canceled;
+                    return;
+                }
+
+                this.innerEnumerator = innerEnumerator;
+                this.status = AwaiterStatus.Pending;
+                this.cancellationToken = cancellationToken;
+                this.continuation = null;
+
+                TaskTracker.TrackActiveTask(this, 2);
+            }
+
+            public bool IsCompleted => status.IsCompleted();
+
+            public AwaiterStatus Status => status;
+
+            public void GetResult()
+            {
+                switch (status)
+                {
+                    case AwaiterStatus.Succeeded:
+                        break;
+                    case AwaiterStatus.Pending:
+                        Error.ThrowNotYetCompleted();
+                        break;
+                    case AwaiterStatus.Faulted:
+                        exception.Throw();
+                        break;
+                    case AwaiterStatus.Canceled:
+                        Error.ThrowOperationCanceledException();
+                        break;
+                    default:
+                        break;
+                }
+            }
+
+            public bool MoveNext()
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    InvokeContinuation(AwaiterStatus.Canceled);
+                    return false;
+                }
+
+                var success = false;
+                try
+                {
+                    if (innerEnumerator.MoveNext())
+                    {
+                        return true;
+                    }
+                    else
+                    {
+                        success = true;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                }
+
+                InvokeContinuation(success ? AwaiterStatus.Succeeded : AwaiterStatus.Faulted);
+                return false;
+            }
+
+            void InvokeContinuation(AwaiterStatus status)
+            {
+                this.status = status;
+                var cont = this.continuation;
+
+                // cleanup
+                TaskTracker.RemoveTracking(this);
+                this.continuation = null;
+                this.cancellationToken = CancellationToken.None;
+                this.innerEnumerator = null;
+
+                if (cont != null) cont.Invoke();
+            }
+
+            public void OnCompleted(Action continuation)
+            {
+                UnsafeOnCompleted(continuation);
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                Error.ThrowWhenContinuationIsAlreadyRegistered(this.continuation);
+                this.continuation = continuation;
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/EnumeratorAsyncExtensions.cs.meta b/Assets/UniRx.Async/EnumeratorAsyncExtensions.cs.meta
new file mode 100644
index 0000000..a07b336
--- /dev/null
+++ b/Assets/UniRx.Async/EnumeratorAsyncExtensions.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bc661232f11e4a741af54ba1c175d5ee
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/ExceptionExtensions.cs b/Assets/UniRx.Async/ExceptionExtensions.cs
new file mode 100644
index 0000000..eb7d071
--- /dev/null
+++ b/Assets/UniRx.Async/ExceptionExtensions.cs
@@ -0,0 +1,16 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+
+using System;
+
+namespace UniRx.Async
+{
+    public static class ExceptionExtensions
+    {
+        public static bool IsOperationCanceledException(this Exception exception)
+        {
+            return exception is OperationCanceledException;
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/ExceptionExtensions.cs.meta b/Assets/UniRx.Async/ExceptionExtensions.cs.meta
new file mode 100644
index 0000000..9833001
--- /dev/null
+++ b/Assets/UniRx.Async/ExceptionExtensions.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 930800098504c0d46958ce23a0495202
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/IAwaiter.cs b/Assets/UniRx.Async/IAwaiter.cs
new file mode 100644
index 0000000..6450ea5
--- /dev/null
+++ b/Assets/UniRx.Async/IAwaiter.cs
@@ -0,0 +1,64 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591
+
+using System.Runtime.CompilerServices;
+
+namespace UniRx.Async
+{
+    public enum AwaiterStatus
+    {
+        /// <summary>The operation has not yet completed.</summary>
+        Pending = 0,
+        /// <summary>The operation completed successfully.</summary>
+        Succeeded = 1,
+        /// <summary>The operation completed with an error.</summary>
+        Faulted = 2,
+        /// <summary>The operation completed due to cancellation.</summary>
+        Canceled = 3
+    }
+
+    public interface IAwaiter : ICriticalNotifyCompletion
+    {
+        AwaiterStatus Status { get; }
+        bool IsCompleted { get; }
+        void GetResult();
+    }
+
+    public interface IAwaiter<out T> : IAwaiter
+    {
+        new T GetResult();
+    }
+
+    public static class AwaiterStatusExtensions
+    {
+        /// <summary>!= Pending.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool IsCompleted(this AwaiterStatus status)
+        {
+            return status != AwaiterStatus.Pending;
+        }
+
+        /// <summary>== Succeeded.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool IsCompletedSuccessfully(this AwaiterStatus status)
+        {
+            return status == AwaiterStatus.Succeeded;
+        }
+
+        /// <summary>== Canceled.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool IsCanceled(this AwaiterStatus status)
+        {
+            return status == AwaiterStatus.Canceled;
+        }
+
+        /// <summary>== Faulted.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool IsFaulted(this AwaiterStatus status)
+        {
+            return status == AwaiterStatus.Faulted;
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/IAwaiter.cs.meta b/Assets/UniRx.Async/IAwaiter.cs.meta
new file mode 100644
index 0000000..b225d1c
--- /dev/null
+++ b/Assets/UniRx.Async/IAwaiter.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3e4d023d8404ab742b5e808c98097c3c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Internal.meta b/Assets/UniRx.Async/Internal.meta
new file mode 100644
index 0000000..7ac2b17
--- /dev/null
+++ b/Assets/UniRx.Async/Internal.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 633f49a8aafb6fa43894cd4646c71743
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Internal/ArrayPool.cs b/Assets/UniRx.Async/Internal/ArrayPool.cs
new file mode 100644
index 0000000..5f7907b
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/ArrayPool.cs
@@ -0,0 +1,152 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Threading;
+
+namespace UniRx.Async.Internal
+{
+    // Same interface as System.Buffers.ArrayPool<T> but only provides Shared.
+
+    internal sealed class ArrayPool<T>
+    {
+        // Same size as System.Buffers.DefaultArrayPool<T>
+        const int DefaultMaxNumberOfArraysPerBucket = 50;
+
+        static readonly T[] EmptyArray = new T[0];
+
+        public static readonly ArrayPool<T> Shared = new ArrayPool<T>();
+
+        readonly MinimumQueue<T[]>[] buckets;
+        readonly SpinLock[] locks;
+
+        ArrayPool()
+        {
+            // see: GetQueueIndex
+            buckets = new MinimumQueue<T[]>[18];
+            locks = new SpinLock[18];
+            for (int i = 0; i < buckets.Length; i++)
+            {
+                buckets[i] = new MinimumQueue<T[]>(4);
+                locks[i] = new SpinLock(false);
+            }
+        }
+
+        public T[] Rent(int minimumLength)
+        {
+            if (minimumLength < 0)
+            {
+                throw new ArgumentOutOfRangeException("minimumLength");
+            }
+            else if (minimumLength == 0)
+            {
+                return EmptyArray;
+            }
+
+            var size = CalculateSize(minimumLength);
+            var index = GetQueueIndex(size);
+            if (index != -1)
+            {
+                var q = buckets[index];
+                var lockTaken = false;
+                try
+                {
+                    locks[index].Enter(ref lockTaken);
+
+                    if (q.Count != 0)
+                    {
+                        return q.Dequeue();
+                    }
+                }
+                finally
+                {
+                    if (lockTaken) locks[index].Exit(false);
+                }
+            }
+
+            return new T[size];
+        }
+
+        public void Return(T[] array, bool clearArray = false)
+        {
+            if (array == null || array.Length == 0)
+            {
+                return;
+            }
+
+            var index = GetQueueIndex(array.Length);
+            if (index != -1)
+            {
+                if (clearArray)
+                {
+                    Array.Clear(array, 0, array.Length);
+                }
+
+                var q = buckets[index];
+                var lockTaken = false;
+
+                try
+                {
+                    locks[index].Enter(ref lockTaken);
+
+                    if (q.Count > DefaultMaxNumberOfArraysPerBucket)
+                    {
+                        return;
+                    }
+
+                    q.Enqueue(array);
+                }
+                finally
+                {
+                    if (lockTaken) locks[index].Exit(false);
+                }
+            }
+        }
+
+        static int CalculateSize(int size)
+        {
+            size--;
+            size |= size >> 1;
+            size |= size >> 2;
+            size |= size >> 4;
+            size |= size >> 8;
+            size |= size >> 16;
+            size += 1;
+
+            if (size < 8)
+            {
+                size = 8;
+            }
+
+            return size;
+        }
+
+        static int GetQueueIndex(int size)
+        {
+            switch (size)
+            {
+                case 8: return 0;
+                case 16: return 1;
+                case 32: return 2;
+                case 64: return 3;
+                case 128: return 4;
+                case 256: return 5;
+                case 512: return 6;
+                case 1024: return 7;
+                case 2048: return 8;
+                case 4096: return 9;
+                case 8192: return 10;
+                case 16384: return 11;
+                case 32768: return 12;
+                case 65536: return 13;
+                case 131072: return 14;
+                case 262144: return 15;
+                case 524288: return 16;
+                case 1048576: return 17; // max array length
+                default:
+                    return -1;
+            }
+        }
+    }
+}
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/Internal/ArrayPool.cs.meta b/Assets/UniRx.Async/Internal/ArrayPool.cs.meta
new file mode 100644
index 0000000..693816c
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/ArrayPool.cs.meta
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: f83ebad81fb89fb4882331616ca6d248
+timeCreated: 1532361008
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Internal/ArrayPoolUtil.cs b/Assets/UniRx.Async/Internal/ArrayPoolUtil.cs
new file mode 100644
index 0000000..127bb31
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/ArrayPoolUtil.cs
@@ -0,0 +1,112 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace UniRx.Async.Internal
+{
+    internal static class ArrayPoolUtil
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static void EnsureCapacity<T>(ref T[] array, int index, ArrayPool<T> pool)
+        {
+            if (array.Length <= index)
+            {
+                EnsureCapacityCore(ref array, index, pool);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        static void EnsureCapacityCore<T>(ref T[] array, int index, ArrayPool<T> pool)
+        {
+            if (array.Length <= index)
+            {
+                var newSize = array.Length * 2;
+                var newArray = pool.Rent((index < newSize) ? newSize : (index * 2));
+                Array.Copy(array, 0, newArray, 0, array.Length);
+
+                pool.Return(array, clearArray: !RuntimeHelpersAbstraction.IsWellKnownNoReferenceContainsType<T>());
+
+                array = newArray;
+            }
+        }
+
+        public static RentArray<T> Materialize<T>(IEnumerable<T> source)
+        {
+            if (source is T[] array)
+            {
+                return new RentArray<T>(array, array.Length, null);
+            }
+
+            var defaultCount = 4;
+            if (source is ICollection<T> coll)
+            {
+                defaultCount = coll.Count;
+                var pool = ArrayPool<T>.Shared;
+                var buffer = pool.Rent(defaultCount);
+                coll.CopyTo(buffer, 0);
+                return new RentArray<T>(buffer, coll.Count, pool);
+            }
+            else if (source is IReadOnlyCollection<T> rcoll)
+            {
+                defaultCount = rcoll.Count;
+            }
+
+            if (defaultCount == 0)
+            {
+                return new RentArray<T>(Array.Empty<T>(), 0, null);
+            }
+
+            {
+                var pool = ArrayPool<T>.Shared;
+
+                var index = 0;
+                var buffer = pool.Rent(defaultCount);
+                foreach (var item in source)
+                {
+                    EnsureCapacity(ref buffer, index, pool);
+                    buffer[index++] = item;
+                }
+
+                return new RentArray<T>(buffer, index, pool);
+            }
+        }
+
+        public struct RentArray<T> : IDisposable
+        {
+            public readonly T[] Array;
+            public readonly int Length;
+            ArrayPool<T> pool;
+
+            public RentArray(T[] array, int length, ArrayPool<T> pool)
+            {
+                this.Array = array;
+                this.Length = length;
+                this.pool = pool;
+            }
+
+            public void Dispose()
+            {
+                DisposeManually(!RuntimeHelpersAbstraction.IsWellKnownNoReferenceContainsType<T>());
+            }
+
+            public void DisposeManually(bool clearArray)
+            {
+                if (pool != null)
+                {
+                    if (clearArray)
+                    {
+                        System.Array.Clear(Array, 0, Length);
+                    }
+
+                    pool.Return(Array, clearArray: false);
+                    pool = null;
+                }
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/Internal/ArrayPoolUtil.cs.meta b/Assets/UniRx.Async/Internal/ArrayPoolUtil.cs.meta
new file mode 100644
index 0000000..e06ec65
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/ArrayPoolUtil.cs.meta
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 424cc208fb61d4e448b08fcfa0eee25e
+timeCreated: 1532361007
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Internal/ArrayUtil.cs b/Assets/UniRx.Async/Internal/ArrayUtil.cs
new file mode 100644
index 0000000..33b2df9
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/ArrayUtil.cs
@@ -0,0 +1,75 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace UniRx.Async.Internal
+{
+    internal static class ArrayUtil
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void EnsureCapacity<T>(ref T[] array, int index)
+        {
+            if (array.Length <= index)
+            {
+                EnsureCore(ref array, index);
+            }
+        }
+
+        // rare case, no inlining.
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        static void EnsureCore<T>(ref T[] array, int index)
+        {
+            var newSize = array.Length * 2;
+            var newArray = new T[(index < newSize) ? newSize : (index * 2)];
+            Array.Copy(array, 0, newArray, 0, array.Length);
+
+            array = newArray;
+        }
+
+        /// <summary>
+        /// Optimizing utility to avoid .ToArray() that creates buffer copy(cut to just size).
+        /// </summary>
+        public static (T[] array, int length) Materialize<T>(IEnumerable<T> source)
+        {
+            if (source is T[] array)
+            {
+                return (array, array.Length);
+            }
+
+            var defaultCount = 4;
+            if (source is ICollection<T> coll)
+            {
+                defaultCount = coll.Count;
+                var buffer = new T[defaultCount];
+                coll.CopyTo(buffer, 0);
+                return (buffer, defaultCount);
+            }
+            else if (source is IReadOnlyCollection<T> rcoll)
+            {
+                defaultCount = rcoll.Count;
+            }
+
+            if (defaultCount == 0)
+            {
+                return (Array.Empty<T>(), 0);
+            }
+
+            {
+                var index = 0;
+                var buffer = new T[defaultCount];
+                foreach (var item in source)
+                {
+                    EnsureCapacity(ref buffer, index);
+                    buffer[index++] = item;
+                }
+
+                return (buffer, index);
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/Internal/ArrayUtil.cs.meta b/Assets/UniRx.Async/Internal/ArrayUtil.cs.meta
new file mode 100644
index 0000000..645fc4e
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/ArrayUtil.cs.meta
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 23146a82ec99f2542a87971c8d3d7988
+timeCreated: 1532361007
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Internal/CancellationTokenHelper.cs b/Assets/UniRx.Async/Internal/CancellationTokenHelper.cs
new file mode 100644
index 0000000..26bad0f
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/CancellationTokenHelper.cs
@@ -0,0 +1,32 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Threading;
+
+namespace UniRx.Async.Internal
+{
+    internal static class CancellationTokenHelper
+    {
+        public static bool TrySetOrLinkCancellationToken(ref CancellationToken field, CancellationToken newCancellationToken)
+        {
+            if (newCancellationToken == CancellationToken.None)
+            {
+                return false;
+            }
+            else if (field == CancellationToken.None)
+            {
+                field = newCancellationToken;
+                return true;
+            }
+            else if (field == newCancellationToken)
+            {
+                return false;
+            }
+
+            field = CancellationTokenSource.CreateLinkedTokenSource(field, newCancellationToken).Token;
+            return true;
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/Internal/CancellationTokenHelper.cs.meta b/Assets/UniRx.Async/Internal/CancellationTokenHelper.cs.meta
new file mode 100644
index 0000000..bf09591
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/CancellationTokenHelper.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 53d1b536fc7e2d4458294ee2c7d9b743
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Internal/ContinuationQueue.cs b/Assets/UniRx.Async/Internal/ContinuationQueue.cs
new file mode 100644
index 0000000..41bb5be
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/ContinuationQueue.cs
@@ -0,0 +1,115 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Threading;
+
+namespace UniRx.Async.Internal
+{
+    internal class ContinuationQueue
+    {
+        const int MaxArrayLength = 0X7FEFFFFF;
+        const int InitialSize = 16;
+
+        SpinLock gate = new SpinLock();
+        bool dequing = false;
+
+        int actionListCount = 0;
+        Action[] actionList = new Action[InitialSize];
+
+        int waitingListCount = 0;
+        Action[] waitingList = new Action[InitialSize];
+
+        public void Enqueue(Action continuation)
+        {
+            bool lockTaken = false;
+            try
+            {
+                gate.Enter(ref lockTaken);
+
+                if (dequing)
+                {
+                    // Ensure Capacity
+                    if (waitingList.Length == waitingListCount)
+                    {
+                        var newLength = waitingListCount * 2;
+                        if ((uint)newLength > MaxArrayLength) newLength = MaxArrayLength;
+
+                        var newArray = new Action[newLength];
+                        Array.Copy(waitingList, newArray, waitingListCount);
+                        waitingList = newArray;
+                    }
+                    waitingList[waitingListCount] = continuation;
+                    waitingListCount++;
+                }
+                else
+                {
+                    // Ensure Capacity
+                    if (actionList.Length == actionListCount)
+                    {
+                        var newLength = actionListCount * 2;
+                        if ((uint)newLength > MaxArrayLength) newLength = MaxArrayLength;
+
+                        var newArray = new Action[newLength];
+                        Array.Copy(actionList, newArray, actionListCount);
+                        actionList = newArray;
+                    }
+                    actionList[actionListCount] = continuation;
+                    actionListCount++;
+                }
+            }
+            finally
+            {
+                if (lockTaken) gate.Exit(false);
+            }
+        }
+
+        public void Run()
+        {
+            {
+                bool lockTaken = false;
+                try
+                {
+                    gate.Enter(ref lockTaken);
+                    if (actionListCount == 0) return;
+                    dequing = true;
+                }
+                finally
+                {
+                    if (lockTaken) gate.Exit(false);
+                }
+            }
+
+            for (int i = 0; i < actionListCount; i++)
+            {
+                var action = actionList[i];
+                actionList[i] = null;
+
+                action();
+            }
+
+            {
+                bool lockTaken = false;
+                try
+                {
+                    gate.Enter(ref lockTaken);
+                    dequing = false;
+
+                    var swapTempActionList = actionList;
+
+                    actionListCount = waitingListCount;
+                    actionList = waitingList;
+
+                    waitingListCount = 0;
+                    waitingList = swapTempActionList;
+                }
+                finally
+                {
+                    if (lockTaken) gate.Exit(false);
+                }
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/Internal/ContinuationQueue.cs.meta b/Assets/UniRx.Async/Internal/ContinuationQueue.cs.meta
new file mode 100644
index 0000000..b04e541
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/ContinuationQueue.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f66c32454e50f2546b17deadc80a4c77
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Internal/Error.cs b/Assets/UniRx.Async/Internal/Error.cs
new file mode 100644
index 0000000..378af62
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/Error.cs
@@ -0,0 +1,63 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace UniRx.Async.Internal
+{
+    internal static class Error
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ThrowArgumentNullException<T>(T value, string paramName)
+          where T : class
+        {
+            if (value == null) ThrowArgumentNullExceptionCore(paramName);
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        static void ThrowArgumentNullExceptionCore(string paramName)
+        {
+            throw new ArgumentNullException(paramName);
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public static void ThrowArgumentException<T>(string message)
+        {
+            throw new ArgumentException(message);
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public static void ThrowNotYetCompleted()
+        {
+            throw new InvalidOperationException("Not yet completed.");
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public static T ThrowNotYetCompleted<T>()
+        {
+            throw new InvalidOperationException("Not yet completed.");
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ThrowWhenContinuationIsAlreadyRegistered<T>(T continuationField)
+          where T : class
+        {
+            if (continuationField != null) ThrowInvalidOperationExceptionCore("continuation is already registered.");
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        static void ThrowInvalidOperationExceptionCore(string message)
+        {
+            throw new InvalidOperationException(message);
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public static void ThrowOperationCanceledException()
+        {
+            throw new OperationCanceledException();
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/Internal/Error.cs.meta b/Assets/UniRx.Async/Internal/Error.cs.meta
new file mode 100644
index 0000000..2e5d219
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/Error.cs.meta
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 5f39f495294d4604b8082202faf98554
+timeCreated: 1532361007
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Internal/Hack.cs b/Assets/UniRx.Async/Internal/Hack.cs
new file mode 100644
index 0000000..7c600d0
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/Hack.cs
@@ -0,0 +1,23 @@
+#if NET_4_6 || NET_STANDARD_2_0 || CSHARP_7_OR_LATER
+
+using System;
+
+namespace UniRx.Async.Internal
+{
+    internal static class FuncExtensions
+    {
+        // avoid lambda capture
+
+        internal static Action<T> AsFuncOfT<T>(this Action action)
+        {
+            return new Action<T>(action.Invoke);
+        }
+
+        static void Invoke<T>(this Action action, T unused)
+        {
+            action();
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/Internal/Hack.cs.meta b/Assets/UniRx.Async/Internal/Hack.cs.meta
new file mode 100644
index 0000000..e77edfc
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/Hack.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4d5a9a3e1f0f069478969f752fde29a9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Internal/LazyPromise.cs b/Assets/UniRx.Async/Internal/LazyPromise.cs
new file mode 100644
index 0000000..e62fd59
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/LazyPromise.cs
@@ -0,0 +1,130 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Threading;
+
+namespace UniRx.Async.Internal
+{
+    internal sealed class LazyPromise : IAwaiter
+    {
+        Func<UniTask> factory;
+        UniTask value;
+
+        public LazyPromise(Func<UniTask> factory)
+        {
+            this.factory = factory;
+        }
+
+        void Create()
+        {
+            var f = Interlocked.Exchange(ref factory, null);
+            if (f != null)
+            {
+                value = f();
+            }
+        }
+
+        public bool IsCompleted
+        {
+            get
+            {
+                Create();
+                return value.IsCompleted;
+            }
+        }
+
+        public AwaiterStatus Status
+        {
+            get
+            {
+                Create();
+                return value.Status;
+            }
+        }
+
+        public void GetResult()
+        {
+            Create();
+            value.GetResult();
+        }
+
+        void IAwaiter.GetResult()
+        {
+            GetResult();
+        }
+
+        public void UnsafeOnCompleted(Action continuation)
+        {
+            Create();
+            value.GetAwaiter().UnsafeOnCompleted(continuation);
+        }
+
+        public void OnCompleted(Action continuation)
+        {
+            UnsafeOnCompleted(continuation);
+        }
+    }
+
+    internal sealed class LazyPromise<T> : IAwaiter<T>
+    {
+        Func<UniTask<T>> factory;
+        UniTask<T> value;
+
+        public LazyPromise(Func<UniTask<T>> factory)
+        {
+            this.factory = factory;
+        }
+
+        void Create()
+        {
+            var f = Interlocked.Exchange(ref factory, null);
+            if (f != null)
+            {
+                value = f();
+            }
+        }
+
+        public bool IsCompleted
+        {
+            get
+            {
+                Create();
+                return value.IsCompleted;
+            }
+        }
+
+        public AwaiterStatus Status
+        {
+            get
+            {
+                    Create();
+                    return value.Status;
+            }
+        }
+
+        public T GetResult()
+        {
+            Create();
+            return value.Result;
+        }
+
+        void IAwaiter.GetResult()
+        {
+            GetResult();
+        }
+
+        public void UnsafeOnCompleted(Action continuation)
+        {
+            Create();
+            value.GetAwaiter().UnsafeOnCompleted(continuation);
+        }
+
+        public void OnCompleted(Action continuation)
+        {
+            UnsafeOnCompleted(continuation);
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/Internal/LazyPromise.cs.meta b/Assets/UniRx.Async/Internal/LazyPromise.cs.meta
new file mode 100644
index 0000000..ee8f3f7
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/LazyPromise.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fe7a4187b7f89f84582fd1e466a7f27e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Internal/MinimumQueue.cs b/Assets/UniRx.Async/Internal/MinimumQueue.cs
new file mode 100644
index 0000000..acf4962
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/MinimumQueue.cs
@@ -0,0 +1,122 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+#endif
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace UniRx.Async.Internal
+{
+    // optimized version of Standard Queue<T>.
+    internal class MinimumQueue<T>
+    {
+        const int MinimumGrow = 4;
+        const int GrowFactor = 200;
+
+        T[] array;
+        int head;
+        int tail;
+        int size;
+
+        public MinimumQueue(int capacity)
+        {
+            if (capacity < 0) throw new ArgumentOutOfRangeException("capacity");
+            array = new T[capacity];
+            head = tail = size = 0;
+        }
+
+        public int Count
+        {
+#if NET_4_6 || NET_STANDARD_2_0
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#endif
+            get { return size; }
+        }
+
+        public T Peek()
+        {
+            if (size == 0) ThrowForEmptyQueue();
+            return array[head];
+        }
+
+#if NET_4_6 || NET_STANDARD_2_0
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#endif
+        public void Enqueue(T item)
+        {
+            if (size == array.Length)
+            {
+                Grow();
+            }
+
+            array[tail] = item;
+            MoveNext(ref tail);
+            size++;
+        }
+
+#if NET_4_6 || NET_STANDARD_2_0
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#endif
+        public T Dequeue()
+        {
+            if (size == 0) ThrowForEmptyQueue();
+
+            int head = this.head;
+            T[] array = this.array;
+            T removed = array[head];
+            array[head] = default(T);
+            MoveNext(ref this.head);
+            size--;
+            return removed;
+        }
+
+        void Grow()
+        {
+            int newcapacity = (int)((long)array.Length * (long)GrowFactor / 100);
+            if (newcapacity < array.Length + MinimumGrow)
+            {
+                newcapacity = array.Length + MinimumGrow;
+            }
+            SetCapacity(newcapacity);
+        }
+
+        void SetCapacity(int capacity)
+        {
+            T[] newarray = new T[capacity];
+            if (size > 0)
+            {
+                if (head < tail)
+                {
+                    Array.Copy(array, head, newarray, 0, size);
+                }
+                else
+                {
+                    Array.Copy(array, head, newarray, 0, array.Length - head);
+                    Array.Copy(array, 0, newarray, array.Length - head, tail);
+                }
+            }
+
+            array = newarray;
+            head = 0;
+            tail = (size == capacity) ? 0 : size;
+        }
+
+#if NET_4_6 || NET_STANDARD_2_0
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#endif
+        void MoveNext(ref int index)
+        {
+            int tmp = index + 1;
+            if (tmp == array.Length)
+            {
+                tmp = 0;
+            }
+            index = tmp;
+        }
+
+        void ThrowForEmptyQueue()
+        {
+            throw new InvalidOperationException("EmptyQueue");
+        }
+    }
+}
\ No newline at end of file
diff --git a/Assets/UniRx.Async/Internal/MinimumQueue.cs.meta b/Assets/UniRx.Async/Internal/MinimumQueue.cs.meta
new file mode 100644
index 0000000..dc06736
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/MinimumQueue.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7d63add489ccc99498114d79702b904d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Internal/PlayerLoopRunner.cs b/Assets/UniRx.Async/Internal/PlayerLoopRunner.cs
new file mode 100644
index 0000000..86da337
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/PlayerLoopRunner.cs
@@ -0,0 +1,153 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+
+using System;
+using UnityEngine;
+
+namespace UniRx.Async.Internal
+{
+    internal sealed class PlayerLoopRunner
+    {
+        const int InitialSize = 16;
+
+        readonly object runningAndQueueLock = new object();
+        readonly object arrayLock = new object();
+        readonly Action<Exception> unhandledExceptionCallback;
+
+        int tail = 0;
+        bool running = false;
+        IPlayerLoopItem[] loopItems = new IPlayerLoopItem[InitialSize];
+        MinimumQueue<IPlayerLoopItem> waitQueue = new MinimumQueue<IPlayerLoopItem>(InitialSize);
+
+        public PlayerLoopRunner()
+        {
+            this.unhandledExceptionCallback = ex => Debug.LogException(ex);
+        }
+
+        public void AddAction(IPlayerLoopItem item)
+        {
+            lock (runningAndQueueLock)
+            {
+                if (running)
+                {
+                    waitQueue.Enqueue(item);
+                    return;
+                }
+            }
+
+            lock (arrayLock)
+            {
+                // Ensure Capacity
+                if (loopItems.Length == tail)
+                {
+                    Array.Resize(ref loopItems, checked(tail * 2));
+                }
+                loopItems[tail++] = item;
+            }
+        }
+
+        public void Run()
+        {
+            lock (runningAndQueueLock)
+            {
+                running = true;
+            }
+
+            lock (arrayLock)
+            {
+                var j = tail - 1;
+
+                // eliminate array-bound check for i
+                for (int i = 0; i < loopItems.Length; i++)
+                {
+                    var action = loopItems[i];
+                    if (action != null)
+                    {
+                        try
+                        {
+                            if (!action.MoveNext())
+                            {
+                                loopItems[i] = null;
+                            }
+                            else
+                            {
+                                continue; // next i 
+                            }
+                        }
+                        catch (Exception ex)
+                        {
+                            loopItems[i] = null;
+                            try
+                            {
+                                unhandledExceptionCallback(ex);
+                            }
+                            catch { }
+                        }
+                    }
+
+                    // find null, loop from tail
+                    while (i < j)
+                    {
+                        var fromTail = loopItems[j];
+                        if (fromTail != null)
+                        {
+                            try
+                            {
+                                if (!fromTail.MoveNext())
+                                {
+                                    loopItems[j] = null;
+                                    j--;
+                                    continue; // next j
+                                }
+                                else
+                                {
+                                    // swap
+                                    loopItems[i] = fromTail;
+                                    loopItems[j] = null;
+                                    j--;
+                                    goto NEXT_LOOP; // next i
+                                }
+                            }
+                            catch (Exception ex)
+                            {
+                                loopItems[j] = null;
+                                j--;
+                                try
+                                {
+                                    unhandledExceptionCallback(ex);
+                                }
+                                catch { }
+                                continue; // next j
+                            }
+                        }
+                        else
+                        {
+                            j--;
+                        }
+                    }
+
+                    tail = i; // loop end
+                    break; // LOOP END
+
+                    NEXT_LOOP:
+                    continue;
+                }
+
+
+                lock (runningAndQueueLock)
+                {
+                    running = false;
+                    while (waitQueue.Count != 0)
+                    {
+                        if (loopItems.Length == tail)
+                        {
+                            Array.Resize(ref loopItems, checked(tail * 2));
+                        }
+                        loopItems[tail++] = waitQueue.Dequeue();
+                    }
+                }
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/Internal/PlayerLoopRunner.cs.meta b/Assets/UniRx.Async/Internal/PlayerLoopRunner.cs.meta
new file mode 100644
index 0000000..603dbc9
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/PlayerLoopRunner.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 340c6d420bb4f484aa8683415ea92571
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Internal/PromiseHelper.cs b/Assets/UniRx.Async/Internal/PromiseHelper.cs
new file mode 100644
index 0000000..a303b11
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/PromiseHelper.cs
@@ -0,0 +1,34 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+
+namespace UniRx.Async.Internal
+{
+    internal static class PromiseHelper
+    {
+        internal static void TrySetResultAll<TPromise, T>(IEnumerable<TPromise> source, T value)
+            where TPromise : class, IResolvePromise<T>
+        {
+            var rentArray = ArrayPoolUtil.Materialize(source);
+            var clearArray = true;
+            try
+            {
+                var array = rentArray.Array;
+                var len = rentArray.Length;
+                for (int i = 0; i < len; i++) 
+                {
+                    array[i].TrySetResult(value);
+                    array[i] = null;
+                }
+                clearArray = false;
+            }
+            finally
+            {
+                rentArray.DisposeManually(clearArray);
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/Internal/PromiseHelper.cs.meta b/Assets/UniRx.Async/Internal/PromiseHelper.cs.meta
new file mode 100644
index 0000000..dfc1c50
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/PromiseHelper.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 173f9b763911bf847b7dfbf31ee87fc4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Internal/ReusablePromise.cs b/Assets/UniRx.Async/Internal/ReusablePromise.cs
new file mode 100644
index 0000000..5e1efea
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/ReusablePromise.cs
@@ -0,0 +1,395 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Diagnostics;
+using System.Runtime.ExceptionServices;
+using System.Threading;
+
+namespace UniRx.Async.Internal
+{
+    // public for some types uses it.
+
+    public abstract class ReusablePromise : IAwaiter
+    {
+        ExceptionDispatchInfo exception;
+        object continuation; // Action or Queue<Action>
+        AwaiterStatus status;
+
+        public UniTask Task => new UniTask(this);
+
+        // can override for control 'start/reset' timing.
+        public virtual bool IsCompleted => status.IsCompleted();
+
+        public virtual void GetResult()
+        {
+            switch (status)
+            {
+                case AwaiterStatus.Succeeded:
+                    return;
+                case AwaiterStatus.Faulted:
+                    exception.Throw();
+                    break;
+                case AwaiterStatus.Canceled:
+                    throw new OperationCanceledException();
+                default:
+                    break;
+            }
+
+            throw new InvalidOperationException("Invalid Status:" + status);
+        }
+
+        public AwaiterStatus Status => status;
+
+        void IAwaiter.GetResult()
+        {
+            GetResult();
+        }
+
+        public void ResetStatus(bool forceReset)
+        {
+            if (forceReset)
+            {
+                status = AwaiterStatus.Pending;
+            }
+            else if (status == AwaiterStatus.Succeeded)
+            {
+                status = AwaiterStatus.Pending;
+            }
+        }
+
+        public virtual bool TrySetCanceled()
+        {
+            if (status == AwaiterStatus.Pending)
+            {
+                status = AwaiterStatus.Canceled;
+                TryInvokeContinuation();
+                return true;
+            }
+            return false;
+        }
+
+        public virtual bool TrySetException(Exception ex)
+        {
+            if (status == AwaiterStatus.Pending)
+            {
+                status = AwaiterStatus.Faulted;
+                exception = ExceptionDispatchInfo.Capture(ex);
+                TryInvokeContinuation();
+                return true;
+            }
+            return false;
+        }
+
+        public virtual bool TrySetResult()
+        {
+            if (status == AwaiterStatus.Pending)
+            {
+                status = AwaiterStatus.Succeeded;
+                TryInvokeContinuation();
+                return true;
+            }
+            return false;
+        }
+
+        void TryInvokeContinuation()
+        {
+            if (continuation == null) return;
+
+            if (continuation is Action act)
+            {
+                continuation = null;
+                act();
+            }
+            else
+            {
+                // reuse Queue(don't null clear)
+                var q = (MinimumQueue<Action>)continuation;
+                var size = q.Count;
+                for (int i = 0; i < size; i++)
+                {
+                    q.Dequeue().Invoke();
+                }
+            }
+        }
+
+        public void OnCompleted(Action action)
+        {
+            UnsafeOnCompleted(action);
+        }
+
+        public void UnsafeOnCompleted(Action action)
+        {
+            if (continuation == null)
+            {
+                continuation = action;
+                return;
+            }
+            else
+            {
+                if (continuation is Action act)
+                {
+                    var q = new MinimumQueue<Action>(4);
+                    q.Enqueue(act);
+                    q.Enqueue(action);
+                    continuation = q;
+                    return;
+                }
+                else
+                {
+                    ((MinimumQueue<Action>)continuation).Enqueue(action);
+                }
+            }
+        }
+    }
+
+    public abstract class ReusablePromise<T> : IAwaiter<T>
+    {
+        T result;
+        ExceptionDispatchInfo exception;
+        object continuation; // Action or Queue<Action>
+        AwaiterStatus status;
+
+        public UniTask<T> Task => new UniTask<T>(this);
+
+        // can override for control 'start/reset' timing.
+        public virtual bool IsCompleted => status.IsCompleted();
+
+        protected T RawResult => result;
+
+        protected void ForceSetResult(T result)
+        {
+            this.result = result;
+        }
+
+        public virtual T GetResult()
+        {
+            switch (status)
+            {
+                case AwaiterStatus.Succeeded:
+                    return result;
+                case AwaiterStatus.Faulted:
+                    exception.Throw();
+                    break;
+                case AwaiterStatus.Canceled:
+                    throw new OperationCanceledException();
+                default:
+                    break;
+            }
+
+            throw new InvalidOperationException("Invalid Status:" + status);
+        }
+
+        public AwaiterStatus Status => status;
+
+        void IAwaiter.GetResult()
+        {
+            GetResult();
+        }
+
+        public void ResetStatus(bool forceReset)
+        {
+            if (forceReset)
+            {
+                status = AwaiterStatus.Pending;
+            }
+            else if (status == AwaiterStatus.Succeeded)
+            {
+                status = AwaiterStatus.Pending;
+            }
+        }
+
+        public virtual bool TrySetCanceled()
+        {
+            if (status == AwaiterStatus.Pending)
+            {
+                status = AwaiterStatus.Canceled;
+                TryInvokeContinuation();
+                return true;
+            }
+            return false;
+        }
+
+        public virtual bool TrySetException(Exception ex)
+        {
+            if (status == AwaiterStatus.Pending)
+            {
+                status = AwaiterStatus.Faulted;
+                exception = ExceptionDispatchInfo.Capture(ex);
+                TryInvokeContinuation();
+                return true;
+            }
+            return false;
+        }
+
+        public virtual bool TrySetResult(T result)
+        {
+            if (status == AwaiterStatus.Pending)
+            {
+                status = AwaiterStatus.Succeeded;
+                this.result = result;
+                TryInvokeContinuation();
+                return true;
+            }
+            return false;
+        }
+
+        protected void TryInvokeContinuation()
+        {
+            if (continuation == null) return;
+
+            if (continuation is Action act)
+            {
+                continuation = null;
+                act();
+            }
+            else
+            {
+                // reuse Queue(don't null clear)
+                var q = (MinimumQueue<Action>)continuation;
+                var size = q.Count;
+                for (int i = 0; i < size; i++)
+                {
+                    q.Dequeue().Invoke();
+                }
+            }
+        }
+
+        public void OnCompleted(Action action)
+        {
+            UnsafeOnCompleted(action);
+        }
+
+        public void UnsafeOnCompleted(Action action)
+        {
+            if (continuation == null)
+            {
+                continuation = action;
+                return;
+            }
+            else
+            {
+                if (continuation is Action act)
+                {
+                    var q = new MinimumQueue<Action>(4);
+                    q.Enqueue(act);
+                    q.Enqueue(action);
+                    continuation = q;
+                    return;
+                }
+                else
+                {
+                    ((MinimumQueue<Action>)continuation).Enqueue(action);
+                }
+            }
+        }
+    }
+
+    public abstract class PlayerLoopReusablePromiseBase : ReusablePromise, IPlayerLoopItem
+    {
+        readonly PlayerLoopTiming timing;
+        protected readonly CancellationToken cancellationToken;
+        bool isRunning = false;
+
+#if UNITY_EDITOR
+        string capturedStackTraceForDebugging;
+#endif
+
+        public PlayerLoopReusablePromiseBase(PlayerLoopTiming timing, CancellationToken cancellationToken, int skipTrackFrameCountAdditive)
+        {
+            this.timing = timing;
+            this.cancellationToken = cancellationToken;
+
+#if UNITY_EDITOR
+            this.capturedStackTraceForDebugging = TaskTracker.CaptureStackTrace(skipTrackFrameCountAdditive + 1); // 1 is self,
+#endif
+        }
+
+        public override bool IsCompleted
+        {
+            get
+            {
+                if (Status == AwaiterStatus.Canceled || Status == AwaiterStatus.Faulted) return true;
+
+                if (!isRunning)
+                {
+                    isRunning = true;
+                    ResetStatus(false);
+                    OnRunningStart();
+#if UNITY_EDITOR
+                    TaskTracker.TrackActiveTask(this, capturedStackTraceForDebugging);
+#endif
+                    PlayerLoopHelper.AddAction(timing, this);
+                }
+                return false;
+            }
+        }
+
+        protected abstract void OnRunningStart();
+
+        protected void Complete()
+        {
+            isRunning = false;
+#if UNITY_EDITOR
+            TaskTracker.RemoveTracking(this);
+#endif
+        }
+
+        public abstract bool MoveNext();
+    }
+
+    public abstract class PlayerLoopReusablePromiseBase<T> : ReusablePromise<T>, IPlayerLoopItem
+    {
+        readonly PlayerLoopTiming timing;
+        protected readonly CancellationToken cancellationToken;
+        bool isRunning = false;
+
+#if UNITY_EDITOR
+        string capturedStackTraceForDebugging;
+#endif
+
+        public PlayerLoopReusablePromiseBase(PlayerLoopTiming timing, CancellationToken cancellationToken, int skipTrackFrameCountAdditive)
+        {
+            this.timing = timing;
+            this.cancellationToken = cancellationToken;
+
+#if UNITY_EDITOR
+            this.capturedStackTraceForDebugging = TaskTracker.CaptureStackTrace(skipTrackFrameCountAdditive + 1); // 1 is self,
+#endif
+        }
+
+        public override bool IsCompleted
+        {
+            get
+            {
+                if (Status == AwaiterStatus.Canceled || Status == AwaiterStatus.Faulted) return true;
+
+                if (!isRunning)
+                {
+                    isRunning = true;
+                    ResetStatus(false);
+                    OnRunningStart();
+#if UNITY_EDITOR
+                    TaskTracker.TrackActiveTask(this, capturedStackTraceForDebugging);
+#endif
+                    PlayerLoopHelper.AddAction(timing, this);
+                }
+                return false;
+            }
+        }
+
+        protected abstract void OnRunningStart();
+
+        protected void Complete()
+        {
+            isRunning = false;
+#if UNITY_EDITOR
+            TaskTracker.RemoveTracking(this);
+#endif
+        }
+
+        public abstract bool MoveNext();
+    }
+
+#endif
+}
\ No newline at end of file
diff --git a/Assets/UniRx.Async/Internal/ReusablePromise.cs.meta b/Assets/UniRx.Async/Internal/ReusablePromise.cs.meta
new file mode 100644
index 0000000..d86918f
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/ReusablePromise.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a8cfc99b5928c0242919aac2121b02bb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Internal/RuntimeHelpersAbstraction.cs b/Assets/UniRx.Async/Internal/RuntimeHelpersAbstraction.cs
new file mode 100644
index 0000000..e628145
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/RuntimeHelpersAbstraction.cs
@@ -0,0 +1,60 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using UnityEngine;
+
+namespace UniRx.Async.Internal
+{
+    internal static class RuntimeHelpersAbstraction
+    {
+        // If we can use RuntimeHelpers.IsReferenceOrContainsReferences(.NET Core 2.0), use it.
+        public static bool IsWellKnownNoReferenceContainsType<T>()
+        {
+            return WellKnownNoReferenceContainsType<T>.IsWellKnownType;
+        }
+
+        static bool WellKnownNoReferenceContainsTypeInitialize(Type t)
+        {
+            // The primitive types are Boolean, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, IntPtr, UIntPtr, Char, Double, and Single.
+            if (t.IsPrimitive) return true;
+
+            if (t.IsEnum) return true;
+            if (t == typeof(DateTime)) return true;
+            if (t == typeof(DateTimeOffset)) return true;
+            if (t == typeof(Guid)) return true;
+            if (t == typeof(decimal)) return true;
+
+            // unwrap nullable
+            if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable<>))
+            {
+                return WellKnownNoReferenceContainsTypeInitialize(t.GetGenericArguments()[0]);
+            }
+
+            // or add other wellknown types(Vector, etc...) here
+            if (t == typeof(Vector2)) return true;
+            if (t == typeof(Vector3)) return true;
+            if (t == typeof(Vector4)) return true;
+            if (t == typeof(Color)) return true;
+            if (t == typeof(Rect)) return true;
+            if (t == typeof(Bounds)) return true;
+            if (t == typeof(Quaternion)) return true;
+            if (t == typeof(Vector2Int)) return true;
+            if (t == typeof(Vector3Int)) return true;
+
+            return false;
+        }
+
+        static class WellKnownNoReferenceContainsType<T>
+        {
+            public static readonly bool IsWellKnownType;
+
+            static WellKnownNoReferenceContainsType()
+            {
+                IsWellKnownType = WellKnownNoReferenceContainsTypeInitialize(typeof(T));
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/Internal/RuntimeHelpersAbstraction.cs.meta b/Assets/UniRx.Async/Internal/RuntimeHelpersAbstraction.cs.meta
new file mode 100644
index 0000000..4254391
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/RuntimeHelpersAbstraction.cs.meta
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 94975e4d4e0c0ea4ba787d3872ce9bb4
+timeCreated: 1532361007
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Internal/TaskTracker.cs b/Assets/UniRx.Async/Internal/TaskTracker.cs
new file mode 100644
index 0000000..9d2e65c
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/TaskTracker.cs
@@ -0,0 +1,152 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Threading;
+
+namespace UniRx.Async.Internal
+{
+    // public for add user custom.
+
+    public static class TaskTracker
+    {
+#if UNITY_EDITOR
+
+        static int trackingId = 0;
+
+        public const string EnableAutoReloadKey = "UniTaskTrackerWindow_EnableAutoReloadKey";
+        public const string EnableTrackingKey = "UniTaskTrackerWindow_EnableTrackingKey";
+        public const string EnableStackTraceKey = "UniTaskTrackerWindow_EnableStackTraceKey";
+
+        public static class EditorEnableState
+        {
+            static bool enableAutoReload;
+            public static bool EnableAutoReload
+            {
+                get { return enableAutoReload; }
+                set
+                {
+                    enableAutoReload = value;
+                    UnityEditor.EditorPrefs.SetBool(EnableAutoReloadKey, value);
+                }
+            }
+
+            static bool enableTracking;
+            public static bool EnableTracking
+            {
+                get { return enableTracking; }
+                set
+                {
+                    enableTracking = value;
+                    UnityEditor.EditorPrefs.SetBool(EnableTrackingKey, value);
+                }
+            }
+
+            static bool enableStackTrace;
+            public static bool EnableStackTrace
+            {
+                get { return enableStackTrace; }
+                set
+                {
+                    enableStackTrace = value;
+                    UnityEditor.EditorPrefs.SetBool(EnableStackTraceKey, value);
+                }
+            }
+        }
+
+#endif
+
+
+        static List<KeyValuePair<IAwaiter, (int trackingId, DateTime addTime, string stackTrace)>> listPool = new List<KeyValuePair<IAwaiter, (int trackingId, DateTime addTime, string stackTrace)>>();
+
+        static readonly WeakDictionary<IAwaiter, (int trackingId, DateTime addTime, string stackTrace)> tracking = new WeakDictionary<IAwaiter, (int trackingId, DateTime addTime, string stackTrace)>();
+
+        [Conditional("UNITY_EDITOR")]
+        public static void TrackActiveTask(IAwaiter task, int skipFrame = 1)
+        {
+#if UNITY_EDITOR
+            dirty = true;
+            if (!EditorEnableState.EnableTracking) return;
+            var stackTrace = EditorEnableState.EnableStackTrace ? new StackTrace(skipFrame, true).CleanupAsyncStackTrace() : "";
+            tracking.TryAdd(task, (Interlocked.Increment(ref trackingId), DateTime.UtcNow, stackTrace));
+#endif
+        }
+
+        [Conditional("UNITY_EDITOR")]
+        public static void TrackActiveTask(IAwaiter task, string stackTrace)
+        {
+#if UNITY_EDITOR
+            dirty = true;
+            if (!EditorEnableState.EnableTracking) return;
+            var success = tracking.TryAdd(task, (Interlocked.Increment(ref trackingId), DateTime.UtcNow, stackTrace));
+#endif
+        }
+
+        public static string CaptureStackTrace(int skipFrame)
+        {
+#if UNITY_EDITOR
+            if (!EditorEnableState.EnableTracking) return "";
+            var stackTrace = EditorEnableState.EnableStackTrace ? new StackTrace(skipFrame + 1, true).CleanupAsyncStackTrace() : "";
+            return stackTrace;
+#else
+            return null;
+#endif
+        }
+
+        [Conditional("UNITY_EDITOR")]
+        public static void RemoveTracking(IAwaiter task)
+        {
+#if UNITY_EDITOR
+            dirty = true;
+            if (!EditorEnableState.EnableTracking) return;
+            var success = tracking.TryRemove(task);
+#endif
+        }
+
+        static bool dirty;
+
+        public static bool CheckAndResetDirty()
+        {
+            var current = dirty;
+            dirty = false;
+            return current;
+        }
+
+        /// <summary>(trackingId, awaiterType, awaiterStatus, createdTime, stackTrace)</summary>
+        public static void ForEachActiveTask(Action<int, string, AwaiterStatus, DateTime, string> action)
+        {
+            lock (listPool)
+            {
+                var count = tracking.ToList(ref listPool, clear: false);
+                try
+                {
+                    for (int i = 0; i < count; i++)
+                    {
+                        string typeName = null;
+                        var keyType = listPool[i].Key.GetType();
+                        if (keyType.IsNested)
+                        {
+                            typeName = keyType.DeclaringType.Name + "." + keyType.Name;
+                        }
+                        else
+                        {
+                            typeName = keyType.Name;
+                        }
+
+                        action(listPool[i].Value.trackingId, typeName, listPool[i].Key.Status, listPool[i].Value.addTime, listPool[i].Value.stackTrace);
+                        listPool[i] = new KeyValuePair<IAwaiter, (int trackingId, DateTime addTime, string stackTrace)>(null, (0, default(DateTime), null)); // clear
+                    }
+                }
+                catch
+                {
+                    listPool.Clear();
+                    throw;
+                }
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/Internal/TaskTracker.cs.meta b/Assets/UniRx.Async/Internal/TaskTracker.cs.meta
new file mode 100644
index 0000000..5563bf7
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/TaskTracker.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a203c73eb4ccdbb44bddfd82d38fdda9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Internal/UnityEqualityComparer.cs b/Assets/UniRx.Async/Internal/UnityEqualityComparer.cs
new file mode 100644
index 0000000..268b82f
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/UnityEqualityComparer.cs
@@ -0,0 +1,271 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+#endif
+
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace UniRx.Async.Internal
+{
+    internal static class UnityEqualityComparer
+    {
+        public static readonly IEqualityComparer<Vector2> Vector2 = new Vector2EqualityComparer();
+        public static readonly IEqualityComparer<Vector3> Vector3 = new Vector3EqualityComparer();
+        public static readonly IEqualityComparer<Vector4> Vector4 = new Vector4EqualityComparer();
+        public static readonly IEqualityComparer<Color> Color = new ColorEqualityComparer();
+        public static readonly IEqualityComparer<Color32> Color32 = new Color32EqualityComparer();
+        public static readonly IEqualityComparer<Rect> Rect = new RectEqualityComparer();
+        public static readonly IEqualityComparer<Bounds> Bounds = new BoundsEqualityComparer();
+        public static readonly IEqualityComparer<Quaternion> Quaternion = new QuaternionEqualityComparer();
+
+        static readonly RuntimeTypeHandle vector2Type = typeof(Vector2).TypeHandle;
+        static readonly RuntimeTypeHandle vector3Type = typeof(Vector3).TypeHandle;
+        static readonly RuntimeTypeHandle vector4Type = typeof(Vector4).TypeHandle;
+        static readonly RuntimeTypeHandle colorType = typeof(Color).TypeHandle;
+        static readonly RuntimeTypeHandle color32Type = typeof(Color32).TypeHandle;
+        static readonly RuntimeTypeHandle rectType = typeof(Rect).TypeHandle;
+        static readonly RuntimeTypeHandle boundsType = typeof(Bounds).TypeHandle;
+        static readonly RuntimeTypeHandle quaternionType = typeof(Quaternion).TypeHandle;
+
+#if UNITY_2017_2_OR_NEWER
+
+        public static readonly IEqualityComparer<Vector2Int> Vector2Int = new Vector2IntEqualityComparer();
+        public static readonly IEqualityComparer<Vector3Int> Vector3Int = new Vector3IntEqualityComparer();
+        public static readonly IEqualityComparer<RangeInt> RangeInt = new RangeIntEqualityComparer();
+        public static readonly IEqualityComparer<RectInt> RectInt = new RectIntEqualityComparer();
+        public static readonly IEqualityComparer<BoundsInt> BoundsInt = new BoundsIntEqualityComparer();
+
+        static readonly RuntimeTypeHandle vector2IntType = typeof(Vector2Int).TypeHandle;
+        static readonly RuntimeTypeHandle vector3IntType = typeof(Vector3Int).TypeHandle;
+        static readonly RuntimeTypeHandle rangeIntType = typeof(RangeInt).TypeHandle;
+        static readonly RuntimeTypeHandle rectIntType = typeof(RectInt).TypeHandle;
+        static readonly RuntimeTypeHandle boundsIntType = typeof(BoundsInt).TypeHandle;
+
+#endif
+
+        static class Cache<T>
+        {
+            public static readonly IEqualityComparer<T> Comparer;
+
+            static Cache()
+            {
+                var comparer = GetDefaultHelper(typeof(T));
+                if (comparer == null)
+                {
+                    Comparer = EqualityComparer<T>.Default;
+                }
+                else
+                {
+                    Comparer = (IEqualityComparer<T>)comparer;
+                }
+            }
+        }
+
+        public static IEqualityComparer<T> GetDefault<T>()
+        {
+            return Cache<T>.Comparer;
+        }
+
+        static object GetDefaultHelper(Type type)
+        {
+            var t = type.TypeHandle;
+
+            if (t.Equals(vector2Type)) return (object)UnityEqualityComparer.Vector2;
+            if (t.Equals(vector3Type)) return (object)UnityEqualityComparer.Vector3;
+            if (t.Equals(vector4Type)) return (object)UnityEqualityComparer.Vector4;
+            if (t.Equals(colorType)) return (object)UnityEqualityComparer.Color;
+            if (t.Equals(color32Type)) return (object)UnityEqualityComparer.Color32;
+            if (t.Equals(rectType)) return (object)UnityEqualityComparer.Rect;
+            if (t.Equals(boundsType)) return (object)UnityEqualityComparer.Bounds;
+            if (t.Equals(quaternionType)) return (object)UnityEqualityComparer.Quaternion;
+
+#if UNITY_2017_2_OR_NEWER
+
+            if (t.Equals(vector2IntType)) return (object)UnityEqualityComparer.Vector2Int;
+            if (t.Equals(vector3IntType)) return (object)UnityEqualityComparer.Vector3Int;
+            if (t.Equals(rangeIntType)) return (object)UnityEqualityComparer.RangeInt;
+            if (t.Equals(rectIntType)) return (object)UnityEqualityComparer.RectInt;
+            if (t.Equals(boundsIntType)) return (object)UnityEqualityComparer.BoundsInt;
+#endif
+
+            return null;
+        }
+
+        sealed class Vector2EqualityComparer : IEqualityComparer<Vector2>
+        {
+            public bool Equals(Vector2 self, Vector2 vector)
+            {
+                return self.x.Equals(vector.x) && self.y.Equals(vector.y);
+            }
+
+            public int GetHashCode(Vector2 obj)
+            {
+                return obj.x.GetHashCode() ^ obj.y.GetHashCode() << 2;
+            }
+        }
+
+        sealed class Vector3EqualityComparer : IEqualityComparer<Vector3>
+        {
+            public bool Equals(Vector3 self, Vector3 vector)
+            {
+                return self.x.Equals(vector.x) && self.y.Equals(vector.y) && self.z.Equals(vector.z);
+            }
+
+            public int GetHashCode(Vector3 obj)
+            {
+                return obj.x.GetHashCode() ^ obj.y.GetHashCode() << 2 ^ obj.z.GetHashCode() >> 2;
+            }
+        }
+
+        sealed class Vector4EqualityComparer : IEqualityComparer<Vector4>
+        {
+            public bool Equals(Vector4 self, Vector4 vector)
+            {
+                return self.x.Equals(vector.x) && self.y.Equals(vector.y) && self.z.Equals(vector.z) && self.w.Equals(vector.w);
+            }
+
+            public int GetHashCode(Vector4 obj)
+            {
+                return obj.x.GetHashCode() ^ obj.y.GetHashCode() << 2 ^ obj.z.GetHashCode() >> 2 ^ obj.w.GetHashCode() >> 1;
+            }
+        }
+
+        sealed class ColorEqualityComparer : IEqualityComparer<Color>
+        {
+            public bool Equals(Color self, Color other)
+            {
+                return self.r.Equals(other.r) && self.g.Equals(other.g) && self.b.Equals(other.b) && self.a.Equals(other.a);
+            }
+
+            public int GetHashCode(Color obj)
+            {
+                return obj.r.GetHashCode() ^ obj.g.GetHashCode() << 2 ^ obj.b.GetHashCode() >> 2 ^ obj.a.GetHashCode() >> 1;
+            }
+        }
+
+        sealed class RectEqualityComparer : IEqualityComparer<Rect>
+        {
+            public bool Equals(Rect self, Rect other)
+            {
+                return self.x.Equals(other.x) && self.width.Equals(other.width) && self.y.Equals(other.y) && self.height.Equals(other.height);
+            }
+
+            public int GetHashCode(Rect obj)
+            {
+                return obj.x.GetHashCode() ^ obj.width.GetHashCode() << 2 ^ obj.y.GetHashCode() >> 2 ^ obj.height.GetHashCode() >> 1;
+            }
+        }
+
+        sealed class BoundsEqualityComparer : IEqualityComparer<Bounds>
+        {
+            public bool Equals(Bounds self, Bounds vector)
+            {
+                return self.center.Equals(vector.center) && self.extents.Equals(vector.extents);
+            }
+
+            public int GetHashCode(Bounds obj)
+            {
+                return obj.center.GetHashCode() ^ obj.extents.GetHashCode() << 2;
+            }
+        }
+
+        sealed class QuaternionEqualityComparer : IEqualityComparer<Quaternion>
+        {
+            public bool Equals(Quaternion self, Quaternion vector)
+            {
+                return self.x.Equals(vector.x) && self.y.Equals(vector.y) && self.z.Equals(vector.z) && self.w.Equals(vector.w);
+            }
+
+            public int GetHashCode(Quaternion obj)
+            {
+                return obj.x.GetHashCode() ^ obj.y.GetHashCode() << 2 ^ obj.z.GetHashCode() >> 2 ^ obj.w.GetHashCode() >> 1;
+            }
+        }
+
+        sealed class Color32EqualityComparer : IEqualityComparer<Color32>
+        {
+            public bool Equals(Color32 self, Color32 vector)
+            {
+                return self.a.Equals(vector.a) && self.r.Equals(vector.r) && self.g.Equals(vector.g) && self.b.Equals(vector.b);
+            }
+
+            public int GetHashCode(Color32 obj)
+            {
+                return obj.a.GetHashCode() ^ obj.r.GetHashCode() << 2 ^ obj.g.GetHashCode() >> 2 ^ obj.b.GetHashCode() >> 1;
+            }
+        }
+
+#if UNITY_2017_2_OR_NEWER
+
+        sealed class Vector2IntEqualityComparer : IEqualityComparer<Vector2Int>
+        {
+            public bool Equals(Vector2Int self, Vector2Int vector)
+            {
+                return self.x.Equals(vector.x) && self.y.Equals(vector.y);
+            }
+
+            public int GetHashCode(Vector2Int obj)
+            {
+                return obj.x.GetHashCode() ^ obj.y.GetHashCode() << 2;
+            }
+        }
+
+        sealed class Vector3IntEqualityComparer : IEqualityComparer<Vector3Int>
+        {
+            public static readonly Vector3IntEqualityComparer Default = new Vector3IntEqualityComparer();
+
+            public bool Equals(Vector3Int self, Vector3Int vector)
+            {
+                return self.x.Equals(vector.x) && self.y.Equals(vector.y) && self.z.Equals(vector.z);
+            }
+
+            public int GetHashCode(Vector3Int obj)
+            {
+                return obj.x.GetHashCode() ^ obj.y.GetHashCode() << 2 ^ obj.z.GetHashCode() >> 2;
+            }
+        }
+
+        sealed class RangeIntEqualityComparer : IEqualityComparer<RangeInt>
+        {
+            public bool Equals(RangeInt self, RangeInt vector)
+            {
+                return self.start.Equals(vector.start) && self.length.Equals(vector.length);
+            }
+
+            public int GetHashCode(RangeInt obj)
+            {
+                return obj.start.GetHashCode() ^ obj.length.GetHashCode() << 2;
+            }
+        }
+
+        sealed class RectIntEqualityComparer : IEqualityComparer<RectInt>
+        {
+            public bool Equals(RectInt self, RectInt other)
+            {
+                return self.x.Equals(other.x) && self.width.Equals(other.width) && self.y.Equals(other.y) && self.height.Equals(other.height);
+            }
+
+            public int GetHashCode(RectInt obj)
+            {
+                return obj.x.GetHashCode() ^ obj.width.GetHashCode() << 2 ^ obj.y.GetHashCode() >> 2 ^ obj.height.GetHashCode() >> 1;
+            }
+        }
+
+        sealed class BoundsIntEqualityComparer : IEqualityComparer<BoundsInt>
+        {
+            public bool Equals(BoundsInt self, BoundsInt vector)
+            {
+                return Vector3IntEqualityComparer.Default.Equals(self.position, vector.position)
+                    && Vector3IntEqualityComparer.Default.Equals(self.size, vector.size);
+            }
+
+            public int GetHashCode(BoundsInt obj)
+            {
+                return Vector3IntEqualityComparer.Default.GetHashCode(obj.position) ^ Vector3IntEqualityComparer.Default.GetHashCode(obj.size) << 2;
+            }
+        }
+
+#endif
+    }
+}
diff --git a/Assets/UniRx.Async/Internal/UnityEqualityComparer.cs.meta b/Assets/UniRx.Async/Internal/UnityEqualityComparer.cs.meta
new file mode 100644
index 0000000..79eb04f
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/UnityEqualityComparer.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ebaaf14253c9cfb47b23283218ff9b67
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Internal/WeakDictionary.cs b/Assets/UniRx.Async/Internal/WeakDictionary.cs
new file mode 100644
index 0000000..e2fd9fb
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/WeakDictionary.cs
@@ -0,0 +1,336 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace UniRx.Async.Internal
+{
+    // Add, Remove, Enumerate with sweep. All operations are thread safe(in spinlock).
+    internal class WeakDictionary<TKey, TValue>
+        where TKey : class
+    {
+        Entry[] buckets;
+        int size;
+        SpinLock gate; // mutable struct(not readonly)
+
+        readonly float loadFactor;
+        readonly IEqualityComparer<TKey> keyEqualityComparer;
+
+        public WeakDictionary(int capacity = 4, float loadFactor = 0.75f, IEqualityComparer<TKey> keyComparer = null)
+        {
+            var tableSize = CalculateCapacity(capacity, loadFactor);
+            this.buckets = new Entry[tableSize];
+            this.loadFactor = loadFactor;
+            this.gate = new SpinLock(false);
+            this.keyEqualityComparer = keyComparer ?? EqualityComparer<TKey>.Default;
+        }
+
+        public bool TryAdd(TKey key, TValue value)
+        {
+            bool lockTaken = false;
+            try
+            {
+                gate.Enter(ref lockTaken);
+                return TryAddInternal(key, value);
+            }
+            finally
+            {
+                if (lockTaken) gate.Exit(false);
+            }
+        }
+
+        public bool TryGetValue(TKey key, out TValue value)
+        {
+            bool lockTaken = false;
+            try
+            {
+                gate.Enter(ref lockTaken);
+                if (TryGetEntry(key, out _, out var entry))
+                {
+                    value = entry.Value;
+                    return true;
+                }
+
+                value = default(TValue);
+                return false;
+            }
+            finally
+            {
+                if (lockTaken) gate.Exit(false);
+            }
+        }
+
+        public bool TryRemove(TKey key)
+        {
+            bool lockTaken = false;
+            try
+            {
+                gate.Enter(ref lockTaken);
+                if (TryGetEntry(key, out var hashIndex, out var entry))
+                {
+                    Remove(hashIndex, entry);
+                    return true;
+                }
+
+                return false;
+            }
+            finally
+            {
+                if (lockTaken) gate.Exit(false);
+            }
+        }
+
+        bool TryAddInternal(TKey key, TValue value)
+        {
+            var nextCapacity = CalculateCapacity(size + 1, loadFactor);
+
+            TRY_ADD_AGAIN:
+            if (buckets.Length < nextCapacity)
+            {
+                // rehash
+                var nextBucket = new Entry[nextCapacity];
+                for (int i = 0; i < buckets.Length; i++)
+                {
+                    var e = buckets[i];
+                    while (e != null)
+                    {
+                        AddToBuckets(nextBucket, key, e.Value, e.Hash);
+                        e = e.Next;
+                    }
+                }
+
+                buckets = nextBucket;
+                goto TRY_ADD_AGAIN;
+            }
+            else
+            {
+                // add entry
+                var successAdd = AddToBuckets(buckets, key, value, keyEqualityComparer.GetHashCode(key));
+                if (successAdd) size++;
+                return successAdd;
+            }
+        }
+
+        bool AddToBuckets(Entry[] targetBuckets, TKey newKey, TValue value, int keyHash)
+        {
+            var h = keyHash;
+            var hashIndex = h & (targetBuckets.Length - 1);
+
+            TRY_ADD_AGAIN:
+            if (targetBuckets[hashIndex] == null)
+            {
+                targetBuckets[hashIndex] = new Entry
+                {
+                    Key = new WeakReference<TKey>(newKey, false),
+                    Value = value,
+                    Hash = h
+                };
+
+                return true;
+            }
+            else
+            {
+                // add to last.
+                var entry = targetBuckets[hashIndex];
+                while (entry != null)
+                {
+                    if (entry.Key.TryGetTarget(out var target))
+                    {
+                        if (keyEqualityComparer.Equals(newKey, target))
+                        {
+                            return false; // duplicate
+                        }
+                    }
+                    else
+                    {
+                        Remove(hashIndex, entry);
+                        if (targetBuckets[hashIndex] == null) goto TRY_ADD_AGAIN; // add new entry
+                    }
+
+                    if (entry.Next != null)
+                    {
+                        entry = entry.Next;
+                    }
+                    else
+                    {
+                        // found last
+                        entry.Next = new Entry
+                        {
+                            Key = new WeakReference<TKey>(newKey, false),
+                            Value = value,
+                            Hash = h
+                        };
+                        entry.Next.Prev = entry;
+                    }
+                }
+
+                return false;
+            }
+        }
+
+        bool TryGetEntry(TKey key, out int hashIndex, out Entry entry)
+        {
+            var table = buckets;
+            var hash = keyEqualityComparer.GetHashCode(key);
+            hashIndex = hash & table.Length - 1;
+            entry = table[hashIndex];
+
+            while (entry != null)
+            {
+                if (entry.Key.TryGetTarget(out var target))
+                {
+                    if (keyEqualityComparer.Equals(key, target))
+                    {
+                        return true;
+                    }
+                }
+                else
+                {
+                    // sweap
+                    Remove(hashIndex, entry);
+                }
+
+                entry = entry.Next;
+            }
+
+            return false;
+        }
+
+        void Remove(int hashIndex, Entry entry)
+        {
+            if (entry.Prev == null && entry.Next == null)
+            {
+                buckets[hashIndex] = null;
+            }
+            else
+            {
+                if (entry.Prev == null)
+                {
+                    buckets[hashIndex] = entry.Next;
+                }
+                if (entry.Prev != null)
+                {
+                    entry.Prev.Next = entry.Next;
+                }
+                if (entry.Next != null)
+                {
+                    entry.Next.Prev = entry.Prev;
+                }
+            }
+            size--;
+        }
+
+        public List<KeyValuePair<TKey, TValue>> ToList()
+        {
+            var list = new List<KeyValuePair<TKey, TValue>>(size);
+            ToList(ref list, false);
+            return list;
+        }
+
+        // avoid allocate everytime.
+        public int ToList(ref List<KeyValuePair<TKey, TValue>> list, bool clear = true)
+        {
+            if (clear)
+            {
+                list.Clear();
+            }
+
+            var listIndex = 0;
+
+            bool lockTaken = false;
+            try
+            {
+                for (int i = 0; i < buckets.Length; i++)
+                {
+                    var entry = buckets[i];
+                    while (entry != null)
+                    {
+                        if (entry.Key.TryGetTarget(out var target))
+                        {
+                            var item = new KeyValuePair<TKey, TValue>(target, entry.Value);
+                            if (listIndex < list.Count)
+                            {
+                                list[listIndex++] = item;
+                            }
+                            else
+                            {
+                                list.Add(item);
+                                listIndex++;
+                            }
+                        }
+                        else
+                        {
+                            // sweap
+                            Remove(i, entry);
+                        }
+
+                        entry = entry.Next;
+                    }
+                }
+            }
+            finally
+            {
+                if (lockTaken) gate.Exit(false);
+            }
+
+            return listIndex;
+        }
+
+        static int CalculateCapacity(int collectionSize, float loadFactor)
+        {
+            var size = (int)(((float)collectionSize) / loadFactor);
+
+            size--;
+            size |= size >> 1;
+            size |= size >> 2;
+            size |= size >> 4;
+            size |= size >> 8;
+            size |= size >> 16;
+            size += 1;
+
+            if (size < 8)
+            {
+                size = 8;
+            }
+            return size;
+        }
+
+        class Entry
+        {
+            public WeakReference<TKey> Key;
+            public TValue Value;
+            public int Hash;
+            public Entry Prev;
+            public Entry Next;
+
+            // debug only
+            public override string ToString()
+            {
+                if (Key.TryGetTarget(out var target))
+                {
+                    return target + "(" + Count() + ")";
+                }
+                else
+                {
+                    return "(Dead)";
+                }
+            }
+
+            int Count()
+            {
+                var count = 1;
+                var n = this;
+                while (n.Next != null)
+                {
+                    count++;
+                    n = n.Next;
+                }
+                return count;
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/Internal/WeakDictionary.cs.meta b/Assets/UniRx.Async/Internal/WeakDictionary.cs.meta
new file mode 100644
index 0000000..9dc1672
--- /dev/null
+++ b/Assets/UniRx.Async/Internal/WeakDictionary.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6c78563864409714593226af59bcb6f3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/PlayerLoopHelper.cs b/Assets/UniRx.Async/PlayerLoopHelper.cs
new file mode 100644
index 0000000..7d2c8bb
--- /dev/null
+++ b/Assets/UniRx.Async/PlayerLoopHelper.cs
@@ -0,0 +1,136 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Linq;
+using UnityEngine;
+using UniRx.Async.Internal;
+using System.Threading;
+
+#if UNITY_2019_3_OR_NEWER
+using UnityEngine.LowLevel;
+#else
+using UnityEngine.Experimental.LowLevel;
+#endif
+
+namespace UniRx.Async
+{
+    public static class UniTaskLoopRunners
+    {
+        public struct UniTaskLoopRunnerInitialization { };
+        public struct UniTaskLoopRunnerEarlyUpdate { };
+        public struct UniTaskLoopRunnerFixedUpdate { };
+        public struct UniTaskLoopRunnerPreUpdate { };
+        public struct UniTaskLoopRunnerUpdate { };
+        public struct UniTaskLoopRunnerPreLateUpdate { };
+        public struct UniTaskLoopRunnerPostLateUpdate { };
+
+        // Yield
+
+        public struct UniTaskLoopRunnerYieldInitialization { };
+        public struct UniTaskLoopRunnerYieldEarlyUpdate { };
+        public struct UniTaskLoopRunnerYieldFixedUpdate { };
+        public struct UniTaskLoopRunnerYieldPreUpdate { };
+        public struct UniTaskLoopRunnerYieldUpdate { };
+        public struct UniTaskLoopRunnerYieldPreLateUpdate { };
+        public struct UniTaskLoopRunnerYieldPostLateUpdate { };
+    }
+
+    public enum PlayerLoopTiming
+    {
+        Initialization = 0,
+        EarlyUpdate = 1,
+        FixedUpdate = 2,
+        PreUpdate = 3,
+        Update = 4,
+        PreLateUpdate = 5,
+        PostLateUpdate = 6
+    }
+
+    public interface IPlayerLoopItem
+    {
+        bool MoveNext();
+    }
+
+    public static class PlayerLoopHelper
+    {
+        public static SynchronizationContext UnitySynchronizationContext => unitySynchronizationContetext;
+        public static int MainThreadId => mainThreadId;
+
+        static int mainThreadId;
+        static SynchronizationContext unitySynchronizationContetext;
+        static ContinuationQueue[] yielders;
+        static PlayerLoopRunner[] runners;
+
+        static PlayerLoopSystem[] InsertRunner(PlayerLoopSystem loopSystem, Type loopRunnerYieldType, ContinuationQueue cq, Type loopRunnerType, PlayerLoopRunner runner)
+        {
+            var yieldLoop = new PlayerLoopSystem
+            {
+                type = loopRunnerYieldType,
+                updateDelegate = cq.Run
+            };
+
+            var runnerLoop = new PlayerLoopSystem
+            {
+                type = loopRunnerType,
+                updateDelegate = runner.Run
+            };
+
+            var dest = new PlayerLoopSystem[loopSystem.subSystemList.Length + 2];
+            Array.Copy(loopSystem.subSystemList, 0, dest, 2, loopSystem.subSystemList.Length);
+            dest[0] = yieldLoop;
+            dest[1] = runnerLoop;
+            return dest;
+        }
+
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
+        static void Init()
+        {
+            // capture default(unity) sync-context.
+            unitySynchronizationContetext = SynchronizationContext.Current;
+            mainThreadId = Thread.CurrentThread.ManagedThreadId;
+
+            if (runners != null) return; // already initialized
+
+            var playerLoop =
+#if UNITY_2019_3_OR_NEWER
+                PlayerLoop.GetCurrentPlayerLoop();
+#else
+                PlayerLoop.GetDefaultPlayerLoop();
+#endif
+
+            Initialize(ref playerLoop);
+        }
+
+        public static void Initialize(ref PlayerLoopSystem playerLoop)
+        {
+            yielders = new ContinuationQueue[7];
+            runners = new PlayerLoopRunner[7];
+
+            var copyList = playerLoop.subSystemList.ToArray();
+
+            copyList[0].subSystemList = InsertRunner(copyList[0], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldInitialization), yielders[0] = new ContinuationQueue(), typeof(UniTaskLoopRunners.UniTaskLoopRunnerInitialization), runners[0] = new PlayerLoopRunner());
+            copyList[1].subSystemList = InsertRunner(copyList[1], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldEarlyUpdate), yielders[1] = new ContinuationQueue(), typeof(UniTaskLoopRunners.UniTaskLoopRunnerEarlyUpdate), runners[1] = new PlayerLoopRunner());
+            copyList[2].subSystemList = InsertRunner(copyList[2], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldFixedUpdate), yielders[2] = new ContinuationQueue(), typeof(UniTaskLoopRunners.UniTaskLoopRunnerFixedUpdate), runners[2] = new PlayerLoopRunner());
+            copyList[3].subSystemList = InsertRunner(copyList[3], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPreUpdate), yielders[3] = new ContinuationQueue(), typeof(UniTaskLoopRunners.UniTaskLoopRunnerPreUpdate), runners[3] = new PlayerLoopRunner());
+            copyList[4].subSystemList = InsertRunner(copyList[4], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldUpdate), yielders[4] = new ContinuationQueue(), typeof(UniTaskLoopRunners.UniTaskLoopRunnerUpdate), runners[4] = new PlayerLoopRunner());
+            copyList[5].subSystemList = InsertRunner(copyList[5], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPreLateUpdate), yielders[5] = new ContinuationQueue(), typeof(UniTaskLoopRunners.UniTaskLoopRunnerPreLateUpdate), runners[5] = new PlayerLoopRunner());
+            copyList[6].subSystemList = InsertRunner(copyList[6], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPostLateUpdate), yielders[6] = new ContinuationQueue(), typeof(UniTaskLoopRunners.UniTaskLoopRunnerPostLateUpdate), runners[6] = new PlayerLoopRunner());
+
+            playerLoop.subSystemList = copyList;
+            PlayerLoop.SetPlayerLoop(playerLoop);
+        }
+
+        public static void AddAction(PlayerLoopTiming timing, IPlayerLoopItem action)
+        {
+            runners[(int)timing].AddAction(action);
+        }
+
+        public static void AddContinuation(PlayerLoopTiming timing, Action continuation)
+        {
+            yielders[(int)timing].Enqueue(continuation);
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/PlayerLoopHelper.cs.meta b/Assets/UniRx.Async/PlayerLoopHelper.cs.meta
new file mode 100644
index 0000000..2487ef7
--- /dev/null
+++ b/Assets/UniRx.Async/PlayerLoopHelper.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 15fb5b85042f19640b973ce651795aca
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Progress.cs b/Assets/UniRx.Async/Progress.cs
new file mode 100644
index 0000000..b9eaf38
--- /dev/null
+++ b/Assets/UniRx.Async/Progress.cs
@@ -0,0 +1,88 @@
+#if NET_4_6 || NET_STANDARD_2_0 || CSHARP_7_OR_LATER
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Collections.Generic;
+using UniRx.Async.Internal;
+
+namespace UniRx.Async
+{
+    /// <summary>
+    /// Lightweight IProgress[T] factory.
+    /// </summary>
+    public static class Progress
+    {
+        public static IProgress<T> Create<T>(Action<T> handler)
+        {
+            if (handler == null) return NullProgress<T>.Instance;
+            return new AnonymousProgress<T>(handler);
+        }
+
+        public static IProgress<T> CreateOnlyValueChanged<T>(Action<T> handler, IEqualityComparer<T> comparer = null)
+        {
+            if (handler == null) return NullProgress<T>.Instance;
+            return new OnlyValueChangedProgress<T>(handler, comparer ?? UnityEqualityComparer.GetDefault<T>());
+        }
+
+        sealed class NullProgress<T> : IProgress<T>
+        {
+            public static readonly IProgress<T> Instance = new NullProgress<T>();
+
+            NullProgress()
+            {
+
+            }
+
+            public void Report(T value)
+            {
+            }
+        }
+
+        sealed class AnonymousProgress<T> : IProgress<T>
+        {
+            readonly Action<T> action;
+
+            public AnonymousProgress(Action<T> action)
+            {
+                this.action = action;
+            }
+
+            public void Report(T value)
+            {
+                action(value);
+            }
+        }
+
+        sealed class OnlyValueChangedProgress<T> : IProgress<T>
+        {
+            readonly Action<T> action;
+            readonly IEqualityComparer<T> comparer;
+            bool isFirstCall;
+            T latestValue;
+
+            public OnlyValueChangedProgress(Action<T> action, IEqualityComparer<T> comparer)
+            {
+                this.action = action;
+                this.comparer = comparer;
+                this.isFirstCall = true;
+            }
+
+            public void Report(T value)
+            {
+                if (isFirstCall)
+                {
+                    isFirstCall = false;
+                }
+                else if (comparer.Equals(value, latestValue))
+                {
+                    return;
+                }
+
+                latestValue = value;
+                action(value);
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/Progress.cs.meta b/Assets/UniRx.Async/Progress.cs.meta
new file mode 100644
index 0000000..f0e1f19
--- /dev/null
+++ b/Assets/UniRx.Async/Progress.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e3377e2ae934ed54fb8fd5388e2d9eb9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers.meta b/Assets/UniRx.Async/Triggers.meta
new file mode 100644
index 0000000..280b698
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 85c0c768ced512e42b24021b3258b669
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncAnimatorTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncAnimatorTrigger.cs
new file mode 100644
index 0000000..00b66cb
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncAnimatorTrigger.cs
@@ -0,0 +1,54 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncAnimatorTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<int> onAnimatorIK;
+        AsyncTriggerPromiseDictionary<int> onAnimatorIKs;
+        AsyncTriggerPromise<AsyncUnit> onAnimatorMove;
+        AsyncTriggerPromiseDictionary<AsyncUnit> onAnimatorMoves;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onAnimatorIK, onAnimatorIKs, onAnimatorMove, onAnimatorMoves);
+        }
+
+
+        void OnAnimatorIK(int layerIndex)
+        {
+            TrySetResult(onAnimatorIK, onAnimatorIKs, layerIndex);
+        }
+
+
+        public UniTask OnAnimatorIKAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onAnimatorIK, ref onAnimatorIKs, cancellationToken);
+        }
+
+
+        void OnAnimatorMove()
+        {
+            TrySetResult(onAnimatorMove, onAnimatorMoves, AsyncUnit.Default);
+        }
+
+
+        public UniTask OnAnimatorMoveAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onAnimatorMove, ref onAnimatorMoves, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncAnimatorTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncAnimatorTrigger.cs.meta
new file mode 100644
index 0000000..29b2826
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncAnimatorTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ae912c37ac7f4cd42b25f22452435103
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncAwakeTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncAwakeTrigger.cs
new file mode 100644
index 0000000..0710dcb
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncAwakeTrigger.cs
@@ -0,0 +1,55 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using UnityEngine;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncAwakeTrigger : MonoBehaviour
+    {
+        bool called = false;
+        UniTaskCompletionSource promise;
+
+        void Awake()
+        {
+            called = true;
+            promise?.TrySetResult();
+        }
+
+        public UniTask AwakeAsync()
+        {
+            if (called) return UniTask.CompletedTask;
+            PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, new AwakeMonitor(this));
+            return new UniTask(promise ?? (promise = new UniTaskCompletionSource()));
+        }
+
+        private void OnDestroy()
+        {
+            promise?.TrySetCanceled();
+        }
+
+        class AwakeMonitor : IPlayerLoopItem
+        {
+            readonly AsyncAwakeTrigger trigger;
+
+            public AwakeMonitor(AsyncAwakeTrigger trigger)
+            {
+                this.trigger = trigger;
+            }
+
+            public bool MoveNext()
+            {
+                if (trigger.called) return false;
+                if (trigger == null)
+                {
+                    trigger.OnDestroy();
+                    return false;
+                }
+                return true;
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/Triggers/AsyncAwakeTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncAwakeTrigger.cs.meta
new file mode 100644
index 0000000..097fdb6
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncAwakeTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ef2840a2586894741a0ae211b8fd669b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncBeginDragTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncBeginDragTrigger.cs
new file mode 100644
index 0000000..bef1037
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncBeginDragTrigger.cs
@@ -0,0 +1,41 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncBeginDragTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<PointerEventData> onBeginDrag;
+        AsyncTriggerPromiseDictionary<PointerEventData> onBeginDrags;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onBeginDrag, onBeginDrags);
+        }
+
+
+        void OnBeginDrag(PointerEventData eventData)
+        {
+            TrySetResult(onBeginDrag, onBeginDrags, eventData);
+        }
+
+
+        public UniTask OnBeginDragAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onBeginDrag, ref onBeginDrags, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncBeginDragTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncBeginDragTrigger.cs.meta
new file mode 100644
index 0000000..d4a44e9
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncBeginDragTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 171fd2191eb22af4fbd92b51815ca757
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncCancelTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncCancelTrigger.cs
new file mode 100644
index 0000000..f484e59
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncCancelTrigger.cs
@@ -0,0 +1,41 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncCancelTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<BaseEventData> onCancel;
+        AsyncTriggerPromiseDictionary<BaseEventData> onCancels;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onCancel, onCancels);
+        }
+
+
+        void OnCancel(BaseEventData eventData)
+        {
+            TrySetResult(onCancel, onCancels, eventData);
+        }
+
+
+        public UniTask OnCancelAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onCancel, ref onCancels, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncCancelTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncCancelTrigger.cs.meta
new file mode 100644
index 0000000..285efd5
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncCancelTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 291886b6e5f2d044a85b2a4dedcaca97
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncCanvasGroupChangedTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncCanvasGroupChangedTrigger.cs
new file mode 100644
index 0000000..98fb776
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncCanvasGroupChangedTrigger.cs
@@ -0,0 +1,41 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncCanvasGroupChangedTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<AsyncUnit> onCanvasGroupChanged;
+        AsyncTriggerPromiseDictionary<AsyncUnit> onCanvasGroupChangeds;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onCanvasGroupChanged, onCanvasGroupChangeds);
+        }
+
+
+        void OnCanvasGroupChanged()
+        {
+            TrySetResult(onCanvasGroupChanged, onCanvasGroupChangeds, AsyncUnit.Default);
+        }
+
+
+        public UniTask OnCanvasGroupChangedAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onCanvasGroupChanged, ref onCanvasGroupChangeds, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncCanvasGroupChangedTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncCanvasGroupChangedTrigger.cs.meta
new file mode 100644
index 0000000..d0ebc56
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncCanvasGroupChangedTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: eddba832648f83046a320ffcacfc771d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncCollision2DTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncCollision2DTrigger.cs
new file mode 100644
index 0000000..c3f0c9c
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncCollision2DTrigger.cs
@@ -0,0 +1,69 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncCollision2DTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<Collision2D> onCollisionEnter2D;
+        AsyncTriggerPromiseDictionary<Collision2D> onCollisionEnter2Ds;
+        AsyncTriggerPromise<Collision2D> onCollisionExit2D;
+        AsyncTriggerPromiseDictionary<Collision2D> onCollisionExit2Ds;
+        AsyncTriggerPromise<Collision2D> onCollisionStay2D;
+        AsyncTriggerPromiseDictionary<Collision2D> onCollisionStay2Ds;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onCollisionEnter2D, onCollisionEnter2Ds, onCollisionExit2D, onCollisionExit2Ds, onCollisionStay2D, onCollisionStay2Ds);
+        }
+
+
+        void OnCollisionEnter2D(Collision2D coll)
+        {
+            TrySetResult(onCollisionEnter2D, onCollisionEnter2Ds, coll);
+        }
+
+
+        public UniTask OnCollisionEnter2DAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onCollisionEnter2D, ref onCollisionEnter2Ds, cancellationToken);
+        }
+
+
+        void OnCollisionExit2D(Collision2D coll)
+        {
+            TrySetResult(onCollisionExit2D, onCollisionExit2Ds, coll);
+        }
+
+
+        public UniTask OnCollisionExit2DAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onCollisionExit2D, ref onCollisionExit2Ds, cancellationToken);
+        }
+
+
+        void OnCollisionStay2D(Collision2D coll)
+        {
+            TrySetResult(onCollisionStay2D, onCollisionStay2Ds, coll);
+        }
+
+
+        public UniTask OnCollisionStay2DAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onCollisionStay2D, ref onCollisionStay2Ds, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncCollision2DTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncCollision2DTrigger.cs.meta
new file mode 100644
index 0000000..ad81300
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncCollision2DTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fbeb63f69bedec44f8003730887f914b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncCollisionTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncCollisionTrigger.cs
new file mode 100644
index 0000000..3534c69
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncCollisionTrigger.cs
@@ -0,0 +1,69 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncCollisionTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<Collision> onCollisionEnter;
+        AsyncTriggerPromiseDictionary<Collision> onCollisionEnters;
+        AsyncTriggerPromise<Collision> onCollisionExit;
+        AsyncTriggerPromiseDictionary<Collision> onCollisionExits;
+        AsyncTriggerPromise<Collision> onCollisionStay;
+        AsyncTriggerPromiseDictionary<Collision> onCollisionStays;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onCollisionEnter, onCollisionEnters, onCollisionExit, onCollisionExits, onCollisionStay, onCollisionStays);
+        }
+
+
+        void OnCollisionEnter(Collision collision)
+        {
+            TrySetResult(onCollisionEnter, onCollisionEnters, collision);
+        }
+
+
+        public UniTask OnCollisionEnterAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onCollisionEnter, ref onCollisionEnters, cancellationToken);
+        }
+
+
+        void OnCollisionExit(Collision collisionInfo)
+        {
+            TrySetResult(onCollisionExit, onCollisionExits, collisionInfo);
+        }
+
+
+        public UniTask OnCollisionExitAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onCollisionExit, ref onCollisionExits, cancellationToken);
+        }
+
+
+        void OnCollisionStay(Collision collisionInfo)
+        {
+            TrySetResult(onCollisionStay, onCollisionStays, collisionInfo);
+        }
+
+
+        public UniTask OnCollisionStayAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onCollisionStay, ref onCollisionStays, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncCollisionTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncCollisionTrigger.cs.meta
new file mode 100644
index 0000000..ebcc28e
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncCollisionTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 72db4a683be8f6a428823502599014a9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncDeselectTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncDeselectTrigger.cs
new file mode 100644
index 0000000..18ac7d0
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncDeselectTrigger.cs
@@ -0,0 +1,41 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncDeselectTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<BaseEventData> onDeselect;
+        AsyncTriggerPromiseDictionary<BaseEventData> onDeselects;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onDeselect, onDeselects);
+        }
+
+
+        void OnDeselect(BaseEventData eventData)
+        {
+            TrySetResult(onDeselect, onDeselects, eventData);
+        }
+
+
+        public UniTask OnDeselectAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onDeselect, ref onDeselects, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncDeselectTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncDeselectTrigger.cs.meta
new file mode 100644
index 0000000..9509524
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncDeselectTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 30faa9be5bd883e488bdc52f4825c4da
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncDestroyTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncDestroyTrigger.cs
new file mode 100644
index 0000000..f5a6ed6
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncDestroyTrigger.cs
@@ -0,0 +1,93 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Threading;
+using UniRx.Async.Internal;
+using UnityEngine;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncDestroyTrigger : MonoBehaviour
+    {
+        bool called = false;
+        UniTaskCompletionSource promise;
+        CancellationTokenSource cancellationTokenSource; // main cancellation
+        object canellationTokenSourceOrQueue;            // external from AddCancellationTriggerOnDestory
+
+        public CancellationToken CancellationToken
+        {
+            get
+            {
+                if (cancellationTokenSource == null)
+                {
+                    cancellationTokenSource = new CancellationTokenSource();
+                }
+                return cancellationTokenSource.Token;
+            }
+        }
+
+        /// <summary>This function is called when the MonoBehaviour will be destroyed.</summary>
+        void OnDestroy()
+        {
+            called = true;
+            promise?.TrySetResult();
+            cancellationTokenSource?.Cancel();
+            cancellationTokenSource?.Dispose();
+            if (canellationTokenSourceOrQueue != null)
+            {
+                if (canellationTokenSourceOrQueue is CancellationTokenSource cts)
+                {
+                    cts.Cancel();
+                    cts.Dispose();
+                }
+                else
+                {
+                    var q = (MinimumQueue<CancellationTokenSource>)canellationTokenSourceOrQueue;
+                    while (q.Count != 0)
+                    {
+                        var c = q.Dequeue();
+                        c.Cancel();
+                        c.Dispose();
+                    }
+                }
+                canellationTokenSourceOrQueue = null;
+            }
+        }
+
+        /// <summary>This function is called when the MonoBehaviour will be destroyed.</summary>
+        public UniTask OnDestroyAsync()
+        {
+            if (called) return UniTask.CompletedTask;
+            return new UniTask(promise ?? (promise = new UniTaskCompletionSource()));
+        }
+
+        /// <summary>Add Cancellation Triggers on destroy</summary>
+        public void AddCancellationTriggerOnDestory(CancellationTokenSource cts)
+        {
+            if (called)
+            {
+                cts.Cancel();
+                cts.Dispose();
+            }
+
+            if (canellationTokenSourceOrQueue == null)
+            {
+                canellationTokenSourceOrQueue = cts;
+            }
+            else if (canellationTokenSourceOrQueue is CancellationTokenSource c)
+            {
+                var q = new MinimumQueue<CancellationTokenSource>(4);
+                q.Enqueue(c);
+                q.Enqueue(cts);
+                canellationTokenSourceOrQueue = q;
+            }
+            else
+            {
+                ((MinimumQueue<CancellationTokenSource>)canellationTokenSourceOrQueue).Enqueue(cts);
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/Triggers/AsyncDestroyTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncDestroyTrigger.cs.meta
new file mode 100644
index 0000000..6450049
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncDestroyTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f4afdcb1cbadf954ba8b1cf465429e17
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncDragTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncDragTrigger.cs
new file mode 100644
index 0000000..46ad8d9
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncDragTrigger.cs
@@ -0,0 +1,41 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncDragTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<PointerEventData> onDrag;
+        AsyncTriggerPromiseDictionary<PointerEventData> onDrags;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onDrag, onDrags);
+        }
+
+
+        void OnDrag(PointerEventData eventData)
+        {
+            TrySetResult(onDrag, onDrags, eventData);
+        }
+
+
+        public UniTask OnDragAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onDrag, ref onDrags, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncDragTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncDragTrigger.cs.meta
new file mode 100644
index 0000000..d259f40
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncDragTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 52242547ba60ea74f8a2e3bbab5fcdfa
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncDropTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncDropTrigger.cs
new file mode 100644
index 0000000..8993952
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncDropTrigger.cs
@@ -0,0 +1,41 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncDropTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<PointerEventData> onDrop;
+        AsyncTriggerPromiseDictionary<PointerEventData> onDrops;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onDrop, onDrops);
+        }
+
+
+        void OnDrop(PointerEventData eventData)
+        {
+            TrySetResult(onDrop, onDrops, eventData);
+        }
+
+
+        public UniTask OnDropAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onDrop, ref onDrops, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncDropTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncDropTrigger.cs.meta
new file mode 100644
index 0000000..2a15847
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncDropTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 42d65fd5e4be25f41a927eca25b0acf7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncEnableDisableTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncEnableDisableTrigger.cs
new file mode 100644
index 0000000..092b97f
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncEnableDisableTrigger.cs
@@ -0,0 +1,55 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncEnableDisableTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<AsyncUnit> onEnable;
+        AsyncTriggerPromiseDictionary<AsyncUnit> onEnables;
+        AsyncTriggerPromise<AsyncUnit> onDisable;
+        AsyncTriggerPromiseDictionary<AsyncUnit> onDisables;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onEnable, onEnables, onDisable, onDisables);
+        }
+
+
+        void OnEnable()
+        {
+            TrySetResult(onEnable, onEnables, AsyncUnit.Default);
+        }
+
+
+        public UniTask OnEnableAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onEnable, ref onEnables, cancellationToken);
+        }
+
+
+        void OnDisable()
+        {
+            TrySetResult(onDisable, onDisables, AsyncUnit.Default);
+        }
+
+
+        public UniTask OnDisableAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onDisable, ref onDisables, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncEnableDisableTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncEnableDisableTrigger.cs.meta
new file mode 100644
index 0000000..8e61a0f
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncEnableDisableTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d0bf9142b63b4cb43b693f0b83b3dbe7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncEndDragTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncEndDragTrigger.cs
new file mode 100644
index 0000000..cbaa823
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncEndDragTrigger.cs
@@ -0,0 +1,41 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncEndDragTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<PointerEventData> onEndDrag;
+        AsyncTriggerPromiseDictionary<PointerEventData> onEndDrags;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onEndDrag, onEndDrags);
+        }
+
+
+        void OnEndDrag(PointerEventData eventData)
+        {
+            TrySetResult(onEndDrag, onEndDrags, eventData);
+        }
+
+
+        public UniTask OnEndDragAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onEndDrag, ref onEndDrags, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncEndDragTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncEndDragTrigger.cs.meta
new file mode 100644
index 0000000..98f67b8
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncEndDragTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8298d43de348acc4aa4e7dbf30472dbf
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncEventTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncEventTrigger.cs
new file mode 100644
index 0000000..218fedc
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncEventTrigger.cs
@@ -0,0 +1,264 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncEventTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<BaseEventData> onDeselect;
+        AsyncTriggerPromiseDictionary<BaseEventData> onDeselects;
+        AsyncTriggerPromise<AxisEventData> onMove;
+        AsyncTriggerPromiseDictionary<AxisEventData> onMoves;
+        AsyncTriggerPromise<PointerEventData> onPointerDown;
+        AsyncTriggerPromiseDictionary<PointerEventData> onPointerDowns;
+        AsyncTriggerPromise<PointerEventData> onPointerEnter;
+        AsyncTriggerPromiseDictionary<PointerEventData> onPointerEnters;
+        AsyncTriggerPromise<PointerEventData> onPointerExit;
+        AsyncTriggerPromiseDictionary<PointerEventData> onPointerExits;
+        AsyncTriggerPromise<PointerEventData> onPointerUp;
+        AsyncTriggerPromiseDictionary<PointerEventData> onPointerUps;
+        AsyncTriggerPromise<BaseEventData> onSelect;
+        AsyncTriggerPromiseDictionary<BaseEventData> onSelects;
+        AsyncTriggerPromise<PointerEventData> onPointerClick;
+        AsyncTriggerPromiseDictionary<PointerEventData> onPointerClicks;
+        AsyncTriggerPromise<BaseEventData> onSubmit;
+        AsyncTriggerPromiseDictionary<BaseEventData> onSubmits;
+        AsyncTriggerPromise<PointerEventData> onDrag;
+        AsyncTriggerPromiseDictionary<PointerEventData> onDrags;
+        AsyncTriggerPromise<PointerEventData> onBeginDrag;
+        AsyncTriggerPromiseDictionary<PointerEventData> onBeginDrags;
+        AsyncTriggerPromise<PointerEventData> onEndDrag;
+        AsyncTriggerPromiseDictionary<PointerEventData> onEndDrags;
+        AsyncTriggerPromise<PointerEventData> onDrop;
+        AsyncTriggerPromiseDictionary<PointerEventData> onDrops;
+        AsyncTriggerPromise<BaseEventData> onUpdateSelected;
+        AsyncTriggerPromiseDictionary<BaseEventData> onUpdateSelecteds;
+        AsyncTriggerPromise<PointerEventData> onInitializePotentialDrag;
+        AsyncTriggerPromiseDictionary<PointerEventData> onInitializePotentialDrags;
+        AsyncTriggerPromise<BaseEventData> onCancel;
+        AsyncTriggerPromiseDictionary<BaseEventData> onCancels;
+        AsyncTriggerPromise<PointerEventData> onScroll;
+        AsyncTriggerPromiseDictionary<PointerEventData> onScrolls;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onDeselect, onDeselects, onMove, onMoves, onPointerDown, onPointerDowns, onPointerEnter, onPointerEnters, onPointerExit, onPointerExits, onPointerUp, onPointerUps, onSelect, onSelects, onPointerClick, onPointerClicks, onSubmit, onSubmits, onDrag, onDrags, onBeginDrag, onBeginDrags, onEndDrag, onEndDrags, onDrop, onDrops, onUpdateSelected, onUpdateSelecteds, onInitializePotentialDrag, onInitializePotentialDrags, onCancel, onCancels, onScroll, onScrolls);
+        }
+
+        void OnDeselect(BaseEventData eventData)
+        {
+            TrySetResult(onDeselect, onDeselects, eventData);
+        }
+
+
+        public UniTask OnDeselectAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onDeselect, ref onDeselects, cancellationToken);
+        }
+
+
+        void OnMove(AxisEventData eventData)
+        {
+            TrySetResult(onMove, onMoves, eventData);
+        }
+
+
+        public UniTask OnMoveAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onMove, ref onMoves, cancellationToken);
+        }
+
+
+        void OnPointerDown(PointerEventData eventData)
+        {
+            TrySetResult(onPointerDown, onPointerDowns, eventData);
+        }
+
+
+        public UniTask OnPointerDownAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onPointerDown, ref onPointerDowns, cancellationToken);
+        }
+
+
+        void OnPointerEnter(PointerEventData eventData)
+        {
+            TrySetResult(onPointerEnter, onPointerEnters, eventData);
+        }
+
+
+        public UniTask OnPointerEnterAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onPointerEnter, ref onPointerEnters, cancellationToken);
+        }
+
+
+        void OnPointerExit(PointerEventData eventData)
+        {
+            TrySetResult(onPointerExit, onPointerExits, eventData);
+        }
+
+
+        public UniTask OnPointerExitAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onPointerExit, ref onPointerExits, cancellationToken);
+        }
+
+
+        void OnPointerUp(PointerEventData eventData)
+        {
+            TrySetResult(onPointerUp, onPointerUps, eventData);
+        }
+
+
+        public UniTask OnPointerUpAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onPointerUp, ref onPointerUps, cancellationToken);
+        }
+
+
+        void OnSelect(BaseEventData eventData)
+        {
+            TrySetResult(onSelect, onSelects, eventData);
+        }
+
+
+        public UniTask OnSelectAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onSelect, ref onSelects, cancellationToken);
+        }
+
+
+        void OnPointerClick(PointerEventData eventData)
+        {
+            TrySetResult(onPointerClick, onPointerClicks, eventData);
+        }
+
+
+        public UniTask OnPointerClickAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onPointerClick, ref onPointerClicks, cancellationToken);
+        }
+
+
+        void OnSubmit(BaseEventData eventData)
+        {
+            TrySetResult(onSubmit, onSubmits, eventData);
+        }
+
+
+        public UniTask OnSubmitAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onSubmit, ref onSubmits, cancellationToken);
+        }
+
+
+        void OnDrag(PointerEventData eventData)
+        {
+            TrySetResult(onDrag, onDrags, eventData);
+        }
+
+
+        public UniTask OnDragAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onDrag, ref onDrags, cancellationToken);
+        }
+
+
+        void OnBeginDrag(PointerEventData eventData)
+        {
+            TrySetResult(onBeginDrag, onBeginDrags, eventData);
+        }
+
+
+        public UniTask OnBeginDragAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onBeginDrag, ref onBeginDrags, cancellationToken);
+        }
+
+
+        void OnEndDrag(PointerEventData eventData)
+        {
+            TrySetResult(onEndDrag, onEndDrags, eventData);
+        }
+
+
+        public UniTask OnEndDragAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onEndDrag, ref onEndDrags, cancellationToken);
+        }
+
+
+        void OnDrop(PointerEventData eventData)
+        {
+            TrySetResult(onDrop, onDrops, eventData);
+        }
+
+
+        public UniTask OnDropAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onDrop, ref onDrops, cancellationToken);
+        }
+
+
+        void OnUpdateSelected(BaseEventData eventData)
+        {
+            TrySetResult(onUpdateSelected, onUpdateSelecteds, eventData);
+        }
+
+
+        public UniTask OnUpdateSelectedAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onUpdateSelected, ref onUpdateSelecteds, cancellationToken);
+        }
+
+
+        void OnInitializePotentialDrag(PointerEventData eventData)
+        {
+            TrySetResult(onInitializePotentialDrag, onInitializePotentialDrags, eventData);
+        }
+
+
+        public UniTask OnInitializePotentialDragAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onInitializePotentialDrag, ref onInitializePotentialDrags, cancellationToken);
+        }
+
+
+        void OnCancel(BaseEventData eventData)
+        {
+            TrySetResult(onCancel, onCancels, eventData);
+        }
+
+
+        public UniTask OnCancelAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onCancel, ref onCancels, cancellationToken);
+        }
+
+
+        void OnScroll(PointerEventData eventData)
+        {
+            TrySetResult(onScroll, onScrolls, eventData);
+        }
+
+
+        public UniTask OnScrollAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onScroll, ref onScrolls, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncEventTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncEventTrigger.cs.meta
new file mode 100644
index 0000000..c901478
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncEventTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 89997820797ad6d43b17971a8bd0d8fe
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncFixedUpdateTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncFixedUpdateTrigger.cs
new file mode 100644
index 0000000..8cfc821
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncFixedUpdateTrigger.cs
@@ -0,0 +1,41 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncFixedUpdateTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<AsyncUnit> fixedUpdate;
+        AsyncTriggerPromiseDictionary<AsyncUnit> fixedUpdates;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(fixedUpdate, fixedUpdates);
+        }
+
+
+        void FixedUpdate()
+        {
+            TrySetResult(fixedUpdate, fixedUpdates, AsyncUnit.Default);
+        }
+
+
+        public UniTask FixedUpdateAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref fixedUpdate, ref fixedUpdates, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncFixedUpdateTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncFixedUpdateTrigger.cs.meta
new file mode 100644
index 0000000..7154af6
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncFixedUpdateTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c74b906c4294aaa4e900f6e7f8b36df6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncInitializePotentialDragTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncInitializePotentialDragTrigger.cs
new file mode 100644
index 0000000..59e04b4
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncInitializePotentialDragTrigger.cs
@@ -0,0 +1,41 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncInitializePotentialDragTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<PointerEventData> onInitializePotentialDrag;
+        AsyncTriggerPromiseDictionary<PointerEventData> onInitializePotentialDrags;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onInitializePotentialDrag, onInitializePotentialDrags);
+        }
+
+
+        void OnInitializePotentialDrag(PointerEventData eventData)
+        {
+            TrySetResult(onInitializePotentialDrag, onInitializePotentialDrags, eventData);
+        }
+
+
+        public UniTask OnInitializePotentialDragAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onInitializePotentialDrag, ref onInitializePotentialDrags, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncInitializePotentialDragTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncInitializePotentialDragTrigger.cs.meta
new file mode 100644
index 0000000..0df8a5b
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncInitializePotentialDragTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ae0733adc239a324f8b934ffb119abd8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncJointTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncJointTrigger.cs
new file mode 100644
index 0000000..9321182
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncJointTrigger.cs
@@ -0,0 +1,55 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncJointTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<float> onJointBreak;
+        AsyncTriggerPromiseDictionary<float> onJointBreaks;
+        AsyncTriggerPromise<Joint2D> onJointBreak2D;
+        AsyncTriggerPromiseDictionary<Joint2D> onJointBreak2Ds;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onJointBreak, onJointBreaks, onJointBreak2D, onJointBreak2Ds);
+        }
+
+
+        void OnJointBreak(float breakForce)
+        {
+            TrySetResult(onJointBreak, onJointBreaks, breakForce);
+        }
+
+
+        public UniTask OnJointBreakAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onJointBreak, ref onJointBreaks, cancellationToken);
+        }
+
+
+        void OnJointBreak2D(Joint2D brokenJoint)
+        {
+            TrySetResult(onJointBreak2D, onJointBreak2Ds, brokenJoint);
+        }
+
+
+        public UniTask OnJointBreak2DAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onJointBreak2D, ref onJointBreak2Ds, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncJointTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncJointTrigger.cs.meta
new file mode 100644
index 0000000..8220736
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncJointTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 04dc74e7b2368094f9153921804a1fb7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncLateUpdateTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncLateUpdateTrigger.cs
new file mode 100644
index 0000000..e88dfd8
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncLateUpdateTrigger.cs
@@ -0,0 +1,41 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncLateUpdateTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<AsyncUnit> lateUpdate;
+        AsyncTriggerPromiseDictionary<AsyncUnit> lateUpdates;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(lateUpdate, lateUpdates);
+        }
+
+
+        void LateUpdate()
+        {
+            TrySetResult(lateUpdate, lateUpdates, AsyncUnit.Default);
+        }
+
+
+        public UniTask LateUpdateAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref lateUpdate, ref lateUpdates, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncLateUpdateTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncLateUpdateTrigger.cs.meta
new file mode 100644
index 0000000..391059d
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncLateUpdateTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a4fb2b4c09cb4ec4a82b934f2038eb36
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncMouseTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncMouseTrigger.cs
new file mode 100644
index 0000000..243fb00
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncMouseTrigger.cs
@@ -0,0 +1,129 @@
+
+#if !(UNITY_IPHONE || UNITY_ANDROID || UNITY_METRO)
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncMouseTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<AsyncUnit> onMouseDown;
+        AsyncTriggerPromiseDictionary<AsyncUnit> onMouseDowns;
+        AsyncTriggerPromise<AsyncUnit> onMouseDrag;
+        AsyncTriggerPromiseDictionary<AsyncUnit> onMouseDrags;
+        AsyncTriggerPromise<AsyncUnit> onMouseEnter;
+        AsyncTriggerPromiseDictionary<AsyncUnit> onMouseEnters;
+        AsyncTriggerPromise<AsyncUnit> onMouseExit;
+        AsyncTriggerPromiseDictionary<AsyncUnit> onMouseExits;
+        AsyncTriggerPromise<AsyncUnit> onMouseOver;
+        AsyncTriggerPromiseDictionary<AsyncUnit> onMouseOvers;
+        AsyncTriggerPromise<AsyncUnit> onMouseUp;
+        AsyncTriggerPromiseDictionary<AsyncUnit> onMouseUps;
+        AsyncTriggerPromise<AsyncUnit> onMouseUpAsButton;
+        AsyncTriggerPromiseDictionary<AsyncUnit> onMouseUpAsButtons;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onMouseDown, onMouseDowns, onMouseDrag, onMouseDrags, onMouseEnter, onMouseEnters, onMouseExit, onMouseExits, onMouseOver, onMouseOvers, onMouseUp, onMouseUps, onMouseUpAsButton, onMouseUpAsButtons);
+        }
+
+
+        void OnMouseDown()
+        {
+            TrySetResult(onMouseDown, onMouseDowns, AsyncUnit.Default);
+        }
+
+
+        public UniTask OnMouseDownAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onMouseDown, ref onMouseDowns, cancellationToken);
+        }
+
+
+        void OnMouseDrag()
+        {
+            TrySetResult(onMouseDrag, onMouseDrags, AsyncUnit.Default);
+        }
+
+
+        public UniTask OnMouseDragAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onMouseDrag, ref onMouseDrags, cancellationToken);
+        }
+
+
+        void OnMouseEnter()
+        {
+            TrySetResult(onMouseEnter, onMouseEnters, AsyncUnit.Default);
+        }
+
+
+        public UniTask OnMouseEnterAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onMouseEnter, ref onMouseEnters, cancellationToken);
+        }
+
+
+        void OnMouseExit()
+        {
+            TrySetResult(onMouseExit, onMouseExits, AsyncUnit.Default);
+        }
+
+
+        public UniTask OnMouseExitAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onMouseExit, ref onMouseExits, cancellationToken);
+        }
+
+
+        void OnMouseOver()
+        {
+            TrySetResult(onMouseOver, onMouseOvers, AsyncUnit.Default);
+        }
+
+
+        public UniTask OnMouseOverAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onMouseOver, ref onMouseOvers, cancellationToken);
+        }
+
+
+        void OnMouseUp()
+        {
+            TrySetResult(onMouseUp, onMouseUps, AsyncUnit.Default);
+        }
+
+
+        public UniTask OnMouseUpAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onMouseUp, ref onMouseUps, cancellationToken);
+        }
+
+
+        void OnMouseUpAsButton()
+        {
+            TrySetResult(onMouseUpAsButton, onMouseUpAsButtons, AsyncUnit.Default);
+        }
+
+
+        public UniTask OnMouseUpAsButtonAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onMouseUpAsButton, ref onMouseUpAsButtons, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
+
+#endif
diff --git a/Assets/UniRx.Async/Triggers/AsyncMouseTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncMouseTrigger.cs.meta
new file mode 100644
index 0000000..9e8706f
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncMouseTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 57ad5120e9c4d424484c963791467272
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncMoveTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncMoveTrigger.cs
new file mode 100644
index 0000000..cab098c
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncMoveTrigger.cs
@@ -0,0 +1,41 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncMoveTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<AxisEventData> onMove;
+        AsyncTriggerPromiseDictionary<AxisEventData> onMoves;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onMove, onMoves);
+        }
+
+
+        void OnMove(AxisEventData eventData)
+        {
+            TrySetResult(onMove, onMoves, eventData);
+        }
+
+
+        public UniTask OnMoveAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onMove, ref onMoves, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncMoveTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncMoveTrigger.cs.meta
new file mode 100644
index 0000000..2ea01b7
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncMoveTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1699926e875c24d4aa34bc8817f96f0e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncParticleTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncParticleTrigger.cs
new file mode 100644
index 0000000..4e22b36
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncParticleTrigger.cs
@@ -0,0 +1,41 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncParticleTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<GameObject> onParticleCollision;
+        AsyncTriggerPromiseDictionary<GameObject> onParticleCollisions;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onParticleCollision, onParticleCollisions);
+        }
+
+
+        void OnParticleCollision(GameObject other)
+        {
+            TrySetResult(onParticleCollision, onParticleCollisions, other);
+        }
+
+
+        public UniTask OnParticleCollisionAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onParticleCollision, ref onParticleCollisions, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncParticleTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncParticleTrigger.cs.meta
new file mode 100644
index 0000000..4a162c7
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncParticleTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 27d3f2efd47fb1d4fb2e9130f97ea8aa
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncPointerClickTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncPointerClickTrigger.cs
new file mode 100644
index 0000000..64b902d
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncPointerClickTrigger.cs
@@ -0,0 +1,41 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncPointerClickTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<PointerEventData> onPointerClick;
+        AsyncTriggerPromiseDictionary<PointerEventData> onPointerClicks;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onPointerClick, onPointerClicks);
+        }
+
+
+        void OnPointerClick(PointerEventData eventData)
+        {
+            TrySetResult(onPointerClick, onPointerClicks, eventData);
+        }
+
+
+        public UniTask OnPointerClickAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onPointerClick, ref onPointerClicks, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncPointerClickTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncPointerClickTrigger.cs.meta
new file mode 100644
index 0000000..67447a7
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncPointerClickTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9f8865abf2db3d248b3730cdb18bb8b7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncPointerDownTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncPointerDownTrigger.cs
new file mode 100644
index 0000000..2e32bfc
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncPointerDownTrigger.cs
@@ -0,0 +1,41 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncPointerDownTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<PointerEventData> onPointerDown;
+        AsyncTriggerPromiseDictionary<PointerEventData> onPointerDowns;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onPointerDown, onPointerDowns);
+        }
+
+
+        void OnPointerDown(PointerEventData eventData)
+        {
+            TrySetResult(onPointerDown, onPointerDowns, eventData);
+        }
+
+
+        public UniTask OnPointerDownAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onPointerDown, ref onPointerDowns, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncPointerDownTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncPointerDownTrigger.cs.meta
new file mode 100644
index 0000000..851cfe4
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncPointerDownTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7c5132395605eaa498a7efedee5acdd7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncPointerEnterTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncPointerEnterTrigger.cs
new file mode 100644
index 0000000..36ed2e3
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncPointerEnterTrigger.cs
@@ -0,0 +1,41 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncPointerEnterTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<PointerEventData> onPointerEnter;
+        AsyncTriggerPromiseDictionary<PointerEventData> onPointerEnters;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onPointerEnter, onPointerEnters);
+        }
+
+
+        void OnPointerEnter(PointerEventData eventData)
+        {
+            TrySetResult(onPointerEnter, onPointerEnters, eventData);
+        }
+
+
+        public UniTask OnPointerEnterAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onPointerEnter, ref onPointerEnters, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncPointerEnterTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncPointerEnterTrigger.cs.meta
new file mode 100644
index 0000000..9a01b93
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncPointerEnterTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 18887d476d48533498efd14224a2f651
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncPointerExitTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncPointerExitTrigger.cs
new file mode 100644
index 0000000..3cf2575
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncPointerExitTrigger.cs
@@ -0,0 +1,41 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncPointerExitTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<PointerEventData> onPointerExit;
+        AsyncTriggerPromiseDictionary<PointerEventData> onPointerExits;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onPointerExit, onPointerExits);
+        }
+
+
+        void OnPointerExit(PointerEventData eventData)
+        {
+            TrySetResult(onPointerExit, onPointerExits, eventData);
+        }
+
+
+        public UniTask OnPointerExitAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onPointerExit, ref onPointerExits, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncPointerExitTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncPointerExitTrigger.cs.meta
new file mode 100644
index 0000000..39ab381
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncPointerExitTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9e3ed09876a11a84794795809ebee243
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncPointerUpTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncPointerUpTrigger.cs
new file mode 100644
index 0000000..4f56fa9
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncPointerUpTrigger.cs
@@ -0,0 +1,41 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncPointerUpTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<PointerEventData> onPointerUp;
+        AsyncTriggerPromiseDictionary<PointerEventData> onPointerUps;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onPointerUp, onPointerUps);
+        }
+
+
+        void OnPointerUp(PointerEventData eventData)
+        {
+            TrySetResult(onPointerUp, onPointerUps, eventData);
+        }
+
+
+        public UniTask OnPointerUpAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onPointerUp, ref onPointerUps, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncPointerUpTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncPointerUpTrigger.cs.meta
new file mode 100644
index 0000000..7be4e27
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncPointerUpTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7a0493ea32f81314cbbaf2b635ba3167
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncRectTransformTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncRectTransformTrigger.cs
new file mode 100644
index 0000000..4fab679
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncRectTransformTrigger.cs
@@ -0,0 +1,55 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncRectTransformTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<AsyncUnit> onRectTransformDimensionsChange;
+        AsyncTriggerPromiseDictionary<AsyncUnit> onRectTransformDimensionsChanges;
+        AsyncTriggerPromise<AsyncUnit> onRectTransformRemoved;
+        AsyncTriggerPromiseDictionary<AsyncUnit> onRectTransformRemoveds;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onRectTransformDimensionsChange, onRectTransformDimensionsChanges, onRectTransformRemoved, onRectTransformRemoveds);
+        }
+
+
+        void OnRectTransformDimensionsChange()
+        {
+            TrySetResult(onRectTransformDimensionsChange, onRectTransformDimensionsChanges, AsyncUnit.Default);
+        }
+
+
+        public UniTask OnRectTransformDimensionsChangeAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onRectTransformDimensionsChange, ref onRectTransformDimensionsChanges, cancellationToken);
+        }
+
+
+        void OnRectTransformRemoved()
+        {
+            TrySetResult(onRectTransformRemoved, onRectTransformRemoveds, AsyncUnit.Default);
+        }
+
+
+        public UniTask OnRectTransformRemovedAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onRectTransformRemoved, ref onRectTransformRemoveds, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncRectTransformTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncRectTransformTrigger.cs.meta
new file mode 100644
index 0000000..98c4f70
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncRectTransformTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: dfe3470221c66c84397c0783c62b24e7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncScrollTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncScrollTrigger.cs
new file mode 100644
index 0000000..7a28c64
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncScrollTrigger.cs
@@ -0,0 +1,41 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncScrollTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<PointerEventData> onScroll;
+        AsyncTriggerPromiseDictionary<PointerEventData> onScrolls;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onScroll, onScrolls);
+        }
+
+
+        void OnScroll(PointerEventData eventData)
+        {
+            TrySetResult(onScroll, onScrolls, eventData);
+        }
+
+
+        public UniTask OnScrollAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onScroll, ref onScrolls, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncScrollTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncScrollTrigger.cs.meta
new file mode 100644
index 0000000..541bdbe
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncScrollTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7c751e9d3deb97d4d8691a8a583c2afd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncSelectTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncSelectTrigger.cs
new file mode 100644
index 0000000..093ec79
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncSelectTrigger.cs
@@ -0,0 +1,41 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncSelectTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<BaseEventData> onSelect;
+        AsyncTriggerPromiseDictionary<BaseEventData> onSelects;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onSelect, onSelects);
+        }
+
+
+        void OnSelect(BaseEventData eventData)
+        {
+            TrySetResult(onSelect, onSelects, eventData);
+        }
+
+
+        public UniTask OnSelectAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onSelect, ref onSelects, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncSelectTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncSelectTrigger.cs.meta
new file mode 100644
index 0000000..dd4563b
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncSelectTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fcc2347251a4fc5498a03f0c17382920
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncStartTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncStartTrigger.cs
new file mode 100644
index 0000000..4c65c8c
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncStartTrigger.cs
@@ -0,0 +1,64 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using UnityEngine;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncStartTrigger : MonoBehaviour
+    {
+        bool awakeCalled = false;
+        bool called = false;
+        UniTaskCompletionSource promise;
+
+        void Awake()
+        {
+            awakeCalled = true;
+        }
+
+        void Start()
+        {
+            called = true;
+            promise?.TrySetResult();
+        }
+
+        public UniTask StartAsync()
+        {
+            if (called) return UniTask.CompletedTask;
+            if (!awakeCalled)
+            {
+                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, new AwakeMonitor(this));
+            }
+            return new UniTask(promise ?? (promise = new UniTaskCompletionSource()));
+        }
+
+        private void OnDestroy()
+        {
+            promise?.TrySetCanceled();
+        }
+
+        class AwakeMonitor : IPlayerLoopItem
+        {
+            readonly AsyncStartTrigger trigger;
+
+            public AwakeMonitor(AsyncStartTrigger trigger)
+            {
+                this.trigger = trigger;
+            }
+
+            public bool MoveNext()
+            {
+                if (trigger.awakeCalled) return false;
+                if (trigger == null)
+                {
+                    trigger.OnDestroy();
+                    return false;
+                }
+                return true;
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/Triggers/AsyncStartTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncStartTrigger.cs.meta
new file mode 100644
index 0000000..9ef06e8
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncStartTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b4fd0f75e54ec3d4fbcb7fc65b11646b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncSubmitTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncSubmitTrigger.cs
new file mode 100644
index 0000000..0dd4206
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncSubmitTrigger.cs
@@ -0,0 +1,41 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncSubmitTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<BaseEventData> onSubmit;
+        AsyncTriggerPromiseDictionary<BaseEventData> onSubmits;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onSubmit, onSubmits);
+        }
+
+
+        void OnSubmit(BaseEventData eventData)
+        {
+            TrySetResult(onSubmit, onSubmits, eventData);
+        }
+
+
+        public UniTask OnSubmitAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onSubmit, ref onSubmits, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncSubmitTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncSubmitTrigger.cs.meta
new file mode 100644
index 0000000..16b6b05
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncSubmitTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 97e85abc2d7ec0c44adfbe5ee971aad3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncTransformChangedTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncTransformChangedTrigger.cs
new file mode 100644
index 0000000..acad97e
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncTransformChangedTrigger.cs
@@ -0,0 +1,69 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncTransformChangedTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<AsyncUnit> onBeforeTransformParentChanged;
+        AsyncTriggerPromiseDictionary<AsyncUnit> onBeforeTransformParentChangeds;
+        AsyncTriggerPromise<AsyncUnit> onTransformParentChanged;
+        AsyncTriggerPromiseDictionary<AsyncUnit> onTransformParentChangeds;
+        AsyncTriggerPromise<AsyncUnit> onTransformChildrenChanged;
+        AsyncTriggerPromiseDictionary<AsyncUnit> onTransformChildrenChangeds;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onBeforeTransformParentChanged, onBeforeTransformParentChangeds, onTransformParentChanged, onTransformParentChangeds, onTransformChildrenChanged, onTransformChildrenChangeds);
+        }
+
+
+        void OnBeforeTransformParentChanged()
+        {
+            TrySetResult(onBeforeTransformParentChanged, onBeforeTransformParentChangeds, AsyncUnit.Default);
+        }
+
+
+        public UniTask OnBeforeTransformParentChangedAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onBeforeTransformParentChanged, ref onBeforeTransformParentChangeds, cancellationToken);
+        }
+
+
+        void OnTransformParentChanged()
+        {
+            TrySetResult(onTransformParentChanged, onTransformParentChangeds, AsyncUnit.Default);
+        }
+
+
+        public UniTask OnTransformParentChangedAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onTransformParentChanged, ref onTransformParentChangeds, cancellationToken);
+        }
+
+
+        void OnTransformChildrenChanged()
+        {
+            TrySetResult(onTransformChildrenChanged, onTransformChildrenChangeds, AsyncUnit.Default);
+        }
+
+
+        public UniTask OnTransformChildrenChangedAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onTransformChildrenChanged, ref onTransformChildrenChangeds, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncTransformChangedTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncTransformChangedTrigger.cs.meta
new file mode 100644
index 0000000..60b6c38
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncTransformChangedTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 053f983cd760f5e4394be8fd657243c1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncTrigger2DTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncTrigger2DTrigger.cs
new file mode 100644
index 0000000..dc33415
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncTrigger2DTrigger.cs
@@ -0,0 +1,69 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncTrigger2DTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<Collider2D> onTriggerEnter2D;
+        AsyncTriggerPromiseDictionary<Collider2D> onTriggerEnter2Ds;
+        AsyncTriggerPromise<Collider2D> onTriggerExit2D;
+        AsyncTriggerPromiseDictionary<Collider2D> onTriggerExit2Ds;
+        AsyncTriggerPromise<Collider2D> onTriggerStay2D;
+        AsyncTriggerPromiseDictionary<Collider2D> onTriggerStay2Ds;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onTriggerEnter2D, onTriggerEnter2Ds, onTriggerExit2D, onTriggerExit2Ds, onTriggerStay2D, onTriggerStay2Ds);
+        }
+
+
+        void OnTriggerEnter2D(Collider2D other)
+        {
+            TrySetResult(onTriggerEnter2D, onTriggerEnter2Ds, other);
+        }
+
+
+        public UniTask OnTriggerEnter2DAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onTriggerEnter2D, ref onTriggerEnter2Ds, cancellationToken);
+        }
+
+
+        void OnTriggerExit2D(Collider2D other)
+        {
+            TrySetResult(onTriggerExit2D, onTriggerExit2Ds, other);
+        }
+
+
+        public UniTask OnTriggerExit2DAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onTriggerExit2D, ref onTriggerExit2Ds, cancellationToken);
+        }
+
+
+        void OnTriggerStay2D(Collider2D other)
+        {
+            TrySetResult(onTriggerStay2D, onTriggerStay2Ds, other);
+        }
+
+
+        public UniTask OnTriggerStay2DAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onTriggerStay2D, ref onTriggerStay2Ds, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncTrigger2DTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncTrigger2DTrigger.cs.meta
new file mode 100644
index 0000000..8d88bad
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncTrigger2DTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 102f8eba36bc2a54e878e67aca9686e5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncTriggerBase.cs b/Assets/UniRx.Async/Triggers/AsyncTriggerBase.cs
new file mode 100644
index 0000000..ceb4f7f
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncTriggerBase.cs
@@ -0,0 +1,271 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using UniRx.Async.Internal;
+using UnityEngine;
+
+namespace UniRx.Async.Triggers
+{
+    public interface ICancelablePromise
+    {
+        CancellationToken RegisteredCancellationToken { get; }
+        bool TrySetCanceled();
+    }
+
+    public class AsyncTriggerPromise<T> : ReusablePromise<T>, IPromise<T>, ICancelablePromise
+    {
+        public CancellationToken RegisteredCancellationToken { get; private set; }
+
+        public AsyncTriggerPromise()
+            : this(CancellationToken.None)
+        {
+        }
+
+        public AsyncTriggerPromise(CancellationToken cancellationToken)
+        {
+            this.RegisteredCancellationToken = cancellationToken;
+            TaskTracker.TrackActiveTask(this);
+        }
+
+        public override T GetResult()
+        {
+            if (Status == AwaiterStatus.Pending) return RawResult;
+            return base.GetResult();
+        }
+
+        public override bool TrySetResult(T result)
+        {
+            if (Status == AwaiterStatus.Pending)
+            {
+                // keep status as Pending.
+                this.ForceSetResult(result);
+                TryInvokeContinuation();
+                return true;
+            }
+            return false;
+        }
+
+        public override bool TrySetCanceled()
+        {
+            if (Status == AwaiterStatus.Canceled) return false;
+            TaskTracker.RemoveTracking(this);
+            return base.TrySetCanceled();
+        }
+    }
+
+    public interface ICancellationTokenKeyDictionary
+    {
+        void Remove(CancellationToken token);
+    }
+
+    public class AsyncTriggerPromiseDictionary<TPromiseType> :
+        Dictionary<CancellationToken, AsyncTriggerPromise<TPromiseType>>,
+        ICancellationTokenKeyDictionary,
+        IEnumerable<ICancelablePromise>
+    {
+        public AsyncTriggerPromiseDictionary()
+            : base(CancellationTokenEqualityComparer.Default)
+        {
+        }
+
+        IEnumerator<ICancelablePromise> IEnumerable<ICancelablePromise>.GetEnumerator()
+        {
+            return Values.GetEnumerator();
+        }
+
+        void ICancellationTokenKeyDictionary.Remove(CancellationToken token)
+        {
+            this.Remove(token);
+        }
+    }
+
+    public abstract class AsyncTriggerBase : MonoBehaviour
+    {
+        static readonly Action<object> Callback = CancelCallback;
+
+        bool calledAwake = false;
+        bool destroyCalled = false;
+        CancellationTokenRegistration[] registeredCancellations;
+        int registeredCancellationsCount;
+
+        protected abstract IEnumerable<ICancelablePromise> GetPromises();
+
+        static protected IEnumerable<ICancelablePromise> Concat(ICancelablePromise p1, IEnumerable<ICancelablePromise> p1s)
+        {
+            if (p1 != null) yield return p1;
+            if (p1s != null) foreach (var item in p1s) yield return item;
+        }
+
+        static protected IEnumerable<ICancelablePromise> Concat(
+            ICancelablePromise p1, IEnumerable<ICancelablePromise> p1s,
+            ICancelablePromise p2, IEnumerable<ICancelablePromise> p2s)
+        {
+            if (p1 != null) yield return p1;
+            if (p1s != null) foreach (var item in p1s) yield return item;
+            if (p2 != null) yield return p2;
+            if (p2s != null) foreach (var item in p2s) yield return item;
+        }
+
+        static protected IEnumerable<ICancelablePromise> Concat(
+            ICancelablePromise p1, IEnumerable<ICancelablePromise> p1s,
+            ICancelablePromise p2, IEnumerable<ICancelablePromise> p2s,
+            ICancelablePromise p3, IEnumerable<ICancelablePromise> p3s)
+        {
+            if (p1 != null) yield return p1;
+            if (p1s != null) foreach (var item in p1s) yield return item;
+            if (p2 != null) yield return p2;
+            if (p2s != null) foreach (var item in p2s) yield return item;
+            if (p3 != null) yield return p3;
+            if (p3s != null) foreach (var item in p3s) yield return item;
+        }
+
+        static protected IEnumerable<ICancelablePromise> Concat(
+            ICancelablePromise p1, IEnumerable<ICancelablePromise> p1s,
+            ICancelablePromise p2, IEnumerable<ICancelablePromise> p2s,
+            ICancelablePromise p3, IEnumerable<ICancelablePromise> p3s,
+            ICancelablePromise p4, IEnumerable<ICancelablePromise> p4s)
+        {
+            if (p1 != null) yield return p1;
+            if (p1s != null) foreach (var item in p1s) yield return item;
+            if (p2 != null) yield return p2;
+            if (p2s != null) foreach (var item in p2s) yield return item;
+            if (p3 != null) yield return p3;
+            if (p3s != null) foreach (var item in p3s) yield return item;
+            if (p4 != null) yield return p4;
+            if (p4s != null) foreach (var item in p4s) yield return item;
+        }
+
+        // otherwise...
+        static protected IEnumerable<ICancelablePromise> Concat(params object[] promises)
+        {
+            foreach (var item in promises)
+            {
+                if (item is ICancelablePromise p)
+                {
+                    yield return p;
+                }
+                else if (item is IEnumerable<ICancelablePromise> ps)
+                {
+                    foreach (var p2 in ps)
+                    {
+                        yield return p2;
+                    }
+                }
+            }
+        }
+
+        protected UniTask<T> GetOrAddPromise<T>(ref AsyncTriggerPromise<T> promise, ref AsyncTriggerPromiseDictionary<T> promises, CancellationToken cancellationToken)
+        {
+            if (destroyCalled) return UniTask.FromCanceled<T>();
+
+            if (!cancellationToken.CanBeCanceled)
+            {
+                if (promise == null)
+                {
+                    promise = new AsyncTriggerPromise<T>();
+                    if (!calledAwake)
+                    {
+                        PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, new AwakeMonitor(this));
+                    }
+                }
+                return promise.Task;
+            }
+
+            if (promises == null) promises = new AsyncTriggerPromiseDictionary<T>();
+
+            if (promises.TryGetValue(cancellationToken, out var cancellablePromise))
+            {
+                return cancellablePromise.Task;
+            }
+
+            cancellablePromise = new AsyncTriggerPromise<T>();
+            promises.Add(cancellationToken, cancellablePromise);
+            if (!calledAwake)
+            {
+                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, new AwakeMonitor(this));
+            }
+
+            var registrationToken = cancellationToken.RegisterWithoutCaptureExecutionContext(Callback, Tuple.Create((ICancellationTokenKeyDictionary)promises, (ICancelablePromise)cancellablePromise));
+            if (registeredCancellations == null)
+            {
+                registeredCancellations = ArrayPool<CancellationTokenRegistration>.Shared.Rent(4);
+            }
+            ArrayPoolUtil.EnsureCapacity(ref registeredCancellations, registeredCancellationsCount + 1, ArrayPool<CancellationTokenRegistration>.Shared);
+            registeredCancellations[registeredCancellationsCount++] = registrationToken;
+
+            return cancellablePromise.Task;
+        }
+
+        static void CancelCallback(object state)
+        {
+            var tuple = (Tuple<ICancellationTokenKeyDictionary, ICancelablePromise>)state;
+            var dict = tuple.Item1;
+            var promise = tuple.Item2;
+
+            promise.TrySetCanceled();
+            dict.Remove(promise.RegisteredCancellationToken);
+        }
+
+        protected void TrySetResult<T>(ReusablePromise<T> promise, AsyncTriggerPromiseDictionary<T> promises, T value)
+        {
+            if (promise != null)
+            {
+                promise.TrySetResult(value);
+            }
+            if (promises != null)
+            {
+                PromiseHelper.TrySetResultAll(promises.Values, value);
+            }
+        }
+
+        void Awake()
+        {
+            calledAwake = true;
+        }
+
+        void OnDestroy()
+        {
+            if (destroyCalled) return;
+            destroyCalled = true;
+            foreach (var item in GetPromises())
+            {
+                item.TrySetCanceled();
+            }
+            if (registeredCancellations != null)
+            {
+                for (int i = 0; i < registeredCancellationsCount; i++)
+                {
+                    registeredCancellations[i].Dispose();
+                    registeredCancellations[i] = default(CancellationTokenRegistration);
+                }
+                ArrayPool<CancellationTokenRegistration>.Shared.Return(registeredCancellations);
+            }
+        }
+
+        class AwakeMonitor : IPlayerLoopItem
+        {
+            readonly AsyncTriggerBase trigger;
+
+            public AwakeMonitor(AsyncTriggerBase trigger)
+            {
+                this.trigger = trigger;
+            }
+
+            public bool MoveNext()
+            {
+                if (trigger.calledAwake) return false;
+                if (trigger == null)
+                {
+                    trigger.OnDestroy();
+                    return false;
+                }
+                return true;
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/Triggers/AsyncTriggerBase.cs.meta b/Assets/UniRx.Async/Triggers/AsyncTriggerBase.cs.meta
new file mode 100644
index 0000000..e101ea2
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncTriggerBase.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2c0c2bcee832c6641b25949c412f020f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncTriggerExtensions.cs b/Assets/UniRx.Async/Triggers/AsyncTriggerExtensions.cs
new file mode 100644
index 0000000..8413968
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncTriggerExtensions.cs
@@ -0,0 +1,511 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Threading;
+using UnityEngine;
+
+namespace UniRx.Async.Triggers
+{
+    public static class AsyncTriggerExtensions
+    {
+        // Util.
+
+        static T GetOrAddComponent<T>(GameObject gameObject)
+            where T : Component
+        {
+            var component = gameObject.GetComponent<T>();
+            if (component == null)
+            {
+                component = gameObject.AddComponent<T>();
+            }
+
+            return component;
+        }
+
+        // Special for single operation.
+
+        /// <summary>This function is called when the MonoBehaviour will be destroyed.</summary>
+        public static UniTask OnDestroyAsync(this GameObject gameObject)
+        {
+            return gameObject.GetAsyncDestroyTrigger().OnDestroyAsync();
+        }
+
+        /// <summary>This function is called when the MonoBehaviour will be destroyed.</summary>
+        public static UniTask OnDestroyAsync(this Component component)
+        {
+            return component.GetAsyncDestroyTrigger().OnDestroyAsync();
+        }
+
+        /// <summary>This CancellationToken is canceled when the MonoBehaviour will be destroyed.</summary>
+        public static CancellationToken GetCancellationTokenOnDestroy(this GameObject gameObject)
+        {
+            return gameObject.GetAsyncDestroyTrigger().CancellationToken;
+        }
+
+        /// <summary>This CancellationToken is canceled when the MonoBehaviour will be destroyed.</summary>
+        public static CancellationToken GetCancellationTokenOnDestroy(this Component component)
+        {
+            return component.GetAsyncDestroyTrigger().CancellationToken;
+        }
+
+        public static UniTask StartAsync(this GameObject gameObject)
+        {
+            return gameObject.GetAsyncStartTrigger().StartAsync();
+        }
+
+        public static UniTask StartAsync(this Component component)
+        {
+            return component.GetAsyncStartTrigger().StartAsync();
+        }
+
+        public static UniTask AwakeAsync(this GameObject gameObject)
+        {
+            return gameObject.GetAsyncAwakeTrigger().AwakeAsync();
+        }
+
+        public static UniTask AwakeAsync(this Component component)
+        {
+            return component.GetAsyncAwakeTrigger().AwakeAsync();
+        }
+
+        // Get Triggers.
+
+        /// <summary>Get for OnAnimatorIKAsync | OnAnimatorMoveAsync.</summary>
+        public static AsyncAnimatorTrigger GetAsyncAnimatorTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncAnimatorTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnAnimatorIKAsync | OnAnimatorMoveAsync.</summary>
+        public static AsyncAnimatorTrigger GetAsyncAnimatorTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncAnimatorTrigger();
+        }
+
+        /// <summary>Get for AwakeAsync.</summary>
+        public static AsyncAwakeTrigger GetAsyncAwakeTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncAwakeTrigger>(gameObject);
+        }
+
+        /// <summary>Get for AwakeAsync.</summary>
+        public static AsyncAwakeTrigger GetAsyncAwakeTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncAwakeTrigger();
+        }
+
+        /// <summary>Get for OnBeginDragAsync.</summary>
+        public static AsyncBeginDragTrigger GetAsyncBeginDragTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncBeginDragTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnBeginDragAsync.</summary>
+        public static AsyncBeginDragTrigger GetAsyncBeginDragTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncBeginDragTrigger();
+        }
+
+        /// <summary>Get for OnCancelAsync.</summary>
+        public static AsyncCancelTrigger GetAsyncCancelTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncCancelTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnCancelAsync.</summary>
+        public static AsyncCancelTrigger GetAsyncCancelTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncCancelTrigger();
+        }
+
+        /// <summary>Get for OnCanvasGroupChangedAsync.</summary>
+        public static AsyncCanvasGroupChangedTrigger GetAsyncCanvasGroupChangedTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncCanvasGroupChangedTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnCanvasGroupChangedAsync.</summary>
+        public static AsyncCanvasGroupChangedTrigger GetAsyncCanvasGroupChangedTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncCanvasGroupChangedTrigger();
+        }
+
+        /// <summary>Get for OnCollisionEnter2DAsync | OnCollisionExit2DAsync | OnCollisionStay2DAsync.</summary>
+        public static AsyncCollision2DTrigger GetAsyncCollision2DTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncCollision2DTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnCollisionEnter2DAsync | OnCollisionExit2DAsync | OnCollisionStay2DAsync.</summary>
+        public static AsyncCollision2DTrigger GetAsyncCollision2DTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncCollision2DTrigger();
+        }
+
+        /// <summary>Get for OnCollisionEnterAsync | OnCollisionExitAsync | OnCollisionStayAsync.</summary>
+        public static AsyncCollisionTrigger GetAsyncCollisionTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncCollisionTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnCollisionEnterAsync | OnCollisionExitAsync | OnCollisionStayAsync.</summary>
+        public static AsyncCollisionTrigger GetAsyncCollisionTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncCollisionTrigger();
+        }
+
+        /// <summary>Get for OnDeselectAsync.</summary>
+        public static AsyncDeselectTrigger GetAsyncDeselectTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncDeselectTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnDeselectAsync.</summary>
+        public static AsyncDeselectTrigger GetAsyncDeselectTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncDeselectTrigger();
+        }
+
+        /// <summary>Get for OnDestroyAsync.</summary>
+        public static AsyncDestroyTrigger GetAsyncDestroyTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncDestroyTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnDestroyAsync.</summary>
+        public static AsyncDestroyTrigger GetAsyncDestroyTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncDestroyTrigger();
+        }
+
+        /// <summary>Get for OnDragAsync.</summary>
+        public static AsyncDragTrigger GetAsyncDragTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncDragTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnDragAsync.</summary>
+        public static AsyncDragTrigger GetAsyncDragTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncDragTrigger();
+        }
+
+        /// <summary>Get for OnDropAsync.</summary>
+        public static AsyncDropTrigger GetAsyncDropTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncDropTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnDropAsync.</summary>
+        public static AsyncDropTrigger GetAsyncDropTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncDropTrigger();
+        }
+
+        /// <summary>Get for OnEnableAsync | OnDisableAsync.</summary>
+        public static AsyncEnableDisableTrigger GetAsyncEnableDisableTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncEnableDisableTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnEnableAsync | OnDisableAsync.</summary>
+        public static AsyncEnableDisableTrigger GetAsyncEnableDisableTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncEnableDisableTrigger();
+        }
+
+        /// <summary>Get for OnEndDragAsync.</summary>
+        public static AsyncEndDragTrigger GetAsyncEndDragTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncEndDragTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnEndDragAsync.</summary>
+        public static AsyncEndDragTrigger GetAsyncEndDragTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncEndDragTrigger();
+        }
+
+        /// <summary>Get for FixedUpdateAsync.</summary>
+        public static AsyncFixedUpdateTrigger GetAsyncFixedUpdateTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncFixedUpdateTrigger>(gameObject);
+        }
+
+        /// <summary>Get for FixedUpdateAsync.</summary>
+        public static AsyncFixedUpdateTrigger GetAsyncFixedUpdateTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncFixedUpdateTrigger();
+        }
+
+        /// <summary>Get for OnInitializePotentialDragAsync.</summary>
+        public static AsyncInitializePotentialDragTrigger GetAsyncInitializePotentialDragTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncInitializePotentialDragTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnInitializePotentialDragAsync.</summary>
+        public static AsyncInitializePotentialDragTrigger GetAsyncInitializePotentialDragTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncInitializePotentialDragTrigger();
+        }
+
+        /// <summary>Get for OnJointBreakAsync.</summary>
+        public static AsyncJointTrigger GetAsyncJointTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncJointTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnJointBreakAsync.</summary>
+        public static AsyncJointTrigger GetAsyncJointTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncJointTrigger();
+        }
+
+        /// <summary>Get for LateUpdateAsync.</summary>
+        public static AsyncLateUpdateTrigger GetAsyncLateUpdateTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncLateUpdateTrigger>(gameObject);
+        }
+
+        /// <summary>Get for LateUpdateAsync.</summary>
+        public static AsyncLateUpdateTrigger GetAsyncLateUpdateTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncLateUpdateTrigger();
+        }
+
+#if !(UNITY_IPHONE || UNITY_ANDROID || UNITY_METRO)
+
+        /// <summary>Get for OnMouseDownAsync | OnMouseDragAsync | OnMouseEnterAsync | OnMouseExitAsync | OnMouseOverAsync | OnMouseUpAsync | OnMouseUpAsButtonAsync.</summary>
+        public static AsyncMouseTrigger GetAsyncMouseTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncMouseTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnMouseDownAsync | OnMouseDragAsync | OnMouseEnterAsync | OnMouseExitAsync | OnMouseOverAsync | OnMouseUpAsync | OnMouseUpAsButtonAsync.</summary>
+        public static AsyncMouseTrigger GetAsyncMouseTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncMouseTrigger();
+        }
+
+#endif
+
+        /// <summary>Get for OnMoveAsync.</summary>
+        public static AsyncMoveTrigger GetAsyncMoveTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncMoveTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnMoveAsync.</summary>
+        public static AsyncMoveTrigger GetAsyncMoveTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncMoveTrigger();
+        }
+
+        /// <summary>Get for OnParticleCollisionAsync | OnParticleTriggerAsync.</summary>
+        public static AsyncParticleTrigger GetAsyncParticleTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncParticleTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnParticleCollisionAsync | OnParticleTriggerAsync.</summary>
+        public static AsyncParticleTrigger GetAsyncParticleTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncParticleTrigger();
+        }
+
+        /// <summary>Get for OnPointerClickAsync.</summary>
+        public static AsyncPointerClickTrigger GetAsyncPointerClickTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncPointerClickTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnPointerClickAsync.</summary>
+        public static AsyncPointerClickTrigger GetAsyncPointerClickTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncPointerClickTrigger();
+        }
+
+        /// <summary>Get for OnPointerDownAsync.</summary>
+        public static AsyncPointerDownTrigger GetAsyncPointerDownTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncPointerDownTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnPointerDownAsync.</summary>
+        public static AsyncPointerDownTrigger GetAsyncPointerDownTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncPointerDownTrigger();
+        }
+
+        /// <summary>Get for OnPointerEnterAsync.</summary>
+        public static AsyncPointerEnterTrigger GetAsyncPointerEnterTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncPointerEnterTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnPointerEnterAsync.</summary>
+        public static AsyncPointerEnterTrigger GetAsyncPointerEnterTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncPointerEnterTrigger();
+        }
+
+        /// <summary>Get for OnPointerExitAsync.</summary>
+        public static AsyncPointerExitTrigger GetAsyncPointerExitTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncPointerExitTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnPointerExitAsync.</summary>
+        public static AsyncPointerExitTrigger GetAsyncPointerExitTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncPointerExitTrigger();
+        }
+
+        /// <summary>Get for OnPointerUpAsync.</summary>
+        public static AsyncPointerUpTrigger GetAsyncPointerUpTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncPointerUpTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnPointerUpAsync.</summary>
+        public static AsyncPointerUpTrigger GetAsyncPointerUpTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncPointerUpTrigger();
+        }
+
+        /// <summary>Get for OnRectTransformDimensionsChange | OnRectTransformDimensionsChangeAsync | OnRectTransformRemoved | OnRectTransformRemovedAsync.</summary>
+        public static AsyncRectTransformTrigger GetAsyncRectTransformTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncRectTransformTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnRectTransformDimensionsChange | OnRectTransformDimensionsChangeAsync | OnRectTransformRemoved | OnRectTransformRemovedAsync.</summary>
+        public static AsyncRectTransformTrigger GetAsyncRectTransformTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncRectTransformTrigger();
+        }
+
+        /// <summary>Get for OnScrollAsync.</summary>
+        public static AsyncScrollTrigger GetAsyncScrollTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncScrollTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnScrollAsync.</summary>
+        public static AsyncScrollTrigger GetAsyncScrollTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncScrollTrigger();
+        }
+
+        /// <summary>Get for OnSelectAsync.</summary>
+        public static AsyncSelectTrigger GetAsyncSelectTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncSelectTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnSelectAsync.</summary>
+        public static AsyncSelectTrigger GetAsyncSelectTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncSelectTrigger();
+        }
+
+        /// <summary>Get for StartAsync.</summary>
+        public static AsyncStartTrigger GetAsyncStartTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncStartTrigger>(gameObject);
+        }
+
+        /// <summary>Get for StartAsync.</summary>
+        public static AsyncStartTrigger GetAsyncStartTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncStartTrigger();
+        }
+
+        /// <summary>Get for OnSubmitAsync.</summary>
+        public static AsyncSubmitTrigger GetAsyncSubmitTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncSubmitTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnSubmitAsync.</summary>
+        public static AsyncSubmitTrigger GetAsyncSubmitTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncSubmitTrigger();
+        }
+
+        /// <summary>Get for OnBeforeTransformParentChangedAsync | OnTransformParentChangedAsync | OnTransformChildrenChangedAsync.</summary>
+        public static AsyncTransformChangedTrigger GetAsyncTransformChangedTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncTransformChangedTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnBeforeTransformParentChangedAsync | OnTransformParentChangedAsync | OnTransformChildrenChangedAsync.</summary>
+        public static AsyncTransformChangedTrigger GetAsyncTransformChangedTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncTransformChangedTrigger();
+        }
+
+        /// <summary>Get for OnTriggerEnter2DAsync | OnTriggerExit2DAsync | OnTriggerStay2DAsync.</summary>
+        public static AsyncTrigger2DTrigger GetAsyncTrigger2DTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncTrigger2DTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnTriggerEnter2DAsync | OnTriggerExit2DAsync | OnTriggerStay2DAsync.</summary>
+        public static AsyncTrigger2DTrigger GetAsyncTrigger2DTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncTrigger2DTrigger();
+        }
+
+        /// <summary>Get for OnTriggerEnterAsync | OnTriggerExitAsync | OnTriggerStayAsync.</summary>
+        public static AsyncTriggerTrigger GetAsyncTriggerTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncTriggerTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnTriggerEnterAsync | OnTriggerExitAsync | OnTriggerStayAsync.</summary>
+        public static AsyncTriggerTrigger GetAsyncTriggerTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncTriggerTrigger();
+        }
+
+        /// <summary>Get for OnUpdateSelectedAsync.</summary>
+        public static AsyncUpdateSelectedTrigger GetAsyncUpdateSelectedTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncUpdateSelectedTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnUpdateSelectedAsync.</summary>
+        public static AsyncUpdateSelectedTrigger GetAsyncUpdateSelectedTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncUpdateSelectedTrigger();
+        }
+
+        /// <summary>Get for UpdateAsync.</summary>
+        public static AsyncUpdateTrigger GetAsyncUpdateTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncUpdateTrigger>(gameObject);
+        }
+
+        /// <summary>Get for UpdateAsync.</summary>
+        public static AsyncUpdateTrigger GetAsyncUpdateTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncUpdateTrigger();
+        }
+
+        /// <summary>Get for OnBecameInvisibleAsync | OnBecameVisibleAsync.</summary>
+        public static AsyncVisibleTrigger GetAsyncVisibleTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncVisibleTrigger>(gameObject);
+        }
+
+        /// <summary>Get for OnBecameInvisibleAsync | OnBecameVisibleAsync.</summary>
+        public static AsyncVisibleTrigger GetAsyncVisibleTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncVisibleTrigger();
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/Triggers/AsyncTriggerExtensions.cs.meta b/Assets/UniRx.Async/Triggers/AsyncTriggerExtensions.cs.meta
new file mode 100644
index 0000000..348783d
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncTriggerExtensions.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 59b61dbea1562a84fb7a38ae0a0a0f88
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncTriggerTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncTriggerTrigger.cs
new file mode 100644
index 0000000..22f3c94
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncTriggerTrigger.cs
@@ -0,0 +1,69 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncTriggerTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<Collider> onTriggerEnter;
+        AsyncTriggerPromiseDictionary<Collider> onTriggerEnters;
+        AsyncTriggerPromise<Collider> onTriggerExit;
+        AsyncTriggerPromiseDictionary<Collider> onTriggerExits;
+        AsyncTriggerPromise<Collider> onTriggerStay;
+        AsyncTriggerPromiseDictionary<Collider> onTriggerStays;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onTriggerEnter, onTriggerEnters, onTriggerExit, onTriggerExits, onTriggerStay, onTriggerStays);
+        }
+
+
+        void OnTriggerEnter(Collider other)
+        {
+            TrySetResult(onTriggerEnter, onTriggerEnters, other);
+        }
+
+
+        public UniTask OnTriggerEnterAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onTriggerEnter, ref onTriggerEnters, cancellationToken);
+        }
+
+
+        void OnTriggerExit(Collider other)
+        {
+            TrySetResult(onTriggerExit, onTriggerExits, other);
+        }
+
+
+        public UniTask OnTriggerExitAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onTriggerExit, ref onTriggerExits, cancellationToken);
+        }
+
+
+        void OnTriggerStay(Collider other)
+        {
+            TrySetResult(onTriggerStay, onTriggerStays, other);
+        }
+
+
+        public UniTask OnTriggerStayAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onTriggerStay, ref onTriggerStays, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncTriggerTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncTriggerTrigger.cs.meta
new file mode 100644
index 0000000..b9f7efb
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncTriggerTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 46bbbbaa910762c4786906e10b6b7b8e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncUpdateSelectedTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncUpdateSelectedTrigger.cs
new file mode 100644
index 0000000..5f7536e
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncUpdateSelectedTrigger.cs
@@ -0,0 +1,41 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncUpdateSelectedTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<BaseEventData> onUpdateSelected;
+        AsyncTriggerPromiseDictionary<BaseEventData> onUpdateSelecteds;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onUpdateSelected, onUpdateSelecteds);
+        }
+
+
+        void OnUpdateSelected(BaseEventData eventData)
+        {
+            TrySetResult(onUpdateSelected, onUpdateSelecteds, eventData);
+        }
+
+
+        public UniTask OnUpdateSelectedAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onUpdateSelected, ref onUpdateSelecteds, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncUpdateSelectedTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncUpdateSelectedTrigger.cs.meta
new file mode 100644
index 0000000..395b43c
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncUpdateSelectedTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ba5b0a4234e164e41b85f10b709d72e9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncUpdateTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncUpdateTrigger.cs
new file mode 100644
index 0000000..258eec9
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncUpdateTrigger.cs
@@ -0,0 +1,41 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncUpdateTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<AsyncUnit> update;
+        AsyncTriggerPromiseDictionary<AsyncUnit> updates;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(update, updates);
+        }
+
+
+        void Update()
+        {
+            TrySetResult(update, updates, AsyncUnit.Default);
+        }
+
+
+        public UniTask UpdateAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref update, ref updates, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncUpdateTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncUpdateTrigger.cs.meta
new file mode 100644
index 0000000..d2277f7
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncUpdateTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c6053bbe25af0d6439712f7c5fc4afc7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/Triggers/AsyncVisibleTrigger.cs b/Assets/UniRx.Async/Triggers/AsyncVisibleTrigger.cs
new file mode 100644
index 0000000..df9596e
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncVisibleTrigger.cs
@@ -0,0 +1,55 @@
+
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UniRx.Async.Triggers
+{
+    [DisallowMultipleComponent]
+    public class AsyncVisibleTrigger : AsyncTriggerBase
+    {
+        AsyncTriggerPromise<AsyncUnit> onBecameInvisible;
+        AsyncTriggerPromiseDictionary<AsyncUnit> onBecameInvisibles;
+        AsyncTriggerPromise<AsyncUnit> onBecameVisible;
+        AsyncTriggerPromiseDictionary<AsyncUnit> onBecameVisibles;
+
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            return Concat(onBecameInvisible, onBecameInvisibles, onBecameVisible, onBecameVisibles);
+        }
+
+
+        void OnBecameInvisible()
+        {
+            TrySetResult(onBecameInvisible, onBecameInvisibles, AsyncUnit.Default);
+        }
+
+
+        public UniTask OnBecameInvisibleAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onBecameInvisible, ref onBecameInvisibles, cancellationToken);
+        }
+
+
+        void OnBecameVisible()
+        {
+            TrySetResult(onBecameVisible, onBecameVisibles, AsyncUnit.Default);
+        }
+
+
+        public UniTask OnBecameVisibleAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return GetOrAddPromise(ref onBecameVisible, ref onBecameVisibles, cancellationToken);
+        }
+
+
+    }
+}
+
+#endif
+
diff --git a/Assets/UniRx.Async/Triggers/AsyncVisibleTrigger.cs.meta b/Assets/UniRx.Async/Triggers/AsyncVisibleTrigger.cs.meta
new file mode 100644
index 0000000..24b33ec
--- /dev/null
+++ b/Assets/UniRx.Async/Triggers/AsyncVisibleTrigger.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 57ebfef2a87c49c46ad6454db136f3ef
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/UniRx.Async.asmdef b/Assets/UniRx.Async/UniRx.Async.asmdef
new file mode 100644
index 0000000..bb982ba
--- /dev/null
+++ b/Assets/UniRx.Async/UniRx.Async.asmdef
@@ -0,0 +1,8 @@
+{
+    "name": "UniRx.Async",
+    "references": [],
+    "optionalUnityReferences": [],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false
+}
\ No newline at end of file
diff --git a/Assets/UniRx.Async/UniRx.Async.asmdef.meta b/Assets/UniRx.Async/UniRx.Async.asmdef.meta
new file mode 100644
index 0000000..e497045
--- /dev/null
+++ b/Assets/UniRx.Async/UniRx.Async.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: f51ebe6a0ceec4240a699833d6309b23
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/UniTask.Bridge.cs b/Assets/UniRx.Async/UniTask.Bridge.cs
new file mode 100644
index 0000000..814bd02
--- /dev/null
+++ b/Assets/UniRx.Async/UniTask.Bridge.cs
@@ -0,0 +1,20 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Collections;
+
+namespace UniRx.Async
+{
+    // UnityEngine Bridges.
+
+    public partial struct UniTask
+    {
+        public static IEnumerator ToCoroutine(Func<UniTask> taskFactory)
+        {
+            return taskFactory().ToCoroutine();
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/UniTask.Bridge.cs.meta b/Assets/UniRx.Async/UniTask.Bridge.cs.meta
new file mode 100644
index 0000000..6f8da80
--- /dev/null
+++ b/Assets/UniRx.Async/UniTask.Bridge.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bd6beac8e0ebd264e9ba246c39429c72
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/UniTask.Delay.cs b/Assets/UniRx.Async/UniTask.Delay.cs
new file mode 100644
index 0000000..d828358
--- /dev/null
+++ b/Assets/UniRx.Async/UniTask.Delay.cs
@@ -0,0 +1,246 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using UniRx.Async.Internal;
+using UnityEngine;
+
+namespace UniRx.Async
+{
+    public partial struct UniTask
+    {
+        public static YieldAwaitable Yield(PlayerLoopTiming timing = PlayerLoopTiming.Update)
+        {
+            // optimized for single continuation
+            return new YieldAwaitable(timing);
+        }
+
+        public static UniTask Yield(PlayerLoopTiming timing, CancellationToken cancellationToken)
+        {
+            return new UniTask(new YieldPromise(timing, cancellationToken));
+        }
+
+        public static UniTask<int> DelayFrame(int delayFrameCount, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            if (delayFrameCount < 0)
+            {
+                throw new ArgumentOutOfRangeException("Delay does not allow minus delayFrameCount. delayFrameCount:" + delayFrameCount);
+            }
+
+            var source = new DelayFramePromise(delayFrameCount, delayTiming, cancellationToken);
+            return source.Task;
+        }
+
+        public static UniTask Delay(int millisecondsDelay, bool ignoreTimeScale = false, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            var delayTimeSpan = TimeSpan.FromMilliseconds(millisecondsDelay);
+            if (delayTimeSpan < TimeSpan.Zero)
+            {
+                throw new ArgumentOutOfRangeException("Delay does not allow minus delayFrameCount. delayTimeSpan:" + delayTimeSpan);
+            }
+
+            return (ignoreTimeScale)
+                ? new DelayIgnoreTimeScalePromise(delayTimeSpan, delayTiming, cancellationToken).Task
+                : new DelayPromise(delayTimeSpan, delayTiming, cancellationToken).Task;
+        }
+
+        public static UniTask Delay(TimeSpan delayTimeSpan, bool ignoreTimeScale = false, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            if (delayTimeSpan < TimeSpan.Zero)
+            {
+                throw new ArgumentOutOfRangeException("Delay does not allow minus delayFrameCount. delayTimeSpan:" + delayTimeSpan);
+            }
+
+            return (ignoreTimeScale)
+                ? new DelayIgnoreTimeScalePromise(delayTimeSpan, delayTiming, cancellationToken).Task
+                : new DelayPromise(delayTimeSpan, delayTiming, cancellationToken).Task;
+        }
+
+        class YieldPromise : PlayerLoopReusablePromiseBase
+        {
+            public YieldPromise(PlayerLoopTiming timing, CancellationToken cancellationToken)
+                : base(timing, cancellationToken, 2)
+            {
+            }
+
+            protected override void OnRunningStart()
+            {
+            }
+
+            public override bool MoveNext()
+            {
+                Complete();
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    TrySetCanceled();
+                }
+                else
+                {
+                    TrySetResult();
+                }
+
+                return false;
+            }
+        }
+
+        class DelayFramePromise : PlayerLoopReusablePromiseBase<int>
+        {
+            readonly int delayFrameCount;
+            int currentFrameCount;
+
+            public DelayFramePromise(int delayFrameCount, PlayerLoopTiming timing, CancellationToken cancellationToken)
+                : base(timing, cancellationToken, 2)
+            {
+                this.delayFrameCount = delayFrameCount;
+                this.currentFrameCount = 0;
+            }
+
+            protected override void OnRunningStart()
+            {
+                currentFrameCount = 0;
+            }
+
+            public override bool MoveNext()
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    Complete();
+                    TrySetCanceled();
+                    return false;
+                }
+
+                if (currentFrameCount == delayFrameCount)
+                {
+                    Complete();
+                    TrySetResult(currentFrameCount);
+                    return false;
+                }
+
+                currentFrameCount++;
+                return true;
+            }
+        }
+
+        class DelayPromise : PlayerLoopReusablePromiseBase
+        {
+            readonly float delayFrameTimeSpan;
+            float elapsed;
+
+            public DelayPromise(TimeSpan delayFrameTimeSpan, PlayerLoopTiming timing, CancellationToken cancellationToken)
+                : base(timing, cancellationToken, 2)
+            {
+                this.delayFrameTimeSpan = (float)delayFrameTimeSpan.TotalSeconds;
+            }
+
+            protected override void OnRunningStart()
+            {
+                this.elapsed = 0.0f;
+            }
+
+            public override bool MoveNext()
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    Complete();
+                    TrySetCanceled();
+                    return false;
+                }
+
+                elapsed += Time.deltaTime;
+                if (elapsed >= delayFrameTimeSpan)
+                {
+                    Complete();
+                    TrySetResult();
+                    return false;
+                }
+
+                return true;
+            }
+        }
+
+        class DelayIgnoreTimeScalePromise : PlayerLoopReusablePromiseBase
+        {
+            readonly float delayFrameTimeSpan;
+            float elapsed;
+
+            public DelayIgnoreTimeScalePromise(TimeSpan delayFrameTimeSpan, PlayerLoopTiming timing, CancellationToken cancellationToken)
+                : base(timing, cancellationToken, 2)
+            {
+                this.delayFrameTimeSpan = (float)delayFrameTimeSpan.TotalSeconds;
+            }
+
+            protected override void OnRunningStart()
+            {
+                this.elapsed = 0.0f;
+            }
+
+            public override bool MoveNext()
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    Complete();
+                    TrySetCanceled();
+                    return false;
+                }
+
+                elapsed += Time.unscaledDeltaTime;
+
+                if (elapsed >= delayFrameTimeSpan)
+                {
+                    Complete();
+                    TrySetResult();
+                    return false;
+                }
+
+                return true;
+            }
+        }
+    }
+
+    public struct YieldAwaitable
+    {
+        readonly PlayerLoopTiming timing;
+
+        public YieldAwaitable(PlayerLoopTiming timing)
+        {
+            this.timing = timing;
+        }
+
+        public Awaiter GetAwaiter()
+        {
+            return new Awaiter(timing);
+        }
+
+        public UniTask ToUniTask()
+        {
+            return UniTask.Yield(timing, CancellationToken.None);
+        }
+
+        public struct Awaiter : ICriticalNotifyCompletion
+        {
+            readonly PlayerLoopTiming timing;
+
+            public Awaiter(PlayerLoopTiming timing)
+            {
+                this.timing = timing;
+            }
+
+            public bool IsCompleted => false;
+
+            public void GetResult() { }
+
+            public void OnCompleted(Action continuation)
+            {
+                PlayerLoopHelper.AddContinuation(timing, continuation);
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                PlayerLoopHelper.AddContinuation(timing, continuation);
+            }
+        }
+    }
+}
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/UniTask.Delay.cs.meta b/Assets/UniRx.Async/UniTask.Delay.cs.meta
new file mode 100644
index 0000000..08ce579
--- /dev/null
+++ b/Assets/UniRx.Async/UniTask.Delay.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ecff7972251de0848b2c0fa89bbd3489
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/UniTask.Factory.cs b/Assets/UniRx.Async/UniTask.Factory.cs
new file mode 100644
index 0000000..0150450
--- /dev/null
+++ b/Assets/UniRx.Async/UniTask.Factory.cs
@@ -0,0 +1,121 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Threading;
+
+namespace UniRx.Async
+{
+    public partial struct UniTask
+    {
+        static readonly UniTask CanceledUniTask = new Func<UniTask>(() =>
+        {
+            var promise = new UniTaskCompletionSource<AsyncUnit>();
+            promise.TrySetCanceled();
+            promise.MarkHandled();
+            return new UniTask(promise);
+        })();
+
+        public static UniTask CompletedTask
+        {
+            get
+            {
+                return new UniTask();
+            }
+        }
+
+        public static UniTask FromException(Exception ex)
+        {
+            var promise = new UniTaskCompletionSource<AsyncUnit>();
+            promise.TrySetException(ex);
+            promise.MarkHandled();
+            return new UniTask(promise);
+        }
+
+        public static UniTask<T> FromException<T>(Exception ex)
+        {
+            var promise = new UniTaskCompletionSource<T>();
+            promise.TrySetException(ex);
+            promise.MarkHandled();
+            return new UniTask<T>(promise);
+        }
+
+        public static UniTask<T> FromResult<T>(T value)
+        {
+            return new UniTask<T>(value);
+        }
+
+        public static UniTask FromCanceled()
+        {
+            return CanceledUniTask;
+        }
+
+        public static UniTask<T> FromCanceled<T>()
+        {
+            return CanceledUniTaskCache<T>.Task;
+        }
+
+        public static UniTask FromCanceled(CancellationToken token)
+        {
+            var promise = new UniTaskCompletionSource<AsyncUnit>();
+            promise.TrySetException(new OperationCanceledException(token));
+            promise.MarkHandled();
+            return new UniTask(promise);
+        }
+
+        public static UniTask<T> FromCanceled<T>(CancellationToken token)
+        {
+            var promise = new UniTaskCompletionSource<T>();
+            promise.TrySetException(new OperationCanceledException(token));
+            promise.MarkHandled();
+            return new UniTask<T>(promise);
+        }
+
+        /// <summary>shorthand of new UniTask[T](Func[UniTask[T]] factory)</summary>
+        public static UniTask<T> Lazy<T>(Func<UniTask<T>> factory)
+        {
+            return new UniTask<T>(factory);
+        }
+
+        /// <summary>
+        /// helper of create add UniTaskVoid to delegate.
+        /// For example: FooEvent += () => UniTask.Void(async () => { /* */ })
+        /// </summary>
+        public static void Void(Func<UniTask> asyncAction)
+        {
+            asyncAction().Forget();
+        }
+
+        /// <summary>
+        /// helper of create add UniTaskVoid to delegate.
+        /// For example: FooEvent += (sender, e) => UniTask.Void(async arg => { /* */ }, (sender, e))
+        /// </summary>
+        public static void Void<T>(Func<T, UniTask> asyncAction, T state)
+        {
+            asyncAction(state).Forget();
+        }
+
+        static class CanceledUniTaskCache<T>
+        {
+            public static readonly UniTask<T> Task;
+
+            static CanceledUniTaskCache()
+            {
+                var promise = new UniTaskCompletionSource<T>();
+                promise.TrySetCanceled();
+                promise.MarkHandled();
+                Task = new UniTask<T>(promise);
+            }
+        }
+    }
+
+    internal static class CompletedTasks
+    {
+        public static readonly UniTask<bool> True = UniTask.FromResult(true);
+        public static readonly UniTask<bool> False = UniTask.FromResult(false);
+        public static readonly UniTask<int> Zero = UniTask.FromResult(0);
+        public static readonly UniTask<int> MinusOne = UniTask.FromResult(-1);
+        public static readonly UniTask<int> One = UniTask.FromResult(1);
+    }
+}
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/UniTask.Factory.cs.meta b/Assets/UniRx.Async/UniTask.Factory.cs.meta
new file mode 100644
index 0000000..31bc0c9
--- /dev/null
+++ b/Assets/UniRx.Async/UniTask.Factory.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4e12b66d6b9bd7845b04a594cbe386b4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/UniTask.Run.cs b/Assets/UniRx.Async/UniTask.Run.cs
new file mode 100644
index 0000000..6363d3f
--- /dev/null
+++ b/Assets/UniRx.Async/UniTask.Run.cs
@@ -0,0 +1,99 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+
+namespace UniRx.Async
+{
+    public partial struct UniTask
+    {
+        /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
+        public static async UniTask Run(Action action, bool configureAwait = true)
+        {
+            await UniTask.SwitchToThreadPool();
+
+            if (configureAwait)
+            {
+                try
+                {
+                    action();
+                }
+                finally
+                {
+                    await UniTask.Yield();
+                }
+            }
+            else
+            {
+                action();
+            }
+        }
+
+        /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
+        public static async UniTask Run(Action<object> action, object state, bool configureAwait = true)
+        {
+            await UniTask.SwitchToThreadPool();
+
+            if (configureAwait)
+            {
+                try
+                {
+                    action(state);
+                }
+                finally
+                {
+                    await UniTask.Yield();
+                }
+            }
+            else
+            {
+                action(state);
+            }
+        }
+
+        /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
+        public static async UniTask<T> Run<T>(Func<T> func, bool configureAwait = true)
+        {
+            await UniTask.SwitchToThreadPool();
+            if (configureAwait)
+            {
+                try
+                {
+                    return func();
+                }
+                finally
+                {
+                    await UniTask.Yield();
+                }
+            }
+            else
+            {
+                return func();
+            }
+        }
+
+        /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
+        public static async UniTask<T> Run<T>(Func<object, T> func, object state, bool configureAwait = true)
+        {
+            await UniTask.SwitchToThreadPool();
+
+            if (configureAwait)
+            {
+                try
+                {
+                    return func(state);
+                }
+                finally
+                {
+                    await UniTask.Yield();
+                }
+            }
+            else
+            {
+                return func(state);
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/UniTask.Run.cs.meta b/Assets/UniRx.Async/UniTask.Run.cs.meta
new file mode 100644
index 0000000..9a780ae
--- /dev/null
+++ b/Assets/UniRx.Async/UniTask.Run.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8473162fc285a5f44bcca90f7da073e7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/UniTask.Threading.cs b/Assets/UniRx.Async/UniTask.Threading.cs
new file mode 100644
index 0000000..53dd1f8
--- /dev/null
+++ b/Assets/UniRx.Async/UniTask.Threading.cs
@@ -0,0 +1,176 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+using UniRx.Async.Internal;
+
+namespace UniRx.Async
+{
+    public partial struct UniTask
+    {
+        /// <summary>
+        /// If running on mainthread, do nothing. Otherwise, same as UniTask.Yield(PlayerLoopTiming.Update).
+        /// </summary>
+        public static SwitchToMainThreadAwaitable SwitchToMainThread()
+        {
+            return new SwitchToMainThreadAwaitable();
+        }
+
+        public static SwitchToThreadPoolAwaitable SwitchToThreadPool()
+        {
+            return new SwitchToThreadPoolAwaitable();
+        }
+
+        public static SwitchToTaskPoolAwaitable SwitchToTaskPool()
+        {
+            return new SwitchToTaskPoolAwaitable();
+        }
+
+        public static SwitchToSynchronizationContextAwaitable SwitchToSynchronizationContext(SynchronizationContext syncContext)
+        {
+            Error.ThrowArgumentNullException(syncContext, nameof(syncContext));
+            return new SwitchToSynchronizationContextAwaitable(syncContext);
+        }
+    }
+
+    public struct SwitchToMainThreadAwaitable
+    {
+        public Awaiter GetAwaiter() => new Awaiter();
+
+        public struct Awaiter : ICriticalNotifyCompletion
+        {
+            public bool IsCompleted
+            {
+                get
+                {
+                    var currentThreadId = System.Threading.Thread.CurrentThread.ManagedThreadId;
+                    if (PlayerLoopHelper.MainThreadId == currentThreadId)
+                    {
+                        return true; // run immediate.
+                    }
+                    else
+                    {
+                        return false; // register continuation.
+                    }
+                }
+            }
+
+            public void GetResult() { }
+
+            public void OnCompleted(Action continuation)
+            {
+                PlayerLoopHelper.AddContinuation(PlayerLoopTiming.Update, continuation);
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                PlayerLoopHelper.AddContinuation(PlayerLoopTiming.Update, continuation);
+            }
+        }
+    }
+
+    public struct SwitchToThreadPoolAwaitable
+    {
+        public Awaiter GetAwaiter() => new Awaiter();
+
+        public struct Awaiter : ICriticalNotifyCompletion
+        {
+            static readonly WaitCallback switchToCallback = Callback;
+
+            public bool IsCompleted => false;
+            public void GetResult() { }
+
+            public void OnCompleted(Action continuation)
+            {
+                ThreadPool.UnsafeQueueUserWorkItem(switchToCallback, continuation);
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                ThreadPool.UnsafeQueueUserWorkItem(switchToCallback, continuation);
+            }
+
+            static void Callback(object state)
+            {
+                var continuation = (Action)state;
+                continuation();
+            }
+        }
+    }
+
+    public struct SwitchToTaskPoolAwaitable
+    {
+        public Awaiter GetAwaiter() => new Awaiter();
+
+        public struct Awaiter : ICriticalNotifyCompletion
+        {
+            static readonly Action<object> switchToCallback = Callback;
+
+            public bool IsCompleted => false;
+            public void GetResult() { }
+
+            public void OnCompleted(Action continuation)
+            {
+                Task.Factory.StartNew(switchToCallback, continuation, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                Task.Factory.StartNew(switchToCallback, continuation, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
+            }
+
+            static void Callback(object state)
+            {
+                var continuation = (Action)state;
+                continuation();
+            }
+        }
+    }
+
+    public struct SwitchToSynchronizationContextAwaitable
+    {
+        readonly SynchronizationContext synchronizationContext;
+
+        public SwitchToSynchronizationContextAwaitable(SynchronizationContext synchronizationContext)
+        {
+            this.synchronizationContext = synchronizationContext;
+        }
+
+        public Awaiter GetAwaiter() => new Awaiter(synchronizationContext);
+
+        public struct Awaiter : ICriticalNotifyCompletion
+        {
+            static readonly SendOrPostCallback switchToCallback = Callback;
+            readonly SynchronizationContext synchronizationContext;
+
+            public Awaiter(SynchronizationContext synchronizationContext)
+            {
+                this.synchronizationContext = synchronizationContext;
+            }
+
+            public bool IsCompleted => false;
+            public void GetResult() { }
+
+            public void OnCompleted(Action continuation)
+            {
+                synchronizationContext.Post(switchToCallback, continuation);
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                synchronizationContext.Post(switchToCallback, continuation);
+            }
+
+            static void Callback(object state)
+            {
+                var continuation = (Action)state;
+                continuation();
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/UniTask.Threading.cs.meta b/Assets/UniRx.Async/UniTask.Threading.cs.meta
new file mode 100644
index 0000000..fa512b8
--- /dev/null
+++ b/Assets/UniRx.Async/UniTask.Threading.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4132ea600454134439fa2c7eb931b5e6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/UniTask.WaitUntil.cs b/Assets/UniRx.Async/UniTask.WaitUntil.cs
new file mode 100644
index 0000000..7326201
--- /dev/null
+++ b/Assets/UniRx.Async/UniTask.WaitUntil.cs
@@ -0,0 +1,235 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using UniRx.Async.Internal;
+
+namespace UniRx.Async
+{
+    public partial struct UniTask
+    {
+        public static UniTask WaitUntil(Func<bool> predicate, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            var promise = new WaitUntilPromise(predicate, timing, cancellationToken);
+            return promise.Task;
+        }
+
+        public static UniTask WaitWhile(Func<bool> predicate, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            var promise = new WaitWhilePromise(predicate, timing, cancellationToken);
+            return promise.Task;
+        }
+
+        public static UniTask<U> WaitUntilValueChanged<T, U>(T target, Func<T, U> monitorFunction, PlayerLoopTiming monitorTiming = PlayerLoopTiming.Update, IEqualityComparer<U> equalityComparer = null, CancellationToken cancellationToken = default(CancellationToken))
+          where T : class
+        {
+            var unityObject = target as UnityEngine.Object;
+            var isUnityObject = !object.ReferenceEquals(target, null); // don't use (unityObject == null)
+
+            return (isUnityObject)
+                ? new WaitUntilValueChangedUnityObjectPromise<T, U>(target, monitorFunction, equalityComparer, monitorTiming, cancellationToken).Task
+                : new WaitUntilValueChangedStandardObjectPromise<T, U>(target, monitorFunction, equalityComparer, monitorTiming, cancellationToken).Task;
+        }
+
+        class WaitUntilPromise : PlayerLoopReusablePromiseBase
+        {
+            readonly Func<bool> predicate;
+
+            public WaitUntilPromise(Func<bool> predicate, PlayerLoopTiming timing, CancellationToken cancellationToken)
+                : base(timing, cancellationToken, 1)
+            {
+                this.predicate = predicate;
+            }
+
+            protected override void OnRunningStart()
+            {
+            }
+
+            public override bool MoveNext()
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    Complete();
+                    TrySetCanceled();
+                    return false;
+                }
+
+                bool result = default(bool);
+                try
+                {
+                    result = predicate();
+                }
+                catch (Exception ex)
+                {
+                    Complete();
+                    TrySetException(ex);
+                    return false;
+                }
+
+                if (result)
+                {
+                    Complete();
+                    TrySetResult();
+                    return false;
+                }
+
+                return true;
+            }
+        }
+
+        class WaitWhilePromise : PlayerLoopReusablePromiseBase
+        {
+            readonly Func<bool> predicate;
+
+            public WaitWhilePromise(Func<bool> predicate, PlayerLoopTiming timing, CancellationToken cancellationToken)
+                : base(timing, cancellationToken, 1)
+            {
+                this.predicate = predicate;
+            }
+
+            protected override void OnRunningStart()
+            {
+            }
+
+            public override bool MoveNext()
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    Complete();
+                    TrySetCanceled();
+                    return false;
+                }
+
+                bool result = default(bool);
+                try
+                {
+                    result = predicate();
+                }
+                catch (Exception ex)
+                {
+                    Complete();
+                    TrySetException(ex);
+                    return false;
+                }
+
+                if (!result)
+                {
+                    Complete();
+                    TrySetResult();
+                    return false;
+                }
+
+                return true;
+            }
+        }
+
+        // where T : UnityEngine.Object, can not add constraint
+        class WaitUntilValueChangedUnityObjectPromise<T, U> : PlayerLoopReusablePromiseBase<U>
+        {
+            readonly T target;
+            readonly Func<T, U> monitorFunction;
+            readonly IEqualityComparer<U> equalityComparer;
+            U currentValue;
+
+            public WaitUntilValueChangedUnityObjectPromise(T target, Func<T, U> monitorFunction, IEqualityComparer<U> equalityComparer, PlayerLoopTiming timing, CancellationToken cancellationToken)
+                : base(timing, cancellationToken, 1)
+            {
+                this.target = target;
+                this.monitorFunction = monitorFunction;
+                this.equalityComparer = equalityComparer ?? UnityEqualityComparer.GetDefault<U>();
+                this.currentValue = monitorFunction(target);
+            }
+
+            protected override void OnRunningStart()
+            {
+            }
+
+            public override bool MoveNext()
+            {
+                if (cancellationToken.IsCancellationRequested || target == null) // destroyed = cancel.
+                {
+                    Complete();
+                    TrySetCanceled();
+                    return false;
+                }
+
+                U nextValue = default(U);
+                try
+                {
+                    nextValue = monitorFunction(target);
+                    if (equalityComparer.Equals(currentValue, nextValue))
+                    {
+                        return true;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Complete();
+                    TrySetException(ex);
+                    return false;
+                }
+
+                Complete();
+                currentValue = nextValue;
+                TrySetResult(nextValue);
+                return false;
+            }
+        }
+
+        class WaitUntilValueChangedStandardObjectPromise<T, U> : PlayerLoopReusablePromiseBase<U>
+            where T : class
+        {
+            readonly WeakReference<T> target;
+            readonly Func<T, U> monitorFunction;
+            readonly IEqualityComparer<U> equalityComparer;
+            U currentValue;
+
+            public WaitUntilValueChangedStandardObjectPromise(T target, Func<T, U> monitorFunction, IEqualityComparer<U> equalityComparer, PlayerLoopTiming timing, CancellationToken cancellationToken)
+                : base(timing, cancellationToken, 1)
+            {
+                this.target = new WeakReference<T>(target, false); // wrap in WeakReference.
+                this.monitorFunction = monitorFunction;
+                this.equalityComparer = equalityComparer ?? UnityEqualityComparer.GetDefault<U>();
+                this.currentValue = monitorFunction(target);
+            }
+
+            protected override void OnRunningStart()
+            {
+            }
+
+            public override bool MoveNext()
+            {
+                if (cancellationToken.IsCancellationRequested || !target.TryGetTarget(out var t))
+                {
+                    Complete();
+                    TrySetCanceled();
+                    return false;
+                }
+
+                U nextValue = default(U);
+                try
+                {
+                    nextValue = monitorFunction(t);
+                    if (equalityComparer.Equals(currentValue, nextValue))
+                    {
+                        return true;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Complete();
+                    TrySetException(ex);
+                    return false;
+                }
+
+                Complete();
+                currentValue = nextValue;
+                TrySetResult(nextValue);
+                return false;
+            }
+        }
+    }
+}
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/UniTask.WaitUntil.cs.meta b/Assets/UniRx.Async/UniTask.WaitUntil.cs.meta
new file mode 100644
index 0000000..6e64dc7
--- /dev/null
+++ b/Assets/UniRx.Async/UniTask.WaitUntil.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 87c9c533491903a4288536b5ac173db8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/UniTask.WhenAll.Generated.cs b/Assets/UniRx.Async/UniTask.WhenAll.Generated.cs
new file mode 100644
index 0000000..bda09db
--- /dev/null
+++ b/Assets/UniRx.Async/UniTask.WhenAll.Generated.cs
@@ -0,0 +1,1863 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.ExceptionServices;
+using System.Threading;
+
+namespace UniRx.Async
+{
+    public partial struct UniTask
+    {
+        public static async UniTask<(T1 result1, T2 result2)> WhenAll<T1, T2>(UniTask<T1> task1, UniTask<T2> task2)
+        {
+            return await new WhenAllPromise<T1, T2>(task1, task2);
+        }
+
+        public static async UniTask<(T1 result1, T2 result2, T3 result3)> WhenAll<T1, T2, T3>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3)
+        {
+            return await new WhenAllPromise<T1, T2, T3>(task1, task2, task3);
+        }
+
+        public static async UniTask<(T1 result1, T2 result2, T3 result3, T4 result4)> WhenAll<T1, T2, T3, T4>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4)
+        {
+            return await new WhenAllPromise<T1, T2, T3, T4>(task1, task2, task3, task4);
+        }
+
+        public static async UniTask<(T1 result1, T2 result2, T3 result3, T4 result4, T5 result5)> WhenAll<T1, T2, T3, T4, T5>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5)
+        {
+            return await new WhenAllPromise<T1, T2, T3, T4, T5>(task1, task2, task3, task4, task5);
+        }
+
+        public static async UniTask<(T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6)> WhenAll<T1, T2, T3, T4, T5, T6>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6)
+        {
+            return await new WhenAllPromise<T1, T2, T3, T4, T5, T6>(task1, task2, task3, task4, task5, task6);
+        }
+
+        public static async UniTask<(T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7)> WhenAll<T1, T2, T3, T4, T5, T6, T7>(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7)
+        {
+            return await new WhenAllPromise<T1, T2, T3, T4, T5, T6, T7>(task1, task2, task3, task4, task5, task6, task7);
+        }
+
+        class WhenAllPromise<T1, T2>
+        {
+            const int MaxCount = 2;
+
+            T1 result1;
+            T2 result2;
+            ExceptionDispatchInfo exception;
+            int completeCount;
+            Action whenComplete;
+
+            public WhenAllPromise(UniTask<T1> task1, UniTask<T2> task2)
+            {
+                this.completeCount = 0;
+                this.whenComplete = null;
+                this.result1 = default(T1);
+                this.result2 = default(T2);
+                this.exception = null;
+
+                RunTask1(task1);
+                RunTask2(task2);
+            }
+
+            void TryCallContinuation()
+            {
+                var action = Interlocked.Exchange(ref whenComplete, null);
+                if (action != null)
+                {
+                    action.Invoke();
+                }
+            }
+
+            void RunTask1(UniTask<T1> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result1 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask1Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask1Async(UniTask<T1> task)
+            {
+                try
+                {
+                    result1 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+            void RunTask2(UniTask<T2> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result2 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask2Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask2Async(UniTask<T2> task)
+            {
+                try
+                {
+                    result2 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+
+            public Awaiter GetAwaiter()
+            {
+                return new Awaiter(this);
+            }
+
+            public struct Awaiter : ICriticalNotifyCompletion
+            {
+                WhenAllPromise<T1, T2> parent;
+
+                public Awaiter(WhenAllPromise<T1, T2> parent)
+                {
+                    this.parent = parent;
+                }
+
+                public bool IsCompleted
+                {
+                    get
+                    {
+                        return parent.exception != null || parent.completeCount == MaxCount;
+                    }
+                }
+
+                public (T1, T2) GetResult()
+                {
+                    if (parent.exception != null)
+                    {
+                        parent.exception.Throw();
+                    }
+
+                    return (parent.result1, parent.result2);
+                }
+
+                public void OnCompleted(Action continuation)
+                {
+                    UnsafeOnCompleted(continuation);
+                }
+
+                public void UnsafeOnCompleted(Action continuation)
+                {
+                    parent.whenComplete = continuation;
+                    if (IsCompleted)
+                    {
+                        var action = Interlocked.Exchange(ref parent.whenComplete, null);
+                        if (action != null)
+                        {
+                            action();
+                        }
+                    }
+                }
+            }
+        }
+
+        class WhenAllPromise<T1, T2, T3>
+        {
+            const int MaxCount = 3;
+
+            T1 result1;
+            T2 result2;
+            T3 result3;
+            ExceptionDispatchInfo exception;
+            int completeCount;
+            Action whenComplete;
+
+            public WhenAllPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3)
+            {
+                this.completeCount = 0;
+                this.whenComplete = null;
+                this.result1 = default(T1);
+                this.result2 = default(T2);
+                this.result3 = default(T3);
+                this.exception = null;
+
+                RunTask1(task1);
+                RunTask2(task2);
+                RunTask3(task3);
+            }
+
+            void TryCallContinuation()
+            {
+                var action = Interlocked.Exchange(ref whenComplete, null);
+                if (action != null)
+                {
+                    action.Invoke();
+                }
+            }
+
+            void RunTask1(UniTask<T1> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result1 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask1Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask1Async(UniTask<T1> task)
+            {
+                try
+                {
+                    result1 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+            void RunTask2(UniTask<T2> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result2 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask2Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask2Async(UniTask<T2> task)
+            {
+                try
+                {
+                    result2 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+            void RunTask3(UniTask<T3> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result3 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask3Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask3Async(UniTask<T3> task)
+            {
+                try
+                {
+                    result3 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+
+            public Awaiter GetAwaiter()
+            {
+                return new Awaiter(this);
+            }
+
+            public struct Awaiter : ICriticalNotifyCompletion
+            {
+                WhenAllPromise<T1, T2, T3> parent;
+
+                public Awaiter(WhenAllPromise<T1, T2, T3> parent)
+                {
+                    this.parent = parent;
+                }
+
+                public bool IsCompleted
+                {
+                    get
+                    {
+                        return parent.exception != null || parent.completeCount == MaxCount;
+                    }
+                }
+
+                public (T1, T2, T3) GetResult()
+                {
+                    if (parent.exception != null)
+                    {
+                        parent.exception.Throw();
+                    }
+
+                    return (parent.result1, parent.result2, parent.result3);
+                }
+
+                public void OnCompleted(Action continuation)
+                {
+                    UnsafeOnCompleted(continuation);
+                }
+
+                public void UnsafeOnCompleted(Action continuation)
+                {
+                    parent.whenComplete = continuation;
+                    if (IsCompleted)
+                    {
+                        var action = Interlocked.Exchange(ref parent.whenComplete, null);
+                        if (action != null)
+                        {
+                            action();
+                        }
+                    }
+                }
+            }
+        }
+
+        class WhenAllPromise<T1, T2, T3, T4>
+        {
+            const int MaxCount = 4;
+
+            T1 result1;
+            T2 result2;
+            T3 result3;
+            T4 result4;
+            ExceptionDispatchInfo exception;
+            int completeCount;
+            Action whenComplete;
+
+            public WhenAllPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4)
+            {
+                this.completeCount = 0;
+                this.whenComplete = null;
+                this.result1 = default(T1);
+                this.result2 = default(T2);
+                this.result3 = default(T3);
+                this.result4 = default(T4);
+                this.exception = null;
+
+                RunTask1(task1);
+                RunTask2(task2);
+                RunTask3(task3);
+                RunTask4(task4);
+            }
+
+            void TryCallContinuation()
+            {
+                var action = Interlocked.Exchange(ref whenComplete, null);
+                if (action != null)
+                {
+                    action.Invoke();
+                }
+            }
+
+            void RunTask1(UniTask<T1> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result1 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask1Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask1Async(UniTask<T1> task)
+            {
+                try
+                {
+                    result1 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+            void RunTask2(UniTask<T2> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result2 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask2Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask2Async(UniTask<T2> task)
+            {
+                try
+                {
+                    result2 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+            void RunTask3(UniTask<T3> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result3 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask3Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask3Async(UniTask<T3> task)
+            {
+                try
+                {
+                    result3 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+            void RunTask4(UniTask<T4> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result4 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask4Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask4Async(UniTask<T4> task)
+            {
+                try
+                {
+                    result4 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+
+            public Awaiter GetAwaiter()
+            {
+                return new Awaiter(this);
+            }
+
+            public struct Awaiter : ICriticalNotifyCompletion
+            {
+                WhenAllPromise<T1, T2, T3, T4> parent;
+
+                public Awaiter(WhenAllPromise<T1, T2, T3, T4> parent)
+                {
+                    this.parent = parent;
+                }
+
+                public bool IsCompleted
+                {
+                    get
+                    {
+                        return parent.exception != null || parent.completeCount == MaxCount;
+                    }
+                }
+
+                public (T1, T2, T3, T4) GetResult()
+                {
+                    if (parent.exception != null)
+                    {
+                        parent.exception.Throw();
+                    }
+
+                    return (parent.result1, parent.result2, parent.result3, parent.result4);
+                }
+
+                public void OnCompleted(Action continuation)
+                {
+                    UnsafeOnCompleted(continuation);
+                }
+
+                public void UnsafeOnCompleted(Action continuation)
+                {
+                    parent.whenComplete = continuation;
+                    if (IsCompleted)
+                    {
+                        var action = Interlocked.Exchange(ref parent.whenComplete, null);
+                        if (action != null)
+                        {
+                            action();
+                        }
+                    }
+                }
+            }
+        }
+
+        class WhenAllPromise<T1, T2, T3, T4, T5>
+        {
+            const int MaxCount = 5;
+
+            T1 result1;
+            T2 result2;
+            T3 result3;
+            T4 result4;
+            T5 result5;
+            ExceptionDispatchInfo exception;
+            int completeCount;
+            Action whenComplete;
+
+            public WhenAllPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5)
+            {
+                this.completeCount = 0;
+                this.whenComplete = null;
+                this.result1 = default(T1);
+                this.result2 = default(T2);
+                this.result3 = default(T3);
+                this.result4 = default(T4);
+                this.result5 = default(T5);
+                this.exception = null;
+
+                RunTask1(task1);
+                RunTask2(task2);
+                RunTask3(task3);
+                RunTask4(task4);
+                RunTask5(task5);
+            }
+
+            void TryCallContinuation()
+            {
+                var action = Interlocked.Exchange(ref whenComplete, null);
+                if (action != null)
+                {
+                    action.Invoke();
+                }
+            }
+
+            void RunTask1(UniTask<T1> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result1 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask1Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask1Async(UniTask<T1> task)
+            {
+                try
+                {
+                    result1 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+            void RunTask2(UniTask<T2> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result2 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask2Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask2Async(UniTask<T2> task)
+            {
+                try
+                {
+                    result2 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+            void RunTask3(UniTask<T3> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result3 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask3Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask3Async(UniTask<T3> task)
+            {
+                try
+                {
+                    result3 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+            void RunTask4(UniTask<T4> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result4 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask4Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask4Async(UniTask<T4> task)
+            {
+                try
+                {
+                    result4 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+            void RunTask5(UniTask<T5> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result5 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask5Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask5Async(UniTask<T5> task)
+            {
+                try
+                {
+                    result5 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+
+            public Awaiter GetAwaiter()
+            {
+                return new Awaiter(this);
+            }
+
+            public struct Awaiter : ICriticalNotifyCompletion
+            {
+                WhenAllPromise<T1, T2, T3, T4, T5> parent;
+
+                public Awaiter(WhenAllPromise<T1, T2, T3, T4, T5> parent)
+                {
+                    this.parent = parent;
+                }
+
+                public bool IsCompleted
+                {
+                    get
+                    {
+                        return parent.exception != null || parent.completeCount == MaxCount;
+                    }
+                }
+
+                public (T1, T2, T3, T4, T5) GetResult()
+                {
+                    if (parent.exception != null)
+                    {
+                        parent.exception.Throw();
+                    }
+
+                    return (parent.result1, parent.result2, parent.result3, parent.result4, parent.result5);
+                }
+
+                public void OnCompleted(Action continuation)
+                {
+                    UnsafeOnCompleted(continuation);
+                }
+
+                public void UnsafeOnCompleted(Action continuation)
+                {
+                    parent.whenComplete = continuation;
+                    if (IsCompleted)
+                    {
+                        var action = Interlocked.Exchange(ref parent.whenComplete, null);
+                        if (action != null)
+                        {
+                            action();
+                        }
+                    }
+                }
+            }
+        }
+
+        class WhenAllPromise<T1, T2, T3, T4, T5, T6>
+        {
+            const int MaxCount = 6;
+
+            T1 result1;
+            T2 result2;
+            T3 result3;
+            T4 result4;
+            T5 result5;
+            T6 result6;
+            ExceptionDispatchInfo exception;
+            int completeCount;
+            Action whenComplete;
+
+            public WhenAllPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6)
+            {
+                this.completeCount = 0;
+                this.whenComplete = null;
+                this.result1 = default(T1);
+                this.result2 = default(T2);
+                this.result3 = default(T3);
+                this.result4 = default(T4);
+                this.result5 = default(T5);
+                this.result6 = default(T6);
+                this.exception = null;
+
+                RunTask1(task1);
+                RunTask2(task2);
+                RunTask3(task3);
+                RunTask4(task4);
+                RunTask5(task5);
+                RunTask6(task6);
+            }
+
+            void TryCallContinuation()
+            {
+                var action = Interlocked.Exchange(ref whenComplete, null);
+                if (action != null)
+                {
+                    action.Invoke();
+                }
+            }
+
+            void RunTask1(UniTask<T1> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result1 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask1Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask1Async(UniTask<T1> task)
+            {
+                try
+                {
+                    result1 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+            void RunTask2(UniTask<T2> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result2 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask2Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask2Async(UniTask<T2> task)
+            {
+                try
+                {
+                    result2 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+            void RunTask3(UniTask<T3> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result3 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask3Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask3Async(UniTask<T3> task)
+            {
+                try
+                {
+                    result3 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+            void RunTask4(UniTask<T4> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result4 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask4Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask4Async(UniTask<T4> task)
+            {
+                try
+                {
+                    result4 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+            void RunTask5(UniTask<T5> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result5 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask5Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask5Async(UniTask<T5> task)
+            {
+                try
+                {
+                    result5 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+            void RunTask6(UniTask<T6> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result6 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask6Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask6Async(UniTask<T6> task)
+            {
+                try
+                {
+                    result6 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+
+            public Awaiter GetAwaiter()
+            {
+                return new Awaiter(this);
+            }
+
+            public struct Awaiter : ICriticalNotifyCompletion
+            {
+                WhenAllPromise<T1, T2, T3, T4, T5, T6> parent;
+
+                public Awaiter(WhenAllPromise<T1, T2, T3, T4, T5, T6> parent)
+                {
+                    this.parent = parent;
+                }
+
+                public bool IsCompleted
+                {
+                    get
+                    {
+                        return parent.exception != null || parent.completeCount == MaxCount;
+                    }
+                }
+
+                public (T1, T2, T3, T4, T5, T6) GetResult()
+                {
+                    if (parent.exception != null)
+                    {
+                        parent.exception.Throw();
+                    }
+
+                    return (parent.result1, parent.result2, parent.result3, parent.result4, parent.result5, parent.result6);
+                }
+
+                public void OnCompleted(Action continuation)
+                {
+                    UnsafeOnCompleted(continuation);
+                }
+
+                public void UnsafeOnCompleted(Action continuation)
+                {
+                    parent.whenComplete = continuation;
+                    if (IsCompleted)
+                    {
+                        var action = Interlocked.Exchange(ref parent.whenComplete, null);
+                        if (action != null)
+                        {
+                            action();
+                        }
+                    }
+                }
+            }
+        }
+
+        class WhenAllPromise<T1, T2, T3, T4, T5, T6, T7>
+        {
+            const int MaxCount = 7;
+
+            T1 result1;
+            T2 result2;
+            T3 result3;
+            T4 result4;
+            T5 result5;
+            T6 result6;
+            T7 result7;
+            ExceptionDispatchInfo exception;
+            int completeCount;
+            Action whenComplete;
+
+            public WhenAllPromise(UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7)
+            {
+                this.completeCount = 0;
+                this.whenComplete = null;
+                this.result1 = default(T1);
+                this.result2 = default(T2);
+                this.result3 = default(T3);
+                this.result4 = default(T4);
+                this.result5 = default(T5);
+                this.result6 = default(T6);
+                this.result7 = default(T7);
+                this.exception = null;
+
+                RunTask1(task1);
+                RunTask2(task2);
+                RunTask3(task3);
+                RunTask4(task4);
+                RunTask5(task5);
+                RunTask6(task6);
+                RunTask7(task7);
+            }
+
+            void TryCallContinuation()
+            {
+                var action = Interlocked.Exchange(ref whenComplete, null);
+                if (action != null)
+                {
+                    action.Invoke();
+                }
+            }
+
+            void RunTask1(UniTask<T1> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result1 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask1Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask1Async(UniTask<T1> task)
+            {
+                try
+                {
+                    result1 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+            void RunTask2(UniTask<T2> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result2 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask2Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask2Async(UniTask<T2> task)
+            {
+                try
+                {
+                    result2 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+            void RunTask3(UniTask<T3> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result3 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask3Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask3Async(UniTask<T3> task)
+            {
+                try
+                {
+                    result3 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+            void RunTask4(UniTask<T4> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result4 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask4Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask4Async(UniTask<T4> task)
+            {
+                try
+                {
+                    result4 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+            void RunTask5(UniTask<T5> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result5 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask5Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask5Async(UniTask<T5> task)
+            {
+                try
+                {
+                    result5 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+            void RunTask6(UniTask<T6> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result6 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask6Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask6Async(UniTask<T6> task)
+            {
+                try
+                {
+                    result6 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+            void RunTask7(UniTask<T7> task)
+            {
+                if (task.IsCompleted)
+                {
+                    try
+                    {
+                        result7 = task.Result;
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ExceptionDispatchInfo.Capture(ex);
+                        TryCallContinuation();
+                        return;
+                    }
+
+                    var count = Interlocked.Increment(ref completeCount);
+                    if (count == MaxCount)
+                    {
+                        TryCallContinuation();
+                    }
+                }
+                else
+                {
+                    RunTask7Async(task).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask7Async(UniTask<T7> task)
+            {
+                try
+                {
+                    result7 = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == MaxCount)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+
+            public Awaiter GetAwaiter()
+            {
+                return new Awaiter(this);
+            }
+
+            public struct Awaiter : ICriticalNotifyCompletion
+            {
+                WhenAllPromise<T1, T2, T3, T4, T5, T6, T7> parent;
+
+                public Awaiter(WhenAllPromise<T1, T2, T3, T4, T5, T6, T7> parent)
+                {
+                    this.parent = parent;
+                }
+
+                public bool IsCompleted
+                {
+                    get
+                    {
+                        return parent.exception != null || parent.completeCount == MaxCount;
+                    }
+                }
+
+                public (T1, T2, T3, T4, T5, T6, T7) GetResult()
+                {
+                    if (parent.exception != null)
+                    {
+                        parent.exception.Throw();
+                    }
+
+                    return (parent.result1, parent.result2, parent.result3, parent.result4, parent.result5, parent.result6, parent.result7);
+                }
+
+                public void OnCompleted(Action continuation)
+                {
+                    UnsafeOnCompleted(continuation);
+                }
+
+                public void UnsafeOnCompleted(Action continuation)
+                {
+                    parent.whenComplete = continuation;
+                    if (IsCompleted)
+                    {
+                        var action = Interlocked.Exchange(ref parent.whenComplete, null);
+                        if (action != null)
+                        {
+                            action();
+                        }
+                    }
+                }
+            }
+        }
+
+    }
+}
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/UniTask.WhenAll.Generated.cs.meta b/Assets/UniRx.Async/UniTask.WhenAll.Generated.cs.meta
new file mode 100644
index 0000000..40ed46c
--- /dev/null
+++ b/Assets/UniRx.Async/UniTask.WhenAll.Generated.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5110117231c8a6d4095fd0cbd3f4c142
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/UniTask.WhenAll.cs b/Assets/UniRx.Async/UniTask.WhenAll.cs
new file mode 100644
index 0000000..715e55b
--- /dev/null
+++ b/Assets/UniRx.Async/UniTask.WhenAll.cs
@@ -0,0 +1,298 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Runtime.ExceptionServices;
+using System.Threading;
+using UniRx.Async.Internal;
+
+namespace UniRx.Async
+{
+    public partial struct UniTask
+    {
+        // UniTask
+
+        public static async UniTask<T[]> WhenAll<T>(params UniTask<T>[] tasks)
+        {
+            return await new WhenAllPromise<T>(tasks, tasks.Length);
+        }
+
+        public static async UniTask<T[]> WhenAll<T>(IEnumerable<UniTask<T>> tasks)
+        {
+            WhenAllPromise<T> promise;
+            using (var span = ArrayPoolUtil.Materialize(tasks))
+            {
+                promise = new WhenAllPromise<T>(span.Array, span.Length);
+            }
+
+            return await promise;
+        }
+
+        public static async UniTask WhenAll(params UniTask[] tasks)
+        {
+            await new WhenAllPromise(tasks, tasks.Length);
+        }
+
+        public static async UniTask WhenAll(IEnumerable<UniTask> tasks)
+        {
+            WhenAllPromise promise;
+            using (var span = ArrayPoolUtil.Materialize(tasks))
+            {
+                promise = new WhenAllPromise(span.Array, span.Length);
+            }
+
+            await promise;
+        }
+
+        class WhenAllPromise<T>
+        {
+            readonly T[] result;
+            int completeCount;
+            Action whenComplete;
+            ExceptionDispatchInfo exception;
+
+            public WhenAllPromise(UniTask<T>[] tasks, int tasksLength)
+            {
+                this.completeCount = 0;
+                this.whenComplete = null;
+                this.exception = null;
+                this.result = new T[tasksLength];
+
+                for (int i = 0; i < tasksLength; i++)
+                {
+                    if (tasks[i].IsCompleted)
+                    {
+                        T value = default(T);
+                        try
+                        {
+                            value = tasks[i].Result;
+                        }
+                        catch (Exception ex)
+                        {
+                            exception = ExceptionDispatchInfo.Capture(ex);
+                            TryCallContinuation();
+                            continue;
+                        }
+
+                        result[i] = value;
+                        var count = Interlocked.Increment(ref completeCount);
+                        if (count == result.Length)
+                        {
+                            TryCallContinuation();
+                        }
+                    }
+                    else
+                    {
+                        RunTask(tasks[i], i).Forget();
+                    }
+                }
+            }
+
+            void TryCallContinuation()
+            {
+                var action = Interlocked.Exchange(ref whenComplete, null);
+                if (action != null)
+                {
+                    action.Invoke();
+                }
+            }
+
+            async UniTaskVoid RunTask(UniTask<T> task, int index)
+            {
+                T value = default(T);
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                result[index] = value;
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == result.Length)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+            public Awaiter GetAwaiter()
+            {
+                return new Awaiter(this);
+            }
+
+            public struct Awaiter : ICriticalNotifyCompletion
+            {
+                WhenAllPromise<T> parent;
+
+                public Awaiter(WhenAllPromise<T> parent)
+                {
+                    this.parent = parent;
+                }
+
+                public bool IsCompleted
+                {
+                    get
+                    {
+                        return parent.exception != null || parent.result.Length == parent.completeCount;
+                    }
+                }
+
+                public T[] GetResult()
+                {
+                    if (parent.exception != null)
+                    {
+                        parent.exception.Throw();
+                    }
+
+                    return parent.result;
+                }
+
+                public void OnCompleted(Action continuation)
+                {
+                    UnsafeOnCompleted(continuation);
+                }
+
+                public void UnsafeOnCompleted(Action continuation)
+                {
+                    parent.whenComplete = continuation;
+                    if (IsCompleted)
+                    {
+                        var action = Interlocked.Exchange(ref parent.whenComplete, null);
+                        if (action != null)
+                        {
+                            action();
+                        }
+                    }
+                }
+            }
+        }
+
+        class WhenAllPromise
+        {
+            int completeCount;
+            int resultLength;
+            Action whenComplete;
+            ExceptionDispatchInfo exception;
+
+            public WhenAllPromise(UniTask[] tasks, int tasksLength)
+            {
+                this.completeCount = 0;
+                this.whenComplete = null;
+                this.exception = null;
+                this.resultLength = tasksLength;
+
+                for (int i = 0; i < tasksLength; i++)
+                {
+                    if (tasks[i].IsCompleted)
+                    {
+                        try
+                        {
+                            tasks[i].GetResult();
+                        }
+                        catch (Exception ex)
+                        {
+                            exception = ExceptionDispatchInfo.Capture(ex);
+                            TryCallContinuation();
+                            continue;
+                        }
+
+                        var count = Interlocked.Increment(ref completeCount);
+                        if (count == resultLength)
+                        {
+                            TryCallContinuation();
+                        }
+                    }
+                    else
+                    {
+                        RunTask(tasks[i], i).Forget();
+                    }
+                }
+            }
+
+            void TryCallContinuation()
+            {
+                var action = Interlocked.Exchange(ref whenComplete, null);
+                if (action != null)
+                {
+                    action.Invoke();
+                }
+            }
+
+            async UniTaskVoid RunTask(UniTask task, int index)
+            {
+                try
+                {
+                    await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == resultLength)
+                {
+                    TryCallContinuation();
+                }
+            }
+
+            public Awaiter GetAwaiter()
+            {
+                return new Awaiter(this);
+            }
+
+            public struct Awaiter : ICriticalNotifyCompletion
+            {
+                WhenAllPromise parent;
+
+                public Awaiter(WhenAllPromise parent)
+                {
+                    this.parent = parent;
+                }
+
+                public bool IsCompleted
+                {
+                    get
+                    {
+                        return parent.exception != null || parent.resultLength == parent.completeCount;
+                    }
+                }
+
+                public void GetResult()
+                {
+                    if (parent.exception != null)
+                    {
+                        parent.exception.Throw();
+                    }
+                }
+
+                public void OnCompleted(Action continuation)
+                {
+                    UnsafeOnCompleted(continuation);
+                }
+
+                public void UnsafeOnCompleted(Action continuation)
+                {
+                    parent.whenComplete = continuation;
+                    if (IsCompleted)
+                    {
+                        var action = Interlocked.Exchange(ref parent.whenComplete, null);
+                        if (action != null)
+                        {
+                            action();
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/UniTask.WhenAll.cs.meta b/Assets/UniRx.Async/UniTask.WhenAll.cs.meta
new file mode 100644
index 0000000..0366aa8
--- /dev/null
+++ b/Assets/UniRx.Async/UniTask.WhenAll.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 355997a305ba64248822eec34998a1a0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/UniTask.WhenAny.Generated.cs b/Assets/UniRx.Async/UniTask.WhenAny.Generated.cs
new file mode 100644
index 0000000..ebc0fe2
--- /dev/null
+++ b/Assets/UniRx.Async/UniTask.WhenAny.Generated.cs
@@ -0,0 +1,1527 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.ExceptionServices;
+using System.Threading;
+
+namespace UniRx.Async
+{
+    public partial struct UniTask
+    {
+        public static async UniTask<(int winArgumentIndex, (bool hasResult, T0 result0), (bool hasResult, T1 result1))> WhenAny<T0, T1>(UniTask<T0> task0, UniTask<T1> task1)
+        {
+            return await new WhenAnyPromise<T0, T1>(task0, task1);
+        }
+
+        public static async UniTask<(int winArgumentIndex, (bool hasResult, T0 result0), (bool hasResult, T1 result1), (bool hasResult, T2 result2))> WhenAny<T0, T1, T2>(UniTask<T0> task0, UniTask<T1> task1, UniTask<T2> task2)
+        {
+            return await new WhenAnyPromise<T0, T1, T2>(task0, task1, task2);
+        }
+
+        public static async UniTask<(int winArgumentIndex, (bool hasResult, T0 result0), (bool hasResult, T1 result1), (bool hasResult, T2 result2), (bool hasResult, T3 result3))> WhenAny<T0, T1, T2, T3>(UniTask<T0> task0, UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3)
+        {
+            return await new WhenAnyPromise<T0, T1, T2, T3>(task0, task1, task2, task3);
+        }
+
+        public static async UniTask<(int winArgumentIndex, (bool hasResult, T0 result0), (bool hasResult, T1 result1), (bool hasResult, T2 result2), (bool hasResult, T3 result3), (bool hasResult, T4 result4))> WhenAny<T0, T1, T2, T3, T4>(UniTask<T0> task0, UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4)
+        {
+            return await new WhenAnyPromise<T0, T1, T2, T3, T4>(task0, task1, task2, task3, task4);
+        }
+
+        public static async UniTask<(int winArgumentIndex, (bool hasResult, T0 result0), (bool hasResult, T1 result1), (bool hasResult, T2 result2), (bool hasResult, T3 result3), (bool hasResult, T4 result4), (bool hasResult, T5 result5))> WhenAny<T0, T1, T2, T3, T4, T5>(UniTask<T0> task0, UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5)
+        {
+            return await new WhenAnyPromise<T0, T1, T2, T3, T4, T5>(task0, task1, task2, task3, task4, task5);
+        }
+
+        public static async UniTask<(int winArgumentIndex, (bool hasResult, T0 result0), (bool hasResult, T1 result1), (bool hasResult, T2 result2), (bool hasResult, T3 result3), (bool hasResult, T4 result4), (bool hasResult, T5 result5), (bool hasResult, T6 result6))> WhenAny<T0, T1, T2, T3, T4, T5, T6>(UniTask<T0> task0, UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6)
+        {
+            return await new WhenAnyPromise<T0, T1, T2, T3, T4, T5, T6>(task0, task1, task2, task3, task4, task5, task6);
+        }
+
+        public static async UniTask<(int winArgumentIndex, (bool hasResult, T0 result0), (bool hasResult, T1 result1), (bool hasResult, T2 result2), (bool hasResult, T3 result3), (bool hasResult, T4 result4), (bool hasResult, T5 result5), (bool hasResult, T6 result6), (bool hasResult, T7 result7))> WhenAny<T0, T1, T2, T3, T4, T5, T6, T7>(UniTask<T0> task0, UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7)
+        {
+            return await new WhenAnyPromise<T0, T1, T2, T3, T4, T5, T6, T7>(task0, task1, task2, task3, task4, task5, task6, task7);
+        }
+
+        class WhenAnyPromise<T0, T1>
+        {
+            T0 result0;
+            T1 result1;
+            ExceptionDispatchInfo exception;
+            Action whenComplete;
+            int completeCount;
+            int winArgumentIndex;
+
+            bool IsCompleted => exception != null || Volatile.Read(ref winArgumentIndex) != -1;
+
+            public WhenAnyPromise(UniTask<T0> task0, UniTask<T1> task1)
+            {
+                this.whenComplete = null;
+                this.exception = null;
+                this.completeCount = 0;
+                this.winArgumentIndex = -1;
+                this.result0 = default(T0);
+                this.result1 = default(T1);
+
+                RunTask0(task0).Forget();
+                RunTask1(task1).Forget();
+            }
+
+            void TryCallContinuation()
+            {
+                var action = Interlocked.Exchange(ref whenComplete, null);
+                if (action != null)
+                {
+                    action.Invoke();
+                }
+            }
+
+            async UniTaskVoid RunTask0(UniTask<T0> task)
+            {
+                T0 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result0 = value;
+                    Volatile.Write(ref winArgumentIndex, 0);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask1(UniTask<T1> task)
+            {
+                T1 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result1 = value;
+                    Volatile.Write(ref winArgumentIndex, 1);
+                    TryCallContinuation();
+                }
+            }
+
+
+            public Awaiter GetAwaiter()
+            {
+                return new Awaiter(this);
+            }
+
+            public struct Awaiter : ICriticalNotifyCompletion
+            {
+                WhenAnyPromise<T0, T1> parent;
+
+                public Awaiter(WhenAnyPromise<T0, T1> parent)
+                {
+                    this.parent = parent;
+                }
+
+                public bool IsCompleted
+                {
+                    get
+                    {
+                        return parent.IsCompleted;
+                    }
+                }
+
+                public (int, (bool, T0), (bool, T1)) GetResult()
+                {
+                    if (parent.exception != null)
+                    {
+                        parent.exception.Throw();
+                    }
+
+                    var i = parent.winArgumentIndex;
+                    return (i, (i == 0, parent.result0), (i == 1, parent.result1));
+                }
+
+                public void OnCompleted(Action continuation)
+                {
+                    UnsafeOnCompleted(continuation);
+                }
+
+                public void UnsafeOnCompleted(Action continuation)
+                {
+                    parent.whenComplete = continuation;
+                    if (IsCompleted)
+                    {
+                        var action = Interlocked.Exchange(ref parent.whenComplete, null);
+                        if (action != null)
+                        {
+                            action();
+                        }
+                    }
+                }
+            }
+        }
+
+        class WhenAnyPromise<T0, T1, T2>
+        {
+            T0 result0;
+            T1 result1;
+            T2 result2;
+            ExceptionDispatchInfo exception;
+            Action whenComplete;
+            int completeCount;
+            int winArgumentIndex;
+
+            bool IsCompleted => exception != null || Volatile.Read(ref winArgumentIndex) != -1;
+
+            public WhenAnyPromise(UniTask<T0> task0, UniTask<T1> task1, UniTask<T2> task2)
+            {
+                this.whenComplete = null;
+                this.exception = null;
+                this.completeCount = 0;
+                this.winArgumentIndex = -1;
+                this.result0 = default(T0);
+                this.result1 = default(T1);
+                this.result2 = default(T2);
+
+                RunTask0(task0).Forget();
+                RunTask1(task1).Forget();
+                RunTask2(task2).Forget();
+            }
+
+            void TryCallContinuation()
+            {
+                var action = Interlocked.Exchange(ref whenComplete, null);
+                if (action != null)
+                {
+                    action.Invoke();
+                }
+            }
+
+            async UniTaskVoid RunTask0(UniTask<T0> task)
+            {
+                T0 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result0 = value;
+                    Volatile.Write(ref winArgumentIndex, 0);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask1(UniTask<T1> task)
+            {
+                T1 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result1 = value;
+                    Volatile.Write(ref winArgumentIndex, 1);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask2(UniTask<T2> task)
+            {
+                T2 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result2 = value;
+                    Volatile.Write(ref winArgumentIndex, 2);
+                    TryCallContinuation();
+                }
+            }
+
+
+            public Awaiter GetAwaiter()
+            {
+                return new Awaiter(this);
+            }
+
+            public struct Awaiter : ICriticalNotifyCompletion
+            {
+                WhenAnyPromise<T0, T1, T2> parent;
+
+                public Awaiter(WhenAnyPromise<T0, T1, T2> parent)
+                {
+                    this.parent = parent;
+                }
+
+                public bool IsCompleted
+                {
+                    get
+                    {
+                        return parent.IsCompleted;
+                    }
+                }
+
+                public (int, (bool, T0), (bool, T1), (bool, T2)) GetResult()
+                {
+                    if (parent.exception != null)
+                    {
+                        parent.exception.Throw();
+                    }
+
+                    var i = parent.winArgumentIndex;
+                    return (i, (i == 0, parent.result0), (i == 1, parent.result1), (i == 2, parent.result2));
+                }
+
+                public void OnCompleted(Action continuation)
+                {
+                    UnsafeOnCompleted(continuation);
+                }
+
+                public void UnsafeOnCompleted(Action continuation)
+                {
+                    parent.whenComplete = continuation;
+                    if (IsCompleted)
+                    {
+                        var action = Interlocked.Exchange(ref parent.whenComplete, null);
+                        if (action != null)
+                        {
+                            action();
+                        }
+                    }
+                }
+            }
+        }
+
+        class WhenAnyPromise<T0, T1, T2, T3>
+        {
+            T0 result0;
+            T1 result1;
+            T2 result2;
+            T3 result3;
+            ExceptionDispatchInfo exception;
+            Action whenComplete;
+            int completeCount;
+            int winArgumentIndex;
+
+            bool IsCompleted => exception != null || Volatile.Read(ref winArgumentIndex) != -1;
+
+            public WhenAnyPromise(UniTask<T0> task0, UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3)
+            {
+                this.whenComplete = null;
+                this.exception = null;
+                this.completeCount = 0;
+                this.winArgumentIndex = -1;
+                this.result0 = default(T0);
+                this.result1 = default(T1);
+                this.result2 = default(T2);
+                this.result3 = default(T3);
+
+                RunTask0(task0).Forget();
+                RunTask1(task1).Forget();
+                RunTask2(task2).Forget();
+                RunTask3(task3).Forget();
+            }
+
+            void TryCallContinuation()
+            {
+                var action = Interlocked.Exchange(ref whenComplete, null);
+                if (action != null)
+                {
+                    action.Invoke();
+                }
+            }
+
+            async UniTaskVoid RunTask0(UniTask<T0> task)
+            {
+                T0 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result0 = value;
+                    Volatile.Write(ref winArgumentIndex, 0);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask1(UniTask<T1> task)
+            {
+                T1 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result1 = value;
+                    Volatile.Write(ref winArgumentIndex, 1);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask2(UniTask<T2> task)
+            {
+                T2 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result2 = value;
+                    Volatile.Write(ref winArgumentIndex, 2);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask3(UniTask<T3> task)
+            {
+                T3 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result3 = value;
+                    Volatile.Write(ref winArgumentIndex, 3);
+                    TryCallContinuation();
+                }
+            }
+
+
+            public Awaiter GetAwaiter()
+            {
+                return new Awaiter(this);
+            }
+
+            public struct Awaiter : ICriticalNotifyCompletion
+            {
+                WhenAnyPromise<T0, T1, T2, T3> parent;
+
+                public Awaiter(WhenAnyPromise<T0, T1, T2, T3> parent)
+                {
+                    this.parent = parent;
+                }
+
+                public bool IsCompleted
+                {
+                    get
+                    {
+                        return parent.IsCompleted;
+                    }
+                }
+
+                public (int, (bool, T0), (bool, T1), (bool, T2), (bool, T3)) GetResult()
+                {
+                    if (parent.exception != null)
+                    {
+                        parent.exception.Throw();
+                    }
+
+                    var i = parent.winArgumentIndex;
+                    return (i, (i == 0, parent.result0), (i == 1, parent.result1), (i == 2, parent.result2), (i == 3, parent.result3));
+                }
+
+                public void OnCompleted(Action continuation)
+                {
+                    UnsafeOnCompleted(continuation);
+                }
+
+                public void UnsafeOnCompleted(Action continuation)
+                {
+                    parent.whenComplete = continuation;
+                    if (IsCompleted)
+                    {
+                        var action = Interlocked.Exchange(ref parent.whenComplete, null);
+                        if (action != null)
+                        {
+                            action();
+                        }
+                    }
+                }
+            }
+        }
+
+        class WhenAnyPromise<T0, T1, T2, T3, T4>
+        {
+            T0 result0;
+            T1 result1;
+            T2 result2;
+            T3 result3;
+            T4 result4;
+            ExceptionDispatchInfo exception;
+            Action whenComplete;
+            int completeCount;
+            int winArgumentIndex;
+
+            bool IsCompleted => exception != null || Volatile.Read(ref winArgumentIndex) != -1;
+
+            public WhenAnyPromise(UniTask<T0> task0, UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4)
+            {
+                this.whenComplete = null;
+                this.exception = null;
+                this.completeCount = 0;
+                this.winArgumentIndex = -1;
+                this.result0 = default(T0);
+                this.result1 = default(T1);
+                this.result2 = default(T2);
+                this.result3 = default(T3);
+                this.result4 = default(T4);
+
+                RunTask0(task0).Forget();
+                RunTask1(task1).Forget();
+                RunTask2(task2).Forget();
+                RunTask3(task3).Forget();
+                RunTask4(task4).Forget();
+            }
+
+            void TryCallContinuation()
+            {
+                var action = Interlocked.Exchange(ref whenComplete, null);
+                if (action != null)
+                {
+                    action.Invoke();
+                }
+            }
+
+            async UniTaskVoid RunTask0(UniTask<T0> task)
+            {
+                T0 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result0 = value;
+                    Volatile.Write(ref winArgumentIndex, 0);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask1(UniTask<T1> task)
+            {
+                T1 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result1 = value;
+                    Volatile.Write(ref winArgumentIndex, 1);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask2(UniTask<T2> task)
+            {
+                T2 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result2 = value;
+                    Volatile.Write(ref winArgumentIndex, 2);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask3(UniTask<T3> task)
+            {
+                T3 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result3 = value;
+                    Volatile.Write(ref winArgumentIndex, 3);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask4(UniTask<T4> task)
+            {
+                T4 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result4 = value;
+                    Volatile.Write(ref winArgumentIndex, 4);
+                    TryCallContinuation();
+                }
+            }
+
+
+            public Awaiter GetAwaiter()
+            {
+                return new Awaiter(this);
+            }
+
+            public struct Awaiter : ICriticalNotifyCompletion
+            {
+                WhenAnyPromise<T0, T1, T2, T3, T4> parent;
+
+                public Awaiter(WhenAnyPromise<T0, T1, T2, T3, T4> parent)
+                {
+                    this.parent = parent;
+                }
+
+                public bool IsCompleted
+                {
+                    get
+                    {
+                        return parent.IsCompleted;
+                    }
+                }
+
+                public (int, (bool, T0), (bool, T1), (bool, T2), (bool, T3), (bool, T4)) GetResult()
+                {
+                    if (parent.exception != null)
+                    {
+                        parent.exception.Throw();
+                    }
+
+                    var i = parent.winArgumentIndex;
+                    return (i, (i == 0, parent.result0), (i == 1, parent.result1), (i == 2, parent.result2), (i == 3, parent.result3), (i == 4, parent.result4));
+                }
+
+                public void OnCompleted(Action continuation)
+                {
+                    UnsafeOnCompleted(continuation);
+                }
+
+                public void UnsafeOnCompleted(Action continuation)
+                {
+                    parent.whenComplete = continuation;
+                    if (IsCompleted)
+                    {
+                        var action = Interlocked.Exchange(ref parent.whenComplete, null);
+                        if (action != null)
+                        {
+                            action();
+                        }
+                    }
+                }
+            }
+        }
+
+        class WhenAnyPromise<T0, T1, T2, T3, T4, T5>
+        {
+            T0 result0;
+            T1 result1;
+            T2 result2;
+            T3 result3;
+            T4 result4;
+            T5 result5;
+            ExceptionDispatchInfo exception;
+            Action whenComplete;
+            int completeCount;
+            int winArgumentIndex;
+
+            bool IsCompleted => exception != null || Volatile.Read(ref winArgumentIndex) != -1;
+
+            public WhenAnyPromise(UniTask<T0> task0, UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5)
+            {
+                this.whenComplete = null;
+                this.exception = null;
+                this.completeCount = 0;
+                this.winArgumentIndex = -1;
+                this.result0 = default(T0);
+                this.result1 = default(T1);
+                this.result2 = default(T2);
+                this.result3 = default(T3);
+                this.result4 = default(T4);
+                this.result5 = default(T5);
+
+                RunTask0(task0).Forget();
+                RunTask1(task1).Forget();
+                RunTask2(task2).Forget();
+                RunTask3(task3).Forget();
+                RunTask4(task4).Forget();
+                RunTask5(task5).Forget();
+            }
+
+            void TryCallContinuation()
+            {
+                var action = Interlocked.Exchange(ref whenComplete, null);
+                if (action != null)
+                {
+                    action.Invoke();
+                }
+            }
+
+            async UniTaskVoid RunTask0(UniTask<T0> task)
+            {
+                T0 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result0 = value;
+                    Volatile.Write(ref winArgumentIndex, 0);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask1(UniTask<T1> task)
+            {
+                T1 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result1 = value;
+                    Volatile.Write(ref winArgumentIndex, 1);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask2(UniTask<T2> task)
+            {
+                T2 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result2 = value;
+                    Volatile.Write(ref winArgumentIndex, 2);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask3(UniTask<T3> task)
+            {
+                T3 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result3 = value;
+                    Volatile.Write(ref winArgumentIndex, 3);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask4(UniTask<T4> task)
+            {
+                T4 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result4 = value;
+                    Volatile.Write(ref winArgumentIndex, 4);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask5(UniTask<T5> task)
+            {
+                T5 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result5 = value;
+                    Volatile.Write(ref winArgumentIndex, 5);
+                    TryCallContinuation();
+                }
+            }
+
+
+            public Awaiter GetAwaiter()
+            {
+                return new Awaiter(this);
+            }
+
+            public struct Awaiter : ICriticalNotifyCompletion
+            {
+                WhenAnyPromise<T0, T1, T2, T3, T4, T5> parent;
+
+                public Awaiter(WhenAnyPromise<T0, T1, T2, T3, T4, T5> parent)
+                {
+                    this.parent = parent;
+                }
+
+                public bool IsCompleted
+                {
+                    get
+                    {
+                        return parent.IsCompleted;
+                    }
+                }
+
+                public (int, (bool, T0), (bool, T1), (bool, T2), (bool, T3), (bool, T4), (bool, T5)) GetResult()
+                {
+                    if (parent.exception != null)
+                    {
+                        parent.exception.Throw();
+                    }
+
+                    var i = parent.winArgumentIndex;
+                    return (i, (i == 0, parent.result0), (i == 1, parent.result1), (i == 2, parent.result2), (i == 3, parent.result3), (i == 4, parent.result4), (i == 5, parent.result5));
+                }
+
+                public void OnCompleted(Action continuation)
+                {
+                    UnsafeOnCompleted(continuation);
+                }
+
+                public void UnsafeOnCompleted(Action continuation)
+                {
+                    parent.whenComplete = continuation;
+                    if (IsCompleted)
+                    {
+                        var action = Interlocked.Exchange(ref parent.whenComplete, null);
+                        if (action != null)
+                        {
+                            action();
+                        }
+                    }
+                }
+            }
+        }
+
+        class WhenAnyPromise<T0, T1, T2, T3, T4, T5, T6>
+        {
+            T0 result0;
+            T1 result1;
+            T2 result2;
+            T3 result3;
+            T4 result4;
+            T5 result5;
+            T6 result6;
+            ExceptionDispatchInfo exception;
+            Action whenComplete;
+            int completeCount;
+            int winArgumentIndex;
+
+            bool IsCompleted => exception != null || Volatile.Read(ref winArgumentIndex) != -1;
+
+            public WhenAnyPromise(UniTask<T0> task0, UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6)
+            {
+                this.whenComplete = null;
+                this.exception = null;
+                this.completeCount = 0;
+                this.winArgumentIndex = -1;
+                this.result0 = default(T0);
+                this.result1 = default(T1);
+                this.result2 = default(T2);
+                this.result3 = default(T3);
+                this.result4 = default(T4);
+                this.result5 = default(T5);
+                this.result6 = default(T6);
+
+                RunTask0(task0).Forget();
+                RunTask1(task1).Forget();
+                RunTask2(task2).Forget();
+                RunTask3(task3).Forget();
+                RunTask4(task4).Forget();
+                RunTask5(task5).Forget();
+                RunTask6(task6).Forget();
+            }
+
+            void TryCallContinuation()
+            {
+                var action = Interlocked.Exchange(ref whenComplete, null);
+                if (action != null)
+                {
+                    action.Invoke();
+                }
+            }
+
+            async UniTaskVoid RunTask0(UniTask<T0> task)
+            {
+                T0 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result0 = value;
+                    Volatile.Write(ref winArgumentIndex, 0);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask1(UniTask<T1> task)
+            {
+                T1 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result1 = value;
+                    Volatile.Write(ref winArgumentIndex, 1);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask2(UniTask<T2> task)
+            {
+                T2 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result2 = value;
+                    Volatile.Write(ref winArgumentIndex, 2);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask3(UniTask<T3> task)
+            {
+                T3 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result3 = value;
+                    Volatile.Write(ref winArgumentIndex, 3);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask4(UniTask<T4> task)
+            {
+                T4 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result4 = value;
+                    Volatile.Write(ref winArgumentIndex, 4);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask5(UniTask<T5> task)
+            {
+                T5 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result5 = value;
+                    Volatile.Write(ref winArgumentIndex, 5);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask6(UniTask<T6> task)
+            {
+                T6 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result6 = value;
+                    Volatile.Write(ref winArgumentIndex, 6);
+                    TryCallContinuation();
+                }
+            }
+
+
+            public Awaiter GetAwaiter()
+            {
+                return new Awaiter(this);
+            }
+
+            public struct Awaiter : ICriticalNotifyCompletion
+            {
+                WhenAnyPromise<T0, T1, T2, T3, T4, T5, T6> parent;
+
+                public Awaiter(WhenAnyPromise<T0, T1, T2, T3, T4, T5, T6> parent)
+                {
+                    this.parent = parent;
+                }
+
+                public bool IsCompleted
+                {
+                    get
+                    {
+                        return parent.IsCompleted;
+                    }
+                }
+
+                public (int, (bool, T0), (bool, T1), (bool, T2), (bool, T3), (bool, T4), (bool, T5), (bool, T6)) GetResult()
+                {
+                    if (parent.exception != null)
+                    {
+                        parent.exception.Throw();
+                    }
+
+                    var i = parent.winArgumentIndex;
+                    return (i, (i == 0, parent.result0), (i == 1, parent.result1), (i == 2, parent.result2), (i == 3, parent.result3), (i == 4, parent.result4), (i == 5, parent.result5), (i == 6, parent.result6));
+                }
+
+                public void OnCompleted(Action continuation)
+                {
+                    UnsafeOnCompleted(continuation);
+                }
+
+                public void UnsafeOnCompleted(Action continuation)
+                {
+                    parent.whenComplete = continuation;
+                    if (IsCompleted)
+                    {
+                        var action = Interlocked.Exchange(ref parent.whenComplete, null);
+                        if (action != null)
+                        {
+                            action();
+                        }
+                    }
+                }
+            }
+        }
+
+        class WhenAnyPromise<T0, T1, T2, T3, T4, T5, T6, T7>
+        {
+            T0 result0;
+            T1 result1;
+            T2 result2;
+            T3 result3;
+            T4 result4;
+            T5 result5;
+            T6 result6;
+            T7 result7;
+            ExceptionDispatchInfo exception;
+            Action whenComplete;
+            int completeCount;
+            int winArgumentIndex;
+
+            bool IsCompleted => exception != null || Volatile.Read(ref winArgumentIndex) != -1;
+
+            public WhenAnyPromise(UniTask<T0> task0, UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7)
+            {
+                this.whenComplete = null;
+                this.exception = null;
+                this.completeCount = 0;
+                this.winArgumentIndex = -1;
+                this.result0 = default(T0);
+                this.result1 = default(T1);
+                this.result2 = default(T2);
+                this.result3 = default(T3);
+                this.result4 = default(T4);
+                this.result5 = default(T5);
+                this.result6 = default(T6);
+                this.result7 = default(T7);
+
+                RunTask0(task0).Forget();
+                RunTask1(task1).Forget();
+                RunTask2(task2).Forget();
+                RunTask3(task3).Forget();
+                RunTask4(task4).Forget();
+                RunTask5(task5).Forget();
+                RunTask6(task6).Forget();
+                RunTask7(task7).Forget();
+            }
+
+            void TryCallContinuation()
+            {
+                var action = Interlocked.Exchange(ref whenComplete, null);
+                if (action != null)
+                {
+                    action.Invoke();
+                }
+            }
+
+            async UniTaskVoid RunTask0(UniTask<T0> task)
+            {
+                T0 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result0 = value;
+                    Volatile.Write(ref winArgumentIndex, 0);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask1(UniTask<T1> task)
+            {
+                T1 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result1 = value;
+                    Volatile.Write(ref winArgumentIndex, 1);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask2(UniTask<T2> task)
+            {
+                T2 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result2 = value;
+                    Volatile.Write(ref winArgumentIndex, 2);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask3(UniTask<T3> task)
+            {
+                T3 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result3 = value;
+                    Volatile.Write(ref winArgumentIndex, 3);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask4(UniTask<T4> task)
+            {
+                T4 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result4 = value;
+                    Volatile.Write(ref winArgumentIndex, 4);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask5(UniTask<T5> task)
+            {
+                T5 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result5 = value;
+                    Volatile.Write(ref winArgumentIndex, 5);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask6(UniTask<T6> task)
+            {
+                T6 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result6 = value;
+                    Volatile.Write(ref winArgumentIndex, 6);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask7(UniTask<T7> task)
+            {
+                T7 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result7 = value;
+                    Volatile.Write(ref winArgumentIndex, 7);
+                    TryCallContinuation();
+                }
+            }
+
+
+            public Awaiter GetAwaiter()
+            {
+                return new Awaiter(this);
+            }
+
+            public struct Awaiter : ICriticalNotifyCompletion
+            {
+                WhenAnyPromise<T0, T1, T2, T3, T4, T5, T6, T7> parent;
+
+                public Awaiter(WhenAnyPromise<T0, T1, T2, T3, T4, T5, T6, T7> parent)
+                {
+                    this.parent = parent;
+                }
+
+                public bool IsCompleted
+                {
+                    get
+                    {
+                        return parent.IsCompleted;
+                    }
+                }
+
+                public (int, (bool, T0), (bool, T1), (bool, T2), (bool, T3), (bool, T4), (bool, T5), (bool, T6), (bool, T7)) GetResult()
+                {
+                    if (parent.exception != null)
+                    {
+                        parent.exception.Throw();
+                    }
+
+                    var i = parent.winArgumentIndex;
+                    return (i, (i == 0, parent.result0), (i == 1, parent.result1), (i == 2, parent.result2), (i == 3, parent.result3), (i == 4, parent.result4), (i == 5, parent.result5), (i == 6, parent.result6), (i == 7, parent.result7));
+                }
+
+                public void OnCompleted(Action continuation)
+                {
+                    UnsafeOnCompleted(continuation);
+                }
+
+                public void UnsafeOnCompleted(Action continuation)
+                {
+                    parent.whenComplete = continuation;
+                    if (IsCompleted)
+                    {
+                        var action = Interlocked.Exchange(ref parent.whenComplete, null);
+                        if (action != null)
+                        {
+                            action();
+                        }
+                    }
+                }
+            }
+        }
+
+    }
+}
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/UniTask.WhenAny.Generated.cs.meta b/Assets/UniRx.Async/UniTask.WhenAny.Generated.cs.meta
new file mode 100644
index 0000000..49a2c3f
--- /dev/null
+++ b/Assets/UniRx.Async/UniTask.WhenAny.Generated.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 13d604ac281570c4eac9962429f19ca9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/UniTask.WhenAny.cs b/Assets/UniRx.Async/UniTask.WhenAny.cs
new file mode 100644
index 0000000..2c5049b
--- /dev/null
+++ b/Assets/UniRx.Async/UniTask.WhenAny.cs
@@ -0,0 +1,374 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.ExceptionServices;
+using System.Threading;
+
+namespace UniRx.Async
+{
+    public partial struct UniTask
+    {
+        // UniTask
+
+        public static async UniTask<(bool hasResultLeft, T0 result)> WhenAny<T0>(UniTask<T0> task0, UniTask task1)
+        {
+            return await new UnitWhenAnyPromise<T0>(task0, task1);
+        }
+
+        public static async UniTask<(int winArgumentIndex, T result)> WhenAny<T>(params UniTask<T>[] tasks)
+        {
+            return await new WhenAnyPromise<T>(tasks);
+        }
+
+        /// <summary>Return value is winArgumentIndex</summary>
+        public static async UniTask<int> WhenAny(params UniTask[] tasks)
+        {
+            return await new WhenAnyPromise(tasks);
+        }
+
+        class UnitWhenAnyPromise<T0>
+        {
+            T0 result0;
+            ExceptionDispatchInfo exception;
+            Action whenComplete;
+            int completeCount;
+            int winArgumentIndex;
+
+            bool IsCompleted => exception != null || Volatile.Read(ref winArgumentIndex) != -1;
+
+            public UnitWhenAnyPromise(UniTask<T0> task0, UniTask task1)
+            {
+                this.whenComplete = null;
+                this.exception = null;
+                this.completeCount = 0;
+                this.winArgumentIndex = -1;
+                this.result0 = default(T0);
+
+                RunTask0(task0).Forget();
+                RunTask1(task1).Forget();
+            }
+
+            void TryCallContinuation()
+            {
+                var action = Interlocked.Exchange(ref whenComplete, null);
+                if (action != null)
+                {
+                    action.Invoke();
+                }
+            }
+
+            async UniTaskVoid RunTask0(UniTask<T0> task)
+            {
+                T0 value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result0 = value;
+                    Volatile.Write(ref winArgumentIndex, 0);
+                    TryCallContinuation();
+                }
+            }
+
+            async UniTaskVoid RunTask1(UniTask task)
+            {
+                try
+                {
+                    await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    Volatile.Write(ref winArgumentIndex, 1);
+                    TryCallContinuation();
+                }
+            }
+
+
+            public Awaiter GetAwaiter()
+            {
+                return new Awaiter(this);
+            }
+
+            public struct Awaiter : ICriticalNotifyCompletion
+            {
+                UnitWhenAnyPromise<T0> parent;
+
+                public Awaiter(UnitWhenAnyPromise<T0> parent)
+                {
+                    this.parent = parent;
+                }
+
+                public bool IsCompleted
+                {
+                    get
+                    {
+                        return parent.IsCompleted;
+                    }
+                }
+
+                public (bool, T0) GetResult()
+                {
+                    if (parent.exception != null)
+                    {
+                        parent.exception.Throw();
+                    }
+
+                    return (parent.winArgumentIndex == 0, parent.result0);
+                }
+
+                public void OnCompleted(Action continuation)
+                {
+                    UnsafeOnCompleted(continuation);
+                }
+
+                public void UnsafeOnCompleted(Action continuation)
+                {
+                    parent.whenComplete = continuation;
+                    if (IsCompleted)
+                    {
+                        var action = Interlocked.Exchange(ref parent.whenComplete, null);
+                        if (action != null)
+                        {
+                            action();
+                        }
+                    }
+                }
+            }
+        }
+
+
+        class WhenAnyPromise<T>
+        {
+            T result;
+            int completeCount;
+            int winArgumentIndex;
+            Action whenComplete;
+            ExceptionDispatchInfo exception;
+
+            public bool IsComplete => exception != null || Volatile.Read(ref winArgumentIndex) != -1;
+
+            public WhenAnyPromise(UniTask<T>[] tasks)
+            {
+                this.completeCount = 0;
+                this.winArgumentIndex = -1;
+                this.whenComplete = null;
+                this.exception = null;
+                this.result = default(T);
+
+                for (int i = 0; i < tasks.Length; i++)
+                {
+                    RunTask(tasks[i], i).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask(UniTask<T> task, int index)
+            {
+                T value;
+                try
+                {
+                    value = await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    result = value;
+                    Volatile.Write(ref winArgumentIndex, index);
+                    TryCallContinuation();
+                }
+            }
+
+            void TryCallContinuation()
+            {
+                var action = Interlocked.Exchange(ref whenComplete, null);
+                if (action != null)
+                {
+                    action.Invoke();
+                }
+            }
+
+            public Awaiter GetAwaiter()
+            {
+                return new Awaiter(this);
+            }
+
+            public struct Awaiter : ICriticalNotifyCompletion
+            {
+                WhenAnyPromise<T> parent;
+
+                public Awaiter(WhenAnyPromise<T> parent)
+                {
+                    this.parent = parent;
+                }
+
+                public bool IsCompleted
+                {
+                    get
+                    {
+                        return parent.IsComplete;
+                    }
+                }
+
+                public (int, T) GetResult()
+                {
+                    if (parent.exception != null)
+                    {
+                        parent.exception.Throw();
+                    }
+
+                    return (parent.winArgumentIndex, parent.result);
+                }
+
+                public void OnCompleted(Action continuation)
+                {
+                    UnsafeOnCompleted(continuation);
+                }
+
+                public void UnsafeOnCompleted(Action continuation)
+                {
+                    parent.whenComplete = continuation;
+                    if (IsCompleted)
+                    {
+                        var action = Interlocked.Exchange(ref parent.whenComplete, null);
+                        if (action != null)
+                        {
+                            action();
+                        }
+                    }
+                }
+            }
+        }
+
+        class WhenAnyPromise
+        {
+            int completeCount;
+            int winArgumentIndex;
+            Action whenComplete;
+            ExceptionDispatchInfo exception;
+
+            public bool IsComplete => exception != null || Volatile.Read(ref winArgumentIndex) != -1;
+
+            public WhenAnyPromise(UniTask[] tasks)
+            {
+                this.completeCount = 0;
+                this.winArgumentIndex = -1;
+                this.whenComplete = null;
+                this.exception = null;
+
+                for (int i = 0; i < tasks.Length; i++)
+                {
+                    RunTask(tasks[i], i).Forget();
+                }
+            }
+
+            async UniTaskVoid RunTask(UniTask task, int index)
+            {
+                try
+                {
+                    await task;
+                }
+                catch (Exception ex)
+                {
+                    exception = ExceptionDispatchInfo.Capture(ex);
+                    TryCallContinuation();
+                    return;
+                }
+
+                var count = Interlocked.Increment(ref completeCount);
+                if (count == 1)
+                {
+                    Volatile.Write(ref winArgumentIndex, index);
+                    TryCallContinuation();
+                }
+            }
+
+            void TryCallContinuation()
+            {
+                var action = Interlocked.Exchange(ref whenComplete, null);
+                if (action != null)
+                {
+                    action.Invoke();
+                }
+            }
+
+            public Awaiter GetAwaiter()
+            {
+                return new Awaiter(this);
+            }
+
+            public struct Awaiter : ICriticalNotifyCompletion
+            {
+                WhenAnyPromise parent;
+
+                public Awaiter(WhenAnyPromise parent)
+                {
+                    this.parent = parent;
+                }
+
+                public bool IsCompleted
+                {
+                    get
+                    {
+                        return parent.IsComplete;
+                    }
+                }
+
+                public int GetResult()
+                {
+                    if (parent.exception != null)
+                    {
+                        parent.exception.Throw();
+                    }
+
+                    return parent.winArgumentIndex;
+                }
+
+                public void OnCompleted(Action continuation)
+                {
+                    UnsafeOnCompleted(continuation);
+                }
+
+                public void UnsafeOnCompleted(Action continuation)
+                {
+                    parent.whenComplete = continuation;
+                    if (IsCompleted)
+                    {
+                        var action = Interlocked.Exchange(ref parent.whenComplete, null);
+                        if (action != null)
+                        {
+                            action();
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/UniTask.WhenAny.cs.meta b/Assets/UniRx.Async/UniTask.WhenAny.cs.meta
new file mode 100644
index 0000000..c10f762
--- /dev/null
+++ b/Assets/UniRx.Async/UniTask.WhenAny.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c32578978c37eaf41bdd90e1b034637d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/UniTask.cs b/Assets/UniRx.Async/UniTask.cs
new file mode 100644
index 0000000..25c533d
--- /dev/null
+++ b/Assets/UniRx.Async/UniTask.cs
@@ -0,0 +1,479 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using UniRx.Async.CompilerServices;
+using UniRx.Async.Internal;
+
+namespace UniRx.Async
+{
+    /// <summary>
+    /// Lightweight unity specified task-like object.
+    /// </summary>
+    [AsyncMethodBuilder(typeof(AsyncUniTaskMethodBuilder))]
+    public partial struct UniTask : IEquatable<UniTask>
+    {
+        static readonly UniTask<AsyncUnit> DefaultAsyncUnitTask = new UniTask<AsyncUnit>(AsyncUnit.Default);
+
+        readonly IAwaiter awaiter;
+
+        [DebuggerHidden]
+        public UniTask(IAwaiter awaiter)
+        {
+            this.awaiter = awaiter;
+        }
+
+        [DebuggerHidden]
+        public UniTask(Func<UniTask> factory)
+        {
+            this.awaiter = new LazyPromise(factory);
+        }
+
+        [DebuggerHidden]
+        public AwaiterStatus Status
+        {
+            get
+            {
+                return awaiter == null ? AwaiterStatus.Succeeded : awaiter.Status;
+            }
+        }
+
+        [DebuggerHidden]
+        public bool IsCompleted
+        {
+            get
+            {
+                return awaiter == null ? true : awaiter.IsCompleted;
+            }
+        }
+
+        [DebuggerHidden]
+        public void GetResult()
+        {
+            if (awaiter != null)
+            {
+                awaiter.GetResult();
+            }
+        }
+
+        [DebuggerHidden]
+        public Awaiter GetAwaiter()
+        {
+            return new Awaiter(this);
+        }
+
+        /// <summary>
+        /// returns (bool IsCanceled) instead of throws OperationCanceledException.
+        /// </summary>
+        public UniTask<bool> SuppressCancellationThrow()
+        {
+            var status = Status;
+            if (status == AwaiterStatus.Succeeded) return CompletedTasks.False;
+            if (status == AwaiterStatus.Canceled) return CompletedTasks.True;
+            return new UniTask<bool>(new IsCanceledAwaiter(awaiter));
+        }
+
+        public bool Equals(UniTask other)
+        {
+            if (this.awaiter == null && other.awaiter == null)
+            {
+                return true;
+            }
+            else if (this.awaiter != null && other.awaiter != null)
+            {
+                return this.awaiter == other.awaiter;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        public override int GetHashCode()
+        {
+            if (this.awaiter == null)
+            {
+                return 0;
+            }
+            else
+            {
+                return this.awaiter.GetHashCode();
+            }
+        }
+
+        public override string ToString()
+        {
+            return (this.awaiter == null) ? "()"
+                 : (this.awaiter.Status == AwaiterStatus.Succeeded) ? "()"
+                 : "(" + this.awaiter.Status + ")";
+        }
+
+        public static implicit operator UniTask<AsyncUnit>(UniTask task)
+        {
+            if (task.awaiter != null)
+            {
+                if (task.awaiter.IsCompleted)
+                {
+                    return DefaultAsyncUnitTask;
+                }
+                else
+                {
+                    // UniTask<T> -> UniTask is free but UniTask -> UniTask<T> requires wrapping cost.
+                    return new UniTask<AsyncUnit>(new AsyncUnitAwaiter(task.awaiter));
+                }
+            }
+            else
+            {
+                return DefaultAsyncUnitTask;
+            }
+        }
+
+        class AsyncUnitAwaiter : IAwaiter<AsyncUnit>
+        {
+            readonly IAwaiter awaiter;
+
+            public AsyncUnitAwaiter(IAwaiter awaiter)
+            {
+                this.awaiter = awaiter;
+            }
+
+            public bool IsCompleted => awaiter.IsCompleted;
+
+            public AwaiterStatus Status => awaiter.Status;
+
+            public AsyncUnit GetResult()
+            {
+                awaiter.GetResult();
+                return AsyncUnit.Default;
+            }
+
+            public void OnCompleted(Action continuation)
+            {
+                awaiter.OnCompleted(continuation);
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                awaiter.UnsafeOnCompleted(continuation);
+            }
+
+            void IAwaiter.GetResult()
+            {
+                awaiter.GetResult();
+            }
+        }
+
+        class IsCanceledAwaiter : IAwaiter<bool>
+        {
+            readonly IAwaiter awaiter;
+
+            public IsCanceledAwaiter(IAwaiter awaiter)
+            {
+                this.awaiter = awaiter;
+            }
+
+            public bool IsCompleted => awaiter.IsCompleted;
+
+            public AwaiterStatus Status => awaiter.Status;
+
+            public bool GetResult()
+            {
+                if (awaiter.Status == AwaiterStatus.Canceled)
+                {
+                    return true;
+                }
+                awaiter.GetResult();
+                return false;
+            }
+
+            public void OnCompleted(Action continuation)
+            {
+                awaiter.OnCompleted(continuation);
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                awaiter.UnsafeOnCompleted(continuation);
+            }
+
+            void IAwaiter.GetResult()
+            {
+                awaiter.GetResult();
+            }
+        }
+
+        public struct Awaiter : IAwaiter
+        {
+            readonly UniTask task;
+
+            [DebuggerHidden]
+            public Awaiter(UniTask task)
+            {
+                this.task = task;
+            }
+
+            [DebuggerHidden]
+            public bool IsCompleted => task.IsCompleted;
+
+            [DebuggerHidden]
+            public AwaiterStatus Status => task.Status;
+
+            [DebuggerHidden]
+            public void GetResult() => task.GetResult();
+
+            [DebuggerHidden]
+            public void OnCompleted(Action continuation)
+            {
+                if (task.awaiter != null)
+                {
+                    task.awaiter.OnCompleted(continuation);
+                }
+                else
+                {
+                    continuation();
+                }
+            }
+
+            [DebuggerHidden]
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                if (task.awaiter != null)
+                {
+                    task.awaiter.UnsafeOnCompleted(continuation);
+                }
+                else
+                {
+                    continuation();
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// Lightweight unity specified task-like object.
+    /// </summary>
+    [AsyncMethodBuilder(typeof(AsyncUniTaskMethodBuilder<>))]
+    public struct UniTask<T> : IEquatable<UniTask<T>>
+    {
+        readonly T result;
+        readonly IAwaiter<T> awaiter;
+
+        [DebuggerHidden]
+        public UniTask(T result)
+        {
+            this.result = result;
+            this.awaiter = null;
+        }
+
+        [DebuggerHidden]
+        public UniTask(IAwaiter<T> awaiter)
+        {
+            this.result = default(T);
+            this.awaiter = awaiter;
+        }
+
+        [DebuggerHidden]
+        public UniTask(Func<UniTask<T>> factory)
+        {
+            this.result = default(T);
+            this.awaiter = new LazyPromise<T>(factory);
+        }
+
+        [DebuggerHidden]
+        public AwaiterStatus Status
+        {
+            get
+            {
+                return awaiter == null ? AwaiterStatus.Succeeded : awaiter.Status;
+            }
+        }
+
+        [DebuggerHidden]
+        public bool IsCompleted
+        {
+            get
+            {
+                return awaiter == null ? true : awaiter.IsCompleted;
+            }
+        }
+
+        [DebuggerHidden]
+        public T Result
+        {
+            get
+            {
+                if (awaiter == null)
+                {
+                    return result;
+                }
+                else
+                {
+                    return awaiter.GetResult();
+                }
+            }
+        }
+
+        [DebuggerHidden]
+        public Awaiter GetAwaiter()
+        {
+            return new Awaiter(this);
+        }
+
+        /// <summary>
+        /// returns (bool IsCanceled, T Result) instead of throws OperationCanceledException.
+        /// </summary>
+        public UniTask<(bool IsCanceled, T Result)> SuppressCancellationThrow()
+        {
+            var status = Status;
+            if (status == AwaiterStatus.Succeeded)
+            {
+                return new UniTask<(bool, T)>((false, Result));
+            }
+            else if (status == AwaiterStatus.Canceled)
+            {
+                return new UniTask<(bool, T)>((true, default(T)));
+            }
+            return new UniTask<(bool, T)>(new IsCanceledAwaiter(awaiter));
+        }
+
+        public bool Equals(UniTask<T> other)
+        {
+            if (this.awaiter == null && other.awaiter == null)
+            {
+                return EqualityComparer<T>.Default.Equals(this.result, other.result);
+            }
+            else if (this.awaiter != null && other.awaiter != null)
+            {
+                return this.awaiter == other.awaiter;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        public override int GetHashCode()
+        {
+            if (this.awaiter == null)
+            {
+                if (result == null) return 0;
+                return result.GetHashCode();
+            }
+            else
+            {
+                return this.awaiter.GetHashCode();
+            }
+        }
+
+        public override string ToString()
+        {
+            return (this.awaiter == null) ? result.ToString()
+                 : (this.awaiter.Status == AwaiterStatus.Succeeded) ? this.awaiter.GetResult().ToString()
+                 : "(" + this.awaiter.Status + ")";
+        }
+
+        public static implicit operator UniTask(UniTask<T> task)
+        {
+            if (task.awaiter != null)
+            {
+                return new UniTask(task.awaiter);
+            }
+            else
+            {
+                return new UniTask();
+            }
+        }
+
+        class IsCanceledAwaiter : IAwaiter<(bool, T)>
+        {
+            readonly IAwaiter<T> awaiter;
+
+            public IsCanceledAwaiter(IAwaiter<T> awaiter)
+            {
+                this.awaiter = awaiter;
+            }
+
+            public bool IsCompleted => awaiter.IsCompleted;
+
+            public AwaiterStatus Status => awaiter.Status;
+
+            public (bool, T) GetResult()
+            {
+                if (awaiter.Status == AwaiterStatus.Canceled)
+                {
+                    return (true, default(T));
+                }
+                return (false, awaiter.GetResult());
+            }
+
+            public void OnCompleted(Action continuation)
+            {
+                awaiter.OnCompleted(continuation);
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                awaiter.UnsafeOnCompleted(continuation);
+            }
+
+            void IAwaiter.GetResult()
+            {
+                awaiter.GetResult();
+            }
+        }
+
+        public struct Awaiter : IAwaiter<T>
+        {
+            readonly UniTask<T> task;
+
+            [DebuggerHidden]
+            public Awaiter(UniTask<T> task)
+            {
+                this.task = task;
+            }
+
+            [DebuggerHidden]
+            public bool IsCompleted => task.IsCompleted;
+
+            [DebuggerHidden]
+            public AwaiterStatus Status => task.Status;
+
+            [DebuggerHidden]
+            void IAwaiter.GetResult() => GetResult();
+
+            [DebuggerHidden]
+            public T GetResult() => task.Result;
+
+            [DebuggerHidden]
+            public void OnCompleted(Action continuation)
+            {
+                if (task.awaiter != null)
+                {
+                    task.awaiter.OnCompleted(continuation);
+                }
+                else
+                {
+                    continuation();
+                }
+            }
+
+            [DebuggerHidden]
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                if (task.awaiter != null)
+                {
+                    task.awaiter.UnsafeOnCompleted(continuation);
+                }
+                else
+                {
+                    continuation();
+                }
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/UniTask.cs.meta b/Assets/UniRx.Async/UniTask.cs.meta
new file mode 100644
index 0000000..04eb6b6
--- /dev/null
+++ b/Assets/UniRx.Async/UniTask.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8947adf23181ff04db73829df217ca94
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/UniTaskCompletionSource.cs b/Assets/UniRx.Async/UniTaskCompletionSource.cs
new file mode 100644
index 0000000..c9a148d
--- /dev/null
+++ b/Assets/UniRx.Async/UniTaskCompletionSource.cs
@@ -0,0 +1,413 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.ExceptionServices;
+using System.Threading;
+using UniRx.Async.Internal;
+
+namespace UniRx.Async
+{
+    internal class ExceptionHolder
+    {
+        ExceptionDispatchInfo exception;
+        bool calledGet = false;
+
+        public ExceptionHolder(ExceptionDispatchInfo exception)
+        {
+            this.exception = exception;
+        }
+
+        public ExceptionDispatchInfo GetException()
+        {
+            if (!calledGet)
+            {
+                calledGet = true;
+                GC.SuppressFinalize(this);
+            }
+            return exception;
+        }
+
+        ~ExceptionHolder()
+        {
+            UniTaskScheduler.PublishUnobservedTaskException(exception.SourceException);
+        }
+    }
+
+    public interface IResolvePromise
+    {
+        bool TrySetResult();
+    }
+
+    public interface IResolvePromise<T>
+    {
+        bool TrySetResult(T value);
+    }
+
+    public interface IRejectPromise
+    {
+        bool TrySetException(Exception exception);
+    }
+
+    public interface ICancelPromise
+    {
+        bool TrySetCanceled();
+    }
+
+    public interface IPromise<T> : IResolvePromise<T>, IRejectPromise, ICancelPromise
+    {
+    }
+
+    public interface IPromise : IResolvePromise, IRejectPromise, ICancelPromise
+    {
+    }
+
+    public class UniTaskCompletionSource : IAwaiter, IPromise
+    {
+        // State(= AwaiterStatus)
+        const int Pending = 0;
+        const int Succeeded = 1;
+        const int Faulted = 2;
+        const int Canceled = 3;
+
+        int state = 0;
+        bool handled = false;
+        ExceptionHolder exception;
+        object continuation; // action or list
+
+        AwaiterStatus IAwaiter.Status => (AwaiterStatus)state;
+
+        bool IAwaiter.IsCompleted => state != Pending;
+
+        public UniTask Task => new UniTask(this);
+
+        public UniTaskCompletionSource()
+        {
+            TaskTracker.TrackActiveTask(this, 2);
+        }
+
+        [Conditional("UNITY_EDITOR")]
+        internal void MarkHandled()
+        {
+            if (!handled)
+            {
+                handled = true;
+                TaskTracker.RemoveTracking(this);
+            }
+        }
+
+        void IAwaiter.GetResult()
+        {
+            MarkHandled();
+
+            if (state == Succeeded)
+            {
+                return;
+            }
+            else if (state == Faulted)
+            {
+                exception.GetException().Throw();
+            }
+            else if (state == Canceled)
+            {
+                if (exception != null)
+                {
+                    exception.GetException().Throw(); // guranteed operation canceled exception.
+                }
+
+                throw new OperationCanceledException();
+            }
+            else // Pending
+            {
+                throw new NotSupportedException("UniTask does not allow call GetResult directly when task not completed. Please use 'await'.");
+            }
+        }
+
+        void ICriticalNotifyCompletion.UnsafeOnCompleted(Action action)
+        {
+            if (Interlocked.CompareExchange(ref continuation, (object)action, null) == null)
+            {
+                if (state != Pending)
+                {
+                    TryInvokeContinuation();
+                }
+            }
+            else
+            {
+                var c = continuation;
+                if (c is Action)
+                {
+                    var list = new List<Action>();
+                    list.Add((Action)c);
+                    list.Add(action);
+                    if (Interlocked.CompareExchange(ref continuation, list, c) == c)
+                    {
+                        goto TRYINVOKE;
+                    }
+                }
+
+                var l = (List<Action>)continuation;
+                lock (l)
+                {
+                    l.Add(action);
+                }
+
+                TRYINVOKE:
+                if (state != Pending)
+                {
+                    TryInvokeContinuation();
+                }
+            }
+        }
+
+        void TryInvokeContinuation()
+        {
+            var c = Interlocked.Exchange(ref continuation, null);
+            if (c != null)
+            {
+                if (c is Action)
+                {
+                    ((Action)c).Invoke();
+                }
+                else
+                {
+                    var l = (List<Action>)c;
+                    var cnt = l.Count;
+                    for (int i = 0; i < cnt; i++)
+                    {
+                        l[i].Invoke();
+                    }
+                }
+            }
+        }
+
+        public bool TrySetResult()
+        {
+            if (Interlocked.CompareExchange(ref state, Succeeded, Pending) == Pending)
+            {
+                TryInvokeContinuation();
+                return true;
+            }
+            return false;
+        }
+
+        public bool TrySetException(Exception exception)
+        {
+            if (Interlocked.CompareExchange(ref state, Faulted, Pending) == Pending)
+            {
+                this.exception = new ExceptionHolder(ExceptionDispatchInfo.Capture(exception));
+                TryInvokeContinuation();
+                return true;
+            }
+            return false;
+        }
+
+        public bool TrySetCanceled()
+        {
+            if (Interlocked.CompareExchange(ref state, Canceled, Pending) == Pending)
+            {
+                TryInvokeContinuation();
+                return true;
+            }
+            return false;
+        }
+
+        public bool TrySetCanceled(OperationCanceledException exception)
+        {
+            if (Interlocked.CompareExchange(ref state, Canceled, Pending) == Pending)
+            {
+                this.exception = new ExceptionHolder(ExceptionDispatchInfo.Capture(exception));
+                TryInvokeContinuation();
+                return true;
+            }
+            return false;
+        }
+
+        void INotifyCompletion.OnCompleted(Action continuation)
+        {
+            ((ICriticalNotifyCompletion)this).UnsafeOnCompleted(continuation);
+        }
+    }
+
+    public class UniTaskCompletionSource<T> : IAwaiter<T>, IPromise<T>
+    {
+        // State(= AwaiterStatus)
+        const int Pending = 0;
+        const int Succeeded = 1;
+        const int Faulted = 2;
+        const int Canceled = 3;
+
+        int state = 0;
+        T value;
+        bool handled = false;
+        ExceptionHolder exception;
+        object continuation; // action or list
+
+        bool IAwaiter.IsCompleted => state != Pending;
+
+        public UniTask<T> Task => new UniTask<T>(this);
+        public UniTask UnitTask => new UniTask(this);
+
+        AwaiterStatus IAwaiter.Status => (AwaiterStatus)state;
+
+        public UniTaskCompletionSource()
+        {
+            TaskTracker.TrackActiveTask(this, 2);
+        }
+
+        [Conditional("UNITY_EDITOR")]
+        internal void MarkHandled()
+        {
+            if (!handled)
+            {
+                handled = true;
+                TaskTracker.RemoveTracking(this);
+            }
+        }
+
+        T IAwaiter<T>.GetResult()
+        {
+            MarkHandled();
+
+            if (state == Succeeded)
+            {
+                return value;
+            }
+            else if (state == Faulted)
+            {
+                exception.GetException().Throw();
+            }
+            else if (state == Canceled)
+            {
+                if (exception != null)
+                {
+                    exception.GetException().Throw(); // guranteed operation canceled exception.
+                }
+
+                throw new OperationCanceledException();
+            }
+            else // Pending
+            {
+                throw new NotSupportedException("UniTask does not allow call GetResult directly when task not completed. Please use 'await'.");
+            }
+
+            return default(T);
+        }
+
+        void ICriticalNotifyCompletion.UnsafeOnCompleted(Action action)
+        {
+            if (Interlocked.CompareExchange(ref continuation, (object)action, null) == null)
+            {
+                if (state != Pending)
+                {
+                    TryInvokeContinuation();
+                }
+            }
+            else
+            {
+                var c = continuation;
+                if (c is Action)
+                {
+                    var list = new List<Action>();
+                    list.Add((Action)c);
+                    list.Add(action);
+                    if (Interlocked.CompareExchange(ref continuation, list, c) == c)
+                    {
+                        goto TRYINVOKE;
+                    }
+                }
+
+                var l = (List<Action>)continuation;
+                lock (l)
+                {
+                    l.Add(action);
+                }
+
+                TRYINVOKE:
+                if (state != Pending)
+                {
+                    TryInvokeContinuation();
+                }
+            }
+        }
+
+        void TryInvokeContinuation()
+        {
+            var c = Interlocked.Exchange(ref continuation, null);
+            if (c != null)
+            {
+                if (c is Action)
+                {
+                    ((Action)c).Invoke();
+                }
+                else
+                {
+                    var l = (List<Action>)c;
+                    var cnt = l.Count;
+                    for (int i = 0; i < cnt; i++)
+                    {
+                        l[i].Invoke();
+                    }
+                }
+            }
+        }
+
+        public bool TrySetResult(T value)
+        {
+            if (Interlocked.CompareExchange(ref state, Succeeded, Pending) == Pending)
+            {
+                this.value = value;
+                TryInvokeContinuation();
+                return true;
+            }
+            return false;
+        }
+
+        public bool TrySetException(Exception exception)
+        {
+            if (Interlocked.CompareExchange(ref state, Faulted, Pending) == Pending)
+            {
+                this.exception = new ExceptionHolder(ExceptionDispatchInfo.Capture(exception));
+                TryInvokeContinuation();
+                return true;
+            }
+            return false;
+        }
+
+        public bool TrySetCanceled()
+        {
+            if (Interlocked.CompareExchange(ref state, Canceled, Pending) == Pending)
+            {
+                TryInvokeContinuation();
+                return true;
+            }
+            return false;
+        }
+
+        public bool TrySetCanceled(OperationCanceledException exception)
+        {
+            if (Interlocked.CompareExchange(ref state, Canceled, Pending) == Pending)
+            {
+                this.exception = new ExceptionHolder(ExceptionDispatchInfo.Capture(exception));
+                TryInvokeContinuation();
+                return true;
+            }
+            return false;
+        }
+
+        void IAwaiter.GetResult()
+        {
+            ((IAwaiter<T>)this).GetResult();
+        }
+
+        void INotifyCompletion.OnCompleted(Action continuation)
+        {
+            ((ICriticalNotifyCompletion)this).UnsafeOnCompleted(continuation);
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/UniTaskCompletionSource.cs.meta b/Assets/UniRx.Async/UniTaskCompletionSource.cs.meta
new file mode 100644
index 0000000..2ae5ee3
--- /dev/null
+++ b/Assets/UniRx.Async/UniTaskCompletionSource.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ed03524d09e7eb24a9fb9137198feb84
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/UniTaskExtensions.Shorthand.cs b/Assets/UniRx.Async/UniTaskExtensions.Shorthand.cs
new file mode 100644
index 0000000..235bcac
--- /dev/null
+++ b/Assets/UniRx.Async/UniTaskExtensions.Shorthand.cs
@@ -0,0 +1,53 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+
+namespace UniRx.Async
+{
+    public static partial class UniTaskExtensions
+    {
+        // shorthand of WhenAll
+
+        public static UniTask.Awaiter GetAwaiter(this IEnumerable<UniTask> tasks)
+        {
+            return UniTask.WhenAll(tasks).GetAwaiter();
+        }
+
+        public static UniTask<T[]>.Awaiter GetAwaiter<T>(this IEnumerable<UniTask<T>> tasks)
+        {
+            return UniTask.WhenAll(tasks).GetAwaiter();
+        }
+
+        public static UniTask<(T1 result1, T2 result2)>.Awaiter GetAwaiter<T1, T2>(this (UniTask<T1> task1, UniTask<T2> task2) tasks)
+        {
+            return UniTask.WhenAll(tasks.task1, tasks.task2).GetAwaiter();
+        }
+
+        public static UniTask<(T1 result1, T2 result2, T3 result3)> WhenAll<T1, T2, T3>(this (UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3) tasks)
+        {
+            return UniTask.WhenAll<T1, T2, T3>(tasks.task1, tasks.task2, tasks.task3);
+        }
+
+        public static UniTask<(T1 result1, T2 result2, T3 result3, T4 result4)> WhenAll<T1, T2, T3, T4>(this (UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4) tasks)
+        {
+            return UniTask.WhenAll<T1, T2, T3, T4>(tasks.task1, tasks.task2, tasks.task3, tasks.task4);
+        }
+
+        public static UniTask<(T1 result1, T2 result2, T3 result3, T4 result4, T5 result5)> WhenAll<T1, T2, T3, T4, T5>(this (UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5) tasks)
+        {
+            return UniTask.WhenAll<T1, T2, T3, T4, T5>(tasks.task1, tasks.task2, tasks.task3, tasks.task4, tasks.task5);
+        }
+
+        public static UniTask<(T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6)> WhenAll<T1, T2, T3, T4, T5, T6>(this (UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6) tasks)
+        {
+            return UniTask.WhenAll<T1, T2, T3, T4, T5, T6>(tasks.task1, tasks.task2, tasks.task3, tasks.task4, tasks.task5, tasks.task6);
+        }
+
+        public static UniTask<(T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7)> WhenAll<T1, T2, T3, T4, T5, T6, T7>(this (UniTask<T1> task1, UniTask<T2> task2, UniTask<T3> task3, UniTask<T4> task4, UniTask<T5> task5, UniTask<T6> task6, UniTask<T7> task7) tasks)
+        {
+            return UniTask.WhenAll<T1, T2, T3, T4, T5, T6, T7>(tasks.task1, tasks.task2, tasks.task3, tasks.task4, tasks.task5, tasks.task6, tasks.task7);
+        }
+    }
+}
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/UniTaskExtensions.Shorthand.cs.meta b/Assets/UniRx.Async/UniTaskExtensions.Shorthand.cs.meta
new file mode 100644
index 0000000..e2dcc14
--- /dev/null
+++ b/Assets/UniRx.Async/UniTaskExtensions.Shorthand.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4b4ff020f73dc6d4b8ebd4760d61fb43
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/UniTaskExtensions.cs b/Assets/UniRx.Async/UniTaskExtensions.cs
new file mode 100644
index 0000000..06642df
--- /dev/null
+++ b/Assets/UniRx.Async/UniTaskExtensions.cs
@@ -0,0 +1,486 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Collections;
+using System.Runtime.ExceptionServices;
+using System.Threading;
+using System.Threading.Tasks;
+using UniRx.Async.Internal;
+
+namespace UniRx.Async
+{
+    public static partial class UniTaskExtensions
+    {
+        /// <summary>
+        /// Convert UniTask -> UniTask[AsyncUnit].
+        /// </summary>
+        public static UniTask<AsyncUnit> AsAsyncUnitUniTask(this UniTask task)
+        {
+            // use implicit conversion
+            return task;
+        }
+
+        /// <summary>
+        /// Convert Task[T] -> UniTask[T].
+        /// </summary>
+        public static UniTask<T> AsUniTask<T>(this Task<T> task, bool useCurrentSynchronizationContext = true)
+        {
+            var promise = new UniTaskCompletionSource<T>();
+
+            task.ContinueWith((x, state) =>
+            {
+                var p = (UniTaskCompletionSource<T>)state;
+
+                switch (x.Status)
+                {
+                    case TaskStatus.Canceled:
+                        p.TrySetCanceled();
+                        break;
+                    case TaskStatus.Faulted:
+                        p.TrySetException(x.Exception);
+                        break;
+                    case TaskStatus.RanToCompletion:
+                        p.TrySetResult(x.Result);
+                        break;
+                    default:
+                        throw new NotSupportedException();
+                }
+            }, promise, useCurrentSynchronizationContext ? TaskScheduler.FromCurrentSynchronizationContext() : TaskScheduler.Current);
+
+            return new UniTask<T>(promise);
+        }
+
+        /// <summary>
+        /// Convert Task -> UniTask.
+        /// </summary>
+        public static UniTask AsUniTask(this Task task, bool useCurrentSynchronizationContext = true)
+        {
+            var promise = new UniTaskCompletionSource<AsyncUnit>();
+
+            task.ContinueWith((x, state) =>
+            {
+                var p = (UniTaskCompletionSource<AsyncUnit>)state;
+
+                switch (x.Status)
+                {
+                    case TaskStatus.Canceled:
+                        p.TrySetCanceled();
+                        break;
+                    case TaskStatus.Faulted:
+                        p.TrySetException(x.Exception);
+                        break;
+                    case TaskStatus.RanToCompletion:
+                        p.TrySetResult(default(AsyncUnit));
+                        break;
+                    default:
+                        throw new NotSupportedException();
+                }
+            }, promise, useCurrentSynchronizationContext ? TaskScheduler.FromCurrentSynchronizationContext() : TaskScheduler.Current);
+
+            return new UniTask(promise);
+        }
+
+        public static IEnumerator ToCoroutine<T>(this UniTask<T> task, Action<T> resultHandler = null, Action<Exception> exceptionHandler = null)
+        {
+            return new ToCoroutineEnumerator<T>(task, resultHandler, exceptionHandler);
+        }
+
+        public static IEnumerator ToCoroutine(this UniTask task, Action<Exception> exceptionHandler = null)
+        {
+            return new ToCoroutineEnumerator(task, exceptionHandler);
+        }
+
+        public static UniTask Timeout(this UniTask task, TimeSpan timeout, bool ignoreTimeScale = true, PlayerLoopTiming timeoutCheckTiming = PlayerLoopTiming.Update, CancellationTokenSource taskCancellationTokenSource = null)
+        {
+            return Timeout(task.AsAsyncUnitUniTask(), timeout, ignoreTimeScale, timeoutCheckTiming, taskCancellationTokenSource);
+        }
+
+        public static async UniTask<T> Timeout<T>(this UniTask<T> task, TimeSpan timeout, bool ignoreTimeScale = true, PlayerLoopTiming timeoutCheckTiming = PlayerLoopTiming.Update, CancellationTokenSource taskCancellationTokenSource = null)
+        {
+            // left, right both suppress operation canceled exception.
+
+            var delayCancellationTokenSource = new CancellationTokenSource();
+            var timeoutTask = (UniTask)UniTask.Delay(timeout, ignoreTimeScale, timeoutCheckTiming).SuppressCancellationThrow();
+
+            var (hasValue, value) = await UniTask.WhenAny(task.SuppressCancellationThrow(), timeoutTask);
+
+            if (!hasValue)
+            {
+                if (taskCancellationTokenSource != null)
+                {
+                    taskCancellationTokenSource.Cancel();
+                    taskCancellationTokenSource.Dispose();
+                }
+
+                throw new TimeoutException("Exceed Timeout:" + timeout);
+            }
+            else
+            {
+                delayCancellationTokenSource.Cancel();
+                delayCancellationTokenSource.Dispose();
+            }
+
+            if (value.IsCanceled)
+            {
+                Error.ThrowOperationCanceledException();
+            }
+
+            return value.Result;
+        }
+
+        /// <summary>
+        /// Timeout with suppress OperationCanceledException. Returns (bool, IsCacneled).
+        /// </summary>
+        public static async UniTask<bool> TimeoutWithoutException(this UniTask task, TimeSpan timeout, bool ignoreTimeScale = true, PlayerLoopTiming timeoutCheckTiming = PlayerLoopTiming.Update, CancellationTokenSource taskCancellationTokenSource = null)
+        {
+            var v = await TimeoutWithoutException(task.AsAsyncUnitUniTask(), timeout, ignoreTimeScale, timeoutCheckTiming, taskCancellationTokenSource);
+            return v.IsTimeout;
+        }
+
+
+        /// <summary>
+        /// Timeout with suppress OperationCanceledException. Returns (bool IsTimeout, T Result).
+        /// </summary>
+        public static async UniTask<(bool IsTimeout, T Result)> TimeoutWithoutException<T>(this UniTask<T> task, TimeSpan timeout, bool ignoreTimeScale = true, PlayerLoopTiming timeoutCheckTiming = PlayerLoopTiming.Update, CancellationTokenSource taskCancellationTokenSource = null)
+        {
+            // left, right both suppress operation canceled exception.
+
+            var delayCancellationTokenSource = new CancellationTokenSource();
+            var timeoutTask = (UniTask)UniTask.Delay(timeout, ignoreTimeScale, timeoutCheckTiming).SuppressCancellationThrow();
+
+            var (hasValue, value) = await UniTask.WhenAny(task.SuppressCancellationThrow(), timeoutTask);
+
+            if (!hasValue)
+            {
+                if (taskCancellationTokenSource != null)
+                {
+                    taskCancellationTokenSource.Cancel();
+                    taskCancellationTokenSource.Dispose();
+                }
+
+                return (true, default(T));
+            }
+            else
+            {
+                delayCancellationTokenSource.Cancel();
+                delayCancellationTokenSource.Dispose();
+            }
+
+            if (value.IsCanceled)
+            {
+                Error.ThrowOperationCanceledException();
+            }
+
+            return (false, value.Result);
+        }
+
+        public static void Forget(this UniTask task)
+        {
+            ForgetCore(task).Forget();
+        }
+
+        public static void Forget(this UniTask task, Action<Exception> exceptionHandler, bool handleExceptionOnMainThread = true)
+        {
+            if (exceptionHandler == null)
+            {
+                ForgetCore(task).Forget();
+            }
+            else
+            {
+                ForgetCoreWithCatch(task, exceptionHandler, handleExceptionOnMainThread).Forget();
+            }
+        }
+
+        // UniTask to UniTaskVoid
+        static async UniTaskVoid ForgetCore(UniTask task)
+        {
+            await task;
+        }
+
+        static async UniTaskVoid ForgetCoreWithCatch(UniTask task, Action<Exception> exceptionHandler, bool handleExceptionOnMainThread)
+        {
+            try
+            {
+                await task;
+            }
+            catch (Exception ex)
+            {
+                try
+                {
+                    if (handleExceptionOnMainThread)
+                    {
+                        await UniTask.SwitchToMainThread();
+                    }
+                    exceptionHandler(ex);
+                }
+                catch (Exception ex2)
+                {
+                    UniTaskScheduler.PublishUnobservedTaskException(ex2);
+                }
+            }
+        }
+
+        public static void Forget<T>(this UniTask<T> task)
+        {
+            ForgetCore(task).Forget();
+        }
+
+        public static void Forget<T>(this UniTask<T> task, Action<Exception> exceptionHandler, bool handleExceptionOnMainThread = true)
+        {
+            if (exceptionHandler == null)
+            {
+                ForgetCore(task).Forget();
+            }
+            else
+            {
+                ForgetCoreWithCatch(task, exceptionHandler, handleExceptionOnMainThread).Forget();
+            }
+        }
+
+        // UniTask to UniTaskVoid
+        static async UniTaskVoid ForgetCore<T>(UniTask<T> task)
+        {
+            await task;
+        }
+
+        static async UniTaskVoid ForgetCoreWithCatch<T>(UniTask<T> task, Action<Exception> exceptionHandler, bool handleExceptionOnMainThread)
+        {
+            try
+            {
+                await task;
+            }
+            catch (Exception ex)
+            {
+                try
+                {
+                    if (handleExceptionOnMainThread)
+                    {
+                        await UniTask.SwitchToMainThread();
+                    }
+                    exceptionHandler(ex);
+                }
+                catch (Exception ex2)
+                {
+                    UniTaskScheduler.PublishUnobservedTaskException(ex2);
+                }
+            }
+        }
+
+        public static async UniTask ContinueWith<T>(this UniTask<T> task, Action<T> continuationFunction)
+        {
+            continuationFunction(await task);
+        }
+
+        public static async UniTask ContinueWith<T>(this UniTask<T> task, Func<T, UniTask> continuationFunction)
+        {
+            await continuationFunction(await task);
+        }
+
+        public static async UniTask<TR> ContinueWith<T, TR>(this UniTask<T> task, Func<T, TR> continuationFunction)
+        {
+            return continuationFunction(await task);
+        }
+
+        public static async UniTask<TR> ContinueWith<T, TR>(this UniTask<T> task, Func<T, UniTask<TR>> continuationFunction)
+        {
+            return await continuationFunction(await task);
+        }
+
+        public static async UniTask ContinueWith(this UniTask task, Action continuationFunction)
+        {
+            await task;
+            continuationFunction();
+        }
+
+        public static async UniTask ContinueWith(this UniTask task, Func<UniTask> continuationFunction)
+        {
+            await task;
+            await continuationFunction();
+        }
+
+        public static async UniTask<T> ContinueWith<T>(this UniTask task, Func<T> continuationFunction)
+        {
+            await task;
+            return continuationFunction();
+        }
+
+        public static async UniTask<T> ContinueWith<T>(this UniTask task, Func<UniTask<T>> continuationFunction)
+        {
+            await task;
+            return await continuationFunction();
+        }
+
+        public static async UniTask ConfigureAwait(this Task task, PlayerLoopTiming timing)
+        {
+            await task.ConfigureAwait(false);
+            await UniTask.Yield(timing);
+        }
+
+        public static async UniTask<T> ConfigureAwait<T>(this Task<T> task, PlayerLoopTiming timing)
+        {
+            var v = await task.ConfigureAwait(false);
+            await UniTask.Yield(timing);
+            return v;
+        }
+
+        public static async UniTask ConfigureAwait(this UniTask task, PlayerLoopTiming timing)
+        {
+            await task;
+            await UniTask.Yield(timing);
+        }
+
+        public static async UniTask<T> ConfigureAwait<T>(this UniTask<T> task, PlayerLoopTiming timing)
+        {
+            var v = await task;
+            await UniTask.Yield(timing);
+            return v;
+        }
+
+        public static async UniTask<T> Unwrap<T>(this UniTask<UniTask<T>> task)
+        {
+            return await await task;
+        }
+
+        public static async UniTask Unwrap<T>(this UniTask<UniTask> task)
+        {
+            await await task;
+        }
+
+        class ToCoroutineEnumerator : IEnumerator
+        {
+            bool completed;
+            UniTask task;
+            Action<Exception> exceptionHandler = null;
+            bool isStarted = false;
+            ExceptionDispatchInfo exception;
+
+            public ToCoroutineEnumerator(UniTask task, Action<Exception> exceptionHandler)
+            {
+                completed = false;
+                this.exceptionHandler = exceptionHandler;
+                this.task = task;
+            }
+
+            async UniTaskVoid RunTask(UniTask task)
+            {
+                try
+                {
+                    await task;
+                }
+                catch (Exception ex)
+                {
+                    if (exceptionHandler != null)
+                    {
+                        exceptionHandler(ex);
+                    }
+                    else
+                    {
+                        this.exception = ExceptionDispatchInfo.Capture(ex);
+                    }
+                }
+                finally
+                {
+                    completed = true;
+                }
+            }
+
+            public object Current => null;
+
+            public bool MoveNext()
+            {
+                if (!isStarted)
+                {
+                    isStarted = true;
+                    RunTask(task).Forget();
+                }
+
+                if (exception != null)
+                {
+                    // throw exception on iterator (main)thread.
+                    // unfortunately unity test-runner can not handle throw exception on hand-write IEnumerator.MoveNext.
+                    UnityEngine.Debug.LogException(exception.SourceException);
+                }
+
+                return !completed;
+            }
+
+            public void Reset()
+            {
+            }
+        }
+
+        class ToCoroutineEnumerator<T> : IEnumerator
+        {
+            bool completed;
+            Action<T> resultHandler = null;
+            Action<Exception> exceptionHandler = null;
+            bool isStarted = false;
+            UniTask<T> task;
+            object current = null;
+            ExceptionDispatchInfo exception;
+
+            public ToCoroutineEnumerator(UniTask<T> task, Action<T> resultHandler, Action<Exception> exceptionHandler)
+            {
+                completed = false;
+                this.task = task;
+                this.resultHandler = resultHandler;
+                this.exceptionHandler = exceptionHandler;
+            }
+
+            async UniTaskVoid RunTask(UniTask<T> task)
+            {
+                try
+                {
+                    var value = await task;
+                    current = value;
+                    if (resultHandler != null)
+                    {
+                        resultHandler(value);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    if (exceptionHandler != null)
+                    {
+                        exceptionHandler(ex);
+                    }
+                    else
+                    {
+                        this.exception = ExceptionDispatchInfo.Capture(ex);
+                    }
+                }
+                finally
+                {
+                    completed = true;
+                }
+            }
+
+            public object Current => current;
+
+            public bool MoveNext()
+            {
+                if (!isStarted)
+                {
+                    isStarted = true;
+                    RunTask(task).Forget();
+                }
+
+                if (exception != null)
+                {
+                    // throw exception on iterator (main)thread.
+                    // unfortunately unity test-runner can not handle throw exception on hand-write IEnumerator.MoveNext.
+                    UnityEngine.Debug.LogException(exception.SourceException);
+                }
+
+                return !completed;
+            }
+
+            public void Reset()
+            {
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/UniTaskExtensions.cs.meta b/Assets/UniRx.Async/UniTaskExtensions.cs.meta
new file mode 100644
index 0000000..0d22946
--- /dev/null
+++ b/Assets/UniRx.Async/UniTaskExtensions.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 05460c617dae1e440861a7438535389f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/UniTaskObservableExtensions.cs b/Assets/UniRx.Async/UniTaskObservableExtensions.cs
new file mode 100644
index 0000000..a089093
--- /dev/null
+++ b/Assets/UniRx.Async/UniTaskObservableExtensions.cs
@@ -0,0 +1,745 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Runtime.ExceptionServices;
+using System.Threading;
+using UniRx.Async.Internal;
+
+namespace UniRx.Async
+{
+    public static class UniTaskObservableExtensions
+    {
+        public static UniTask<T> ToUniTask<T>(this IObservable<T> source, CancellationToken cancellationToken = default(CancellationToken), bool useFirstValue = false)
+        {
+            var promise = new UniTaskCompletionSource<T>();
+            var disposable = new SingleAssignmentDisposable();
+
+            var observer = useFirstValue
+                ? (IObserver<T>)new FirstValueToUniTaskObserver<T>(promise, disposable, cancellationToken)
+                : (IObserver<T>)new ToUniTaskObserver<T>(promise, disposable, cancellationToken);
+
+            try
+            {
+                disposable.Disposable = source.Subscribe(observer);
+            }
+            catch (Exception ex)
+            {
+                promise.TrySetException(ex);
+            }
+
+            return promise.Task;
+        }
+
+        public static IObservable<T> ToObservable<T>(this UniTask<T> task)
+        {
+            if (task.IsCompleted)
+            {
+                try
+                {
+                    return new ReturnObservable<T>(task.GetAwaiter().GetResult());
+                }
+                catch (Exception ex)
+                {
+                    return new ThrowObservable<T>(ex);
+                }
+            }
+
+            var subject = new AsyncSubject<T>();
+            Fire(subject, task).Forget();
+            return subject;
+        }
+
+        /// <summary>
+        /// Ideally returns IObservabl[Unit] is best but UniRx.Async does not have Unit so return AsyncUnit instead.
+        /// </summary>
+        public static IObservable<AsyncUnit> ToObservable(this UniTask task)
+        {
+            if (task.IsCompleted)
+            {
+                try
+                {
+                    return new ReturnObservable<AsyncUnit>(AsyncUnit.Default);
+                }
+                catch (Exception ex)
+                {
+                    return new ThrowObservable<AsyncUnit>(ex);
+                }
+            }
+
+            var subject = new AsyncSubject<AsyncUnit>();
+            Fire(subject, task).Forget();
+            return subject;
+        }
+
+        static async UniTaskVoid Fire<T>(AsyncSubject<T> subject, UniTask<T> task)
+        {
+            try
+            {
+                var value = await task;
+                subject.OnNext(value);
+                subject.OnCompleted();
+            }
+            catch (Exception ex)
+            {
+                subject.OnError(ex);
+            }
+        }
+
+        static async UniTaskVoid Fire(AsyncSubject<object> subject, UniTask task)
+        {
+            try
+            {
+                await task;
+                subject.OnNext(null);
+                subject.OnCompleted();
+            }
+            catch (Exception ex)
+            {
+                subject.OnError(ex);
+            }
+        }
+
+        class ToUniTaskObserver<T> : IObserver<T>
+        {
+            static readonly Action<object> callback = OnCanceled;
+
+            readonly UniTaskCompletionSource<T> promise;
+            readonly SingleAssignmentDisposable disposable;
+            readonly CancellationToken cancellationToken;
+            readonly CancellationTokenRegistration registration;
+
+            bool hasValue;
+            T latestValue;
+
+            public ToUniTaskObserver(UniTaskCompletionSource<T> promise, SingleAssignmentDisposable disposable, CancellationToken cancellationToken)
+            {
+                this.promise = promise;
+                this.disposable = disposable;
+                this.cancellationToken = cancellationToken;
+
+                if (this.cancellationToken.CanBeCanceled)
+                {
+                    this.registration = this.cancellationToken.RegisterWithoutCaptureExecutionContext(callback, this);
+                }
+            }
+
+            static void OnCanceled(object state)
+            {
+                var self = (ToUniTaskObserver<T>)state;
+                self.disposable.Dispose();
+                self.promise.TrySetCanceled();
+            }
+
+            public void OnNext(T value)
+            {
+                hasValue = true;
+                latestValue = value;
+            }
+
+            public void OnError(Exception error)
+            {
+                try
+                {
+                    promise.TrySetException(error);
+                }
+                finally
+                {
+                    registration.Dispose();
+                    disposable.Dispose();
+                }
+            }
+
+            public void OnCompleted()
+            {
+                try
+                {
+                    if (hasValue)
+                    {
+                        promise.TrySetResult(latestValue);
+                    }
+                    else
+                    {
+                        promise.TrySetException(new InvalidOperationException("Sequence has no elements"));
+                    }
+                }
+                finally
+                {
+                    registration.Dispose();
+                    disposable.Dispose();
+                }
+            }
+        }
+
+        class FirstValueToUniTaskObserver<T> : IObserver<T>
+        {
+            static readonly Action<object> callback = OnCanceled;
+
+            readonly UniTaskCompletionSource<T> promise;
+            readonly SingleAssignmentDisposable disposable;
+            readonly CancellationToken cancellationToken;
+            readonly CancellationTokenRegistration registration;
+
+            bool hasValue;
+
+            public FirstValueToUniTaskObserver(UniTaskCompletionSource<T> promise, SingleAssignmentDisposable disposable, CancellationToken cancellationToken)
+            {
+                this.promise = promise;
+                this.disposable = disposable;
+                this.cancellationToken = cancellationToken;
+
+                if (this.cancellationToken.CanBeCanceled)
+                {
+                    this.registration = this.cancellationToken.RegisterWithoutCaptureExecutionContext(callback, this);
+                }
+            }
+
+            static void OnCanceled(object state)
+            {
+                var self = (FirstValueToUniTaskObserver<T>)state;
+                self.disposable.Dispose();
+                self.promise.TrySetCanceled();
+            }
+
+            public void OnNext(T value)
+            {
+                hasValue = true;
+                try
+                {
+                    promise.TrySetResult(value);
+                }
+                finally
+                {
+                    registration.Dispose();
+                    disposable.Dispose();
+                }
+            }
+
+            public void OnError(Exception error)
+            {
+                try
+                {
+                    promise.TrySetException(error);
+                }
+                finally
+                {
+                    registration.Dispose();
+                    disposable.Dispose();
+                }
+            }
+
+            public void OnCompleted()
+            {
+                try
+                {
+                    if (!hasValue)
+                    {
+                        promise.TrySetException(new InvalidOperationException("Sequence has no elements"));
+                    }
+                }
+                finally
+                {
+                    registration.Dispose();
+                    disposable.Dispose();
+                }
+            }
+        }
+
+        class ReturnObservable<T> : IObservable<T>
+        {
+            readonly T value;
+
+            public ReturnObservable(T value)
+            {
+                this.value = value;
+            }
+
+            public IDisposable Subscribe(IObserver<T> observer)
+            {
+                observer.OnNext(value);
+                return EmptyDisposable.Instance;
+            }
+        }
+
+        class ThrowObservable<T> : IObservable<T>
+        {
+            readonly Exception value;
+
+            public ThrowObservable(Exception value)
+            {
+                this.value = value;
+            }
+
+            public IDisposable Subscribe(IObserver<T> observer)
+            {
+                observer.OnError(value);
+                return EmptyDisposable.Instance;
+            }
+        }
+    }
+}
+
+namespace UniRx.Async.Internal
+{
+    // Bridges for Rx.
+
+    internal class EmptyDisposable : IDisposable
+    {
+        public static EmptyDisposable Instance = new EmptyDisposable();
+
+        EmptyDisposable()
+        {
+
+        }
+
+        public void Dispose()
+        {
+        }
+    }
+
+    internal sealed class SingleAssignmentDisposable : IDisposable
+    {
+        readonly object gate = new object();
+        IDisposable current;
+        bool disposed;
+
+        public bool IsDisposed { get { lock (gate) { return disposed; } } }
+
+        public IDisposable Disposable
+        {
+            get
+            {
+                return current;
+            }
+            set
+            {
+                var old = default(IDisposable);
+                bool alreadyDisposed;
+                lock (gate)
+                {
+                    alreadyDisposed = disposed;
+                    old = current;
+                    if (!alreadyDisposed)
+                    {
+                        if (value == null) return;
+                        current = value;
+                    }
+                }
+
+                if (alreadyDisposed && value != null)
+                {
+                    value.Dispose();
+                    return;
+                }
+
+                if (old != null) throw new InvalidOperationException("Disposable is already set");
+            }
+        }
+
+
+        public void Dispose()
+        {
+            IDisposable old = null;
+
+            lock (gate)
+            {
+                if (!disposed)
+                {
+                    disposed = true;
+                    old = current;
+                    current = null;
+                }
+            }
+
+            if (old != null) old.Dispose();
+        }
+    }
+
+    internal sealed class AsyncSubject<T> : IObservable<T>, IObserver<T>
+    {
+        object observerLock = new object();
+
+        T lastValue;
+        bool hasValue;
+        bool isStopped;
+        bool isDisposed;
+        Exception lastError;
+        IObserver<T> outObserver = EmptyObserver<T>.Instance;
+
+        public T Value
+        {
+            get
+            {
+                ThrowIfDisposed();
+                if (!isStopped) throw new InvalidOperationException("AsyncSubject is not completed yet");
+                if (lastError != null) ExceptionDispatchInfo.Capture(lastError).Throw();
+                return lastValue;
+            }
+        }
+
+        public bool HasObservers
+        {
+            get
+            {
+                return !(outObserver is EmptyObserver<T>) && !isStopped && !isDisposed;
+            }
+        }
+
+        public bool IsCompleted { get { return isStopped; } }
+
+        public void OnCompleted()
+        {
+            IObserver<T> old;
+            T v;
+            bool hv;
+            lock (observerLock)
+            {
+                ThrowIfDisposed();
+                if (isStopped) return;
+
+                old = outObserver;
+                outObserver = EmptyObserver<T>.Instance;
+                isStopped = true;
+                v = lastValue;
+                hv = hasValue;
+            }
+
+            if (hv)
+            {
+                old.OnNext(v);
+                old.OnCompleted();
+            }
+            else
+            {
+                old.OnCompleted();
+            }
+        }
+
+        public void OnError(Exception error)
+        {
+            if (error == null) throw new ArgumentNullException("error");
+
+            IObserver<T> old;
+            lock (observerLock)
+            {
+                ThrowIfDisposed();
+                if (isStopped) return;
+
+                old = outObserver;
+                outObserver = EmptyObserver<T>.Instance;
+                isStopped = true;
+                lastError = error;
+            }
+
+            old.OnError(error);
+        }
+
+        public void OnNext(T value)
+        {
+            lock (observerLock)
+            {
+                ThrowIfDisposed();
+                if (isStopped) return;
+
+                this.hasValue = true;
+                this.lastValue = value;
+            }
+        }
+
+        public IDisposable Subscribe(IObserver<T> observer)
+        {
+            if (observer == null) throw new ArgumentNullException("observer");
+
+            var ex = default(Exception);
+            var v = default(T);
+            var hv = false;
+
+            lock (observerLock)
+            {
+                ThrowIfDisposed();
+                if (!isStopped)
+                {
+                    var listObserver = outObserver as ListObserver<T>;
+                    if (listObserver != null)
+                    {
+                        outObserver = listObserver.Add(observer);
+                    }
+                    else
+                    {
+                        var current = outObserver;
+                        if (current is EmptyObserver<T>)
+                        {
+                            outObserver = observer;
+                        }
+                        else
+                        {
+                            outObserver = new ListObserver<T>(new ImmutableList<IObserver<T>>(new[] { current, observer }));
+                        }
+                    }
+
+                    return new Subscription(this, observer);
+                }
+
+                ex = lastError;
+                v = lastValue;
+                hv = hasValue;
+            }
+
+            if (ex != null)
+            {
+                observer.OnError(ex);
+            }
+            else if (hv)
+            {
+                observer.OnNext(v);
+                observer.OnCompleted();
+            }
+            else
+            {
+                observer.OnCompleted();
+            }
+
+            return EmptyDisposable.Instance;
+        }
+
+        public void Dispose()
+        {
+            lock (observerLock)
+            {
+                isDisposed = true;
+                outObserver = DisposedObserver<T>.Instance;
+                lastError = null;
+                lastValue = default(T);
+            }
+        }
+
+        void ThrowIfDisposed()
+        {
+            if (isDisposed) throw new ObjectDisposedException("");
+        }
+        
+        class Subscription : IDisposable
+        {
+            readonly object gate = new object();
+            AsyncSubject<T> parent;
+            IObserver<T> unsubscribeTarget;
+
+            public Subscription(AsyncSubject<T> parent, IObserver<T> unsubscribeTarget)
+            {
+                this.parent = parent;
+                this.unsubscribeTarget = unsubscribeTarget;
+            }
+
+            public void Dispose()
+            {
+                lock (gate)
+                {
+                    if (parent != null)
+                    {
+                        lock (parent.observerLock)
+                        {
+                            var listObserver = parent.outObserver as ListObserver<T>;
+                            if (listObserver != null)
+                            {
+                                parent.outObserver = listObserver.Remove(unsubscribeTarget);
+                            }
+                            else
+                            {
+                                parent.outObserver = EmptyObserver<T>.Instance;
+                            }
+
+                            unsubscribeTarget = null;
+                            parent = null;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    internal class ListObserver<T> : IObserver<T>
+    {
+        private readonly ImmutableList<IObserver<T>> _observers;
+
+        public ListObserver(ImmutableList<IObserver<T>> observers)
+        {
+            _observers = observers;
+        }
+
+        public void OnCompleted()
+        {
+            var targetObservers = _observers.Data;
+            for (int i = 0; i < targetObservers.Length; i++)
+            {
+                targetObservers[i].OnCompleted();
+            }
+        }
+
+        public void OnError(Exception error)
+        {
+            var targetObservers = _observers.Data;
+            for (int i = 0; i < targetObservers.Length; i++)
+            {
+                targetObservers[i].OnError(error);
+            }
+        }
+
+        public void OnNext(T value)
+        {
+            var targetObservers = _observers.Data;
+            for (int i = 0; i < targetObservers.Length; i++)
+            {
+                targetObservers[i].OnNext(value);
+            }
+        }
+
+        internal IObserver<T> Add(IObserver<T> observer)
+        {
+            return new ListObserver<T>(_observers.Add(observer));
+        }
+
+        internal IObserver<T> Remove(IObserver<T> observer)
+        {
+            var i = Array.IndexOf(_observers.Data, observer);
+            if (i < 0)
+                return this;
+
+            if (_observers.Data.Length == 2)
+            {
+                return _observers.Data[1 - i];
+            }
+            else
+            {
+                return new ListObserver<T>(_observers.Remove(observer));
+            }
+        }
+    }
+
+    internal class EmptyObserver<T> : IObserver<T>
+    {
+        public static readonly EmptyObserver<T> Instance = new EmptyObserver<T>();
+
+        EmptyObserver()
+        {
+
+        }
+
+        public void OnCompleted()
+        {
+        }
+
+        public void OnError(Exception error)
+        {
+        }
+
+        public void OnNext(T value)
+        {
+        }
+    }
+
+    internal class ThrowObserver<T> : IObserver<T>
+    {
+        public static readonly ThrowObserver<T> Instance = new ThrowObserver<T>();
+
+        ThrowObserver()
+        {
+
+        }
+
+        public void OnCompleted()
+        {
+        }
+
+        public void OnError(Exception error)
+        {
+            ExceptionDispatchInfo.Capture(error).Throw();
+        }
+
+        public void OnNext(T value)
+        {
+        }
+    }
+
+    internal class DisposedObserver<T> : IObserver<T>
+    {
+        public static readonly DisposedObserver<T> Instance = new DisposedObserver<T>();
+
+        DisposedObserver()
+        {
+
+        }
+
+        public void OnCompleted()
+        {
+            throw new ObjectDisposedException("");
+        }
+
+        public void OnError(Exception error)
+        {
+            throw new ObjectDisposedException("");
+        }
+
+        public void OnNext(T value)
+        {
+            throw new ObjectDisposedException("");
+        }
+    }
+
+    internal class ImmutableList<T>
+    {
+        public static readonly ImmutableList<T> Empty = new ImmutableList<T>();
+
+        T[] data;
+
+        public T[] Data
+        {
+            get { return data; }
+        }
+
+        ImmutableList()
+        {
+            data = new T[0];
+        }
+
+        public ImmutableList(T[] data)
+        {
+            this.data = data;
+        }
+
+        public ImmutableList<T> Add(T value)
+        {
+            var newData = new T[data.Length + 1];
+            Array.Copy(data, newData, data.Length);
+            newData[data.Length] = value;
+            return new ImmutableList<T>(newData);
+        }
+
+        public ImmutableList<T> Remove(T value)
+        {
+            var i = IndexOf(value);
+            if (i < 0) return this;
+
+            var length = data.Length;
+            if (length == 1) return Empty;
+
+            var newData = new T[length - 1];
+
+            Array.Copy(data, 0, newData, 0, i);
+            Array.Copy(data, i + 1, newData, i, length - i - 1);
+
+            return new ImmutableList<T>(newData);
+        }
+
+        public int IndexOf(T value)
+        {
+            for (var i = 0; i < data.Length; ++i)
+            {
+                // ImmutableList only use for IObserver(no worry for boxed)
+                if (object.Equals(data[i], value)) return i;
+            }
+            return -1;
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/UniTaskObservableExtensions.cs.meta b/Assets/UniRx.Async/UniTaskObservableExtensions.cs.meta
new file mode 100644
index 0000000..527a49f
--- /dev/null
+++ b/Assets/UniRx.Async/UniTaskObservableExtensions.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: eaea262a5ad393d419c15b3b2901d664
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/UniTaskScheduler.cs b/Assets/UniRx.Async/UniTaskScheduler.cs
new file mode 100644
index 0000000..9270445
--- /dev/null
+++ b/Assets/UniRx.Async/UniTaskScheduler.cs
@@ -0,0 +1,94 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Threading;
+
+namespace UniRx.Async
+{
+    // UniTask has no scheduler like TaskScheduler.
+    // Only handle unobserved exception.
+
+    public static class UniTaskScheduler
+    {
+        public static event Action<Exception> UnobservedTaskException;
+
+        /// <summary>
+        /// Propagate OperationCanceledException to UnobservedTaskException when true. Default is false.
+        /// </summary>
+        public static bool PropagateOperationCanceledException = false;
+
+        /// <summary>
+        /// Write log type when catch unobserved exception and not registered UnobservedTaskException. Default is Warning.
+        /// </summary>
+        public static UnityEngine.LogType UnobservedExceptionWriteLogType = UnityEngine.LogType.Warning;
+
+        /// <summary>
+        /// Dispatch exception event to Unity MainThread.
+        /// </summary>
+        public static bool DispatchUnityMainThread = true;
+
+        // cache delegate.
+        static readonly SendOrPostCallback handleExceptionInvoke = InvokeUnobservedTaskException;
+
+        internal static void PublishUnobservedTaskException(Exception ex)
+        {
+            if (ex != null)
+            {
+                if (!PropagateOperationCanceledException && ex is OperationCanceledException)
+                {
+                    return;
+                }
+
+                if (UnobservedTaskException != null)
+                {
+                    if (Thread.CurrentThread.ManagedThreadId == PlayerLoopHelper.MainThreadId)
+                    {
+                        // allows inlining call.
+                        UnobservedTaskException.Invoke(ex);
+                    }
+                    else
+                    {
+                        // Post to MainThread.
+                        PlayerLoopHelper.UnitySynchronizationContext.Post(handleExceptionInvoke, ex);
+                    }
+                }
+                else
+                {
+                    string msg = null;
+                    if (UnobservedExceptionWriteLogType != UnityEngine.LogType.Exception)
+                    {
+                        msg = "UnobservedTaskException:" + ex.ToString();
+                    }
+                    switch (UnobservedExceptionWriteLogType)
+                    {
+                        case UnityEngine.LogType.Error:
+                            UnityEngine.Debug.LogError(msg);
+                            break;
+                        case UnityEngine.LogType.Assert:
+                            UnityEngine.Debug.LogAssertion(msg);
+                            break;
+                        case UnityEngine.LogType.Warning:
+                            UnityEngine.Debug.LogWarning(msg);
+                            break;
+                        case UnityEngine.LogType.Log:
+                            UnityEngine.Debug.Log(msg);
+                            break;
+                        case UnityEngine.LogType.Exception:
+                            UnityEngine.Debug.LogException(ex);
+                            break;
+                        default:
+                            break;
+                    }
+                }
+            }
+        }
+
+        static void InvokeUnobservedTaskException(object state)
+        {
+            UnobservedTaskException((Exception)state);
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/UniTaskScheduler.cs.meta b/Assets/UniRx.Async/UniTaskScheduler.cs.meta
new file mode 100644
index 0000000..5e29191
--- /dev/null
+++ b/Assets/UniRx.Async/UniTaskScheduler.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d6cad69921702d5488d96b5ef30df1b0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/UniTaskVoid.cs b/Assets/UniRx.Async/UniTaskVoid.cs
new file mode 100644
index 0000000..929ac6f
--- /dev/null
+++ b/Assets/UniRx.Async/UniTaskVoid.cs
@@ -0,0 +1,48 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using UniRx.Async.CompilerServices;
+
+namespace UniRx.Async
+{
+    [AsyncMethodBuilder(typeof(AsyncUniTaskVoidMethodBuilder))]
+    public struct UniTaskVoid
+    {
+        public void Forget()
+        {
+        }
+
+        [DebuggerHidden]
+        public Awaiter GetAwaiter()
+        {
+            return new Awaiter();
+        }
+
+        public struct Awaiter : ICriticalNotifyCompletion
+        {
+            [DebuggerHidden]
+            public bool IsCompleted => true;
+
+            [DebuggerHidden]
+            public void GetResult()
+            {
+                UnityEngine.Debug.LogWarning("UniTaskVoid can't await, always fire-and-forget. use Forget instead of await.");
+            }
+
+            [DebuggerHidden]
+            public void OnCompleted(Action continuation)
+            {
+            }
+
+            [DebuggerHidden]
+            public void UnsafeOnCompleted(Action continuation)
+            {
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/UniTaskVoid.cs.meta b/Assets/UniRx.Async/UniTaskVoid.cs.meta
new file mode 100644
index 0000000..01f7156
--- /dev/null
+++ b/Assets/UniRx.Async/UniTaskVoid.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e9f28cd922179634d863011548f89ae7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/UnityAsyncExtensions.Jobs.cs b/Assets/UniRx.Async/UnityAsyncExtensions.Jobs.cs
new file mode 100644
index 0000000..01185e3
--- /dev/null
+++ b/Assets/UniRx.Async/UnityAsyncExtensions.Jobs.cs
@@ -0,0 +1,140 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6)) && ENABLE_MANAGED_JOBS
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Threading;
+using UniRx.Async.Internal;
+using Unity.Jobs;
+
+namespace UniRx.Async
+{
+    public static partial class UnityAsyncExtensions
+    {
+        public static IAwaiter GetAwaiter(this JobHandle jobHandle)
+        {
+            var awaiter = new JobHandleAwaiter(jobHandle, CancellationToken.None);
+            if (!awaiter.IsCompleted)
+            {
+                PlayerLoopHelper.AddAction(PlayerLoopTiming.EarlyUpdate, awaiter);
+                PlayerLoopHelper.AddAction(PlayerLoopTiming.PreUpdate, awaiter);
+                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, awaiter);
+                PlayerLoopHelper.AddAction(PlayerLoopTiming.PreLateUpdate, awaiter);
+                PlayerLoopHelper.AddAction(PlayerLoopTiming.PostLateUpdate, awaiter);
+            }
+            return awaiter;
+        }
+
+        public static UniTask ToUniTask(this JobHandle jobHandle, CancellationToken cancellation = default(CancellationToken))
+        {
+            var awaiter = new JobHandleAwaiter(jobHandle, cancellation);
+            if (!awaiter.IsCompleted)
+            {
+                PlayerLoopHelper.AddAction(PlayerLoopTiming.EarlyUpdate, awaiter);
+                PlayerLoopHelper.AddAction(PlayerLoopTiming.PreUpdate, awaiter);
+                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, awaiter);
+                PlayerLoopHelper.AddAction(PlayerLoopTiming.PreLateUpdate, awaiter);
+                PlayerLoopHelper.AddAction(PlayerLoopTiming.PostLateUpdate, awaiter);
+            }
+            return new UniTask(awaiter);
+        }
+
+        public static UniTask ConfigureAwait(this JobHandle jobHandle, PlayerLoopTiming waitTiming, CancellationToken cancellation = default(CancellationToken))
+        {
+            var awaiter = new JobHandleAwaiter(jobHandle, cancellation);
+            if (!awaiter.IsCompleted)
+            {
+                PlayerLoopHelper.AddAction(waitTiming, awaiter);
+            }
+            return new UniTask(awaiter);
+        }
+
+        class JobHandleAwaiter : IAwaiter, IPlayerLoopItem
+        {
+            JobHandle jobHandle;
+            CancellationToken cancellationToken;
+            AwaiterStatus status;
+            Action continuation;
+
+            public JobHandleAwaiter(JobHandle jobHandle, CancellationToken cancellationToken, int skipFrame = 2)
+            {
+                this.status = cancellationToken.IsCancellationRequested ? AwaiterStatus.Canceled
+                            : jobHandle.IsCompleted ? AwaiterStatus.Succeeded
+                            : AwaiterStatus.Pending;
+
+                if (this.status.IsCompleted()) return;
+
+                this.jobHandle = jobHandle;
+                this.cancellationToken = cancellationToken;
+                this.status = AwaiterStatus.Pending;
+                this.continuation = null;
+
+                TaskTracker.TrackActiveTask(this, skipFrame);
+            }
+
+            public bool IsCompleted => status.IsCompleted();
+
+            public AwaiterStatus Status => status;
+
+            public void GetResult()
+            {
+                if (status == AwaiterStatus.Succeeded)
+                {
+                    return;
+                }
+                else if (status == AwaiterStatus.Canceled)
+                {
+                    Error.ThrowOperationCanceledException();
+                }
+
+                Error.ThrowNotYetCompleted();
+            }
+
+            public bool MoveNext()
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    // Call jobHandle.Complete after finished.
+                    PlayerLoopHelper.AddAction(PlayerLoopTiming.EarlyUpdate, new JobHandleAwaiter(jobHandle, CancellationToken.None, 1));
+                    InvokeContinuation(AwaiterStatus.Canceled);
+                    return false;
+                }
+
+                if (jobHandle.IsCompleted)
+                {
+                    jobHandle.Complete();
+                    InvokeContinuation(AwaiterStatus.Succeeded);
+                    return false;
+                }
+
+                return true;
+            }
+
+            void InvokeContinuation(AwaiterStatus status)
+            {
+                this.status = status;
+                var cont = this.continuation;
+
+                // cleanup
+                TaskTracker.RemoveTracking(this);
+                this.continuation = null;
+                this.cancellationToken = CancellationToken.None;
+                this.jobHandle = default(JobHandle);
+
+                if (cont != null) cont.Invoke();
+            }
+
+            public void OnCompleted(Action continuation)
+            {
+                UnsafeOnCompleted(continuation);
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                Error.ThrowWhenContinuationIsAlreadyRegistered(this.continuation);
+                this.continuation = continuation;
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/UnityAsyncExtensions.Jobs.cs.meta b/Assets/UniRx.Async/UnityAsyncExtensions.Jobs.cs.meta
new file mode 100644
index 0000000..c07df0b
--- /dev/null
+++ b/Assets/UniRx.Async/UnityAsyncExtensions.Jobs.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 30979a768fbd4b94f8694eee8a305c99
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/UnityAsyncExtensions.cs b/Assets/UniRx.Async/UnityAsyncExtensions.cs
new file mode 100644
index 0000000..0005ca7
--- /dev/null
+++ b/Assets/UniRx.Async/UnityAsyncExtensions.cs
@@ -0,0 +1,702 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Threading;
+using UniRx.Async.Internal;
+using UnityEngine;
+using UnityEngine.Networking;
+
+namespace UniRx.Async
+{
+    public static partial class UnityAsyncExtensions
+    {
+        public static AsyncOperationAwaiter GetAwaiter(this AsyncOperation asyncOperation)
+        {
+            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
+            return new AsyncOperationAwaiter(asyncOperation);
+        }
+
+        public static UniTask ToUniTask(this AsyncOperation asyncOperation)
+        {
+            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
+            return new UniTask(new AsyncOperationAwaiter(asyncOperation));
+        }
+
+        public static UniTask ConfigureAwait(this AsyncOperation asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellation = default(CancellationToken))
+        {
+            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
+
+            var awaiter = new AsyncOperationConfiguredAwaiter(asyncOperation, progress, cancellation);
+            if (!awaiter.IsCompleted)
+            {
+                PlayerLoopHelper.AddAction(timing, awaiter);
+            }
+            return new UniTask(awaiter);
+        }
+
+        public static ResourceRequestAwaiter GetAwaiter(this ResourceRequest resourceRequest)
+        {
+            Error.ThrowArgumentNullException(resourceRequest, nameof(resourceRequest));
+            return new ResourceRequestAwaiter(resourceRequest);
+        }
+
+        public static UniTask<UnityEngine.Object> ToUniTask(this ResourceRequest resourceRequest)
+        {
+            Error.ThrowArgumentNullException(resourceRequest, nameof(resourceRequest));
+            return new UniTask<UnityEngine.Object>(new ResourceRequestAwaiter(resourceRequest));
+        }
+
+        public static UniTask<UnityEngine.Object> ConfigureAwait(this ResourceRequest resourceRequest, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellation = default(CancellationToken))
+        {
+            Error.ThrowArgumentNullException(resourceRequest, nameof(resourceRequest));
+
+            var awaiter = new ResourceRequestConfiguredAwaiter(resourceRequest, progress, cancellation);
+            if (!awaiter.IsCompleted)
+            {
+                PlayerLoopHelper.AddAction(timing, awaiter);
+            }
+            return new UniTask<UnityEngine.Object>(awaiter);
+        }
+
+#if ENABLE_WWW
+
+#if UNITY_2018_3_OR_NEWER
+#pragma warning disable CS0618
+#endif
+
+        public static IAwaiter GetAwaiter(this WWW www)
+        {
+            Error.ThrowArgumentNullException(www, nameof(www));
+
+            var awaiter = new WWWConfiguredAwaiter(www, null, CancellationToken.None);
+            if (!awaiter.IsCompleted)
+            {
+                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, awaiter);
+            }
+            return awaiter;
+        }
+
+        public static UniTask ToUniTask(this WWW www)
+        {
+            Error.ThrowArgumentNullException(www, nameof(www));
+
+            var awaiter = new WWWConfiguredAwaiter(www, null, CancellationToken.None);
+            if (!awaiter.IsCompleted)
+            {
+                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, awaiter);
+            }
+            return new UniTask(awaiter);
+        }
+
+        public static UniTask ConfigureAwait(this WWW www, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellation = default(CancellationToken))
+        {
+            Error.ThrowArgumentNullException(www, nameof(www));
+
+            var awaiter = new WWWConfiguredAwaiter(www, progress, cancellation);
+            if (!awaiter.IsCompleted)
+            {
+                PlayerLoopHelper.AddAction(timing, awaiter);
+            }
+            return new UniTask(awaiter);
+        }
+
+#if UNITY_2018_3_OR_NEWER
+#pragma warning restore CS0618
+#endif
+
+#endif
+
+#if ENABLE_UNITYWEBREQUEST
+
+        public static UnityWebRequestAsyncOperationAwaiter GetAwaiter(this UnityWebRequestAsyncOperation asyncOperation)
+        {
+            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
+            return new UnityWebRequestAsyncOperationAwaiter(asyncOperation);
+        }
+
+        public static UniTask<UnityWebRequest> ToUniTask(this UnityWebRequestAsyncOperation asyncOperation)
+        {
+            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
+            return new UniTask<UnityWebRequest>(new UnityWebRequestAsyncOperationAwaiter(asyncOperation));
+        }
+
+        public static UniTask<UnityWebRequest> ConfigureAwait(this UnityWebRequestAsyncOperation asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellation = default(CancellationToken))
+        {
+            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
+
+            var awaiter = new UnityWebRequestAsyncOperationConfiguredAwaiter(asyncOperation, progress, cancellation);
+            if (!awaiter.IsCompleted)
+            {
+                PlayerLoopHelper.AddAction(timing, awaiter);
+            }
+            return new UniTask<UnityWebRequest>(awaiter);
+        }
+
+#endif
+
+        public struct AsyncOperationAwaiter : IAwaiter
+        {
+            AsyncOperation asyncOperation;
+            Action<AsyncOperation> continuationAction;
+            AwaiterStatus status;
+
+            public AsyncOperationAwaiter(AsyncOperation asyncOperation)
+            {
+                this.status = asyncOperation.isDone ? AwaiterStatus.Succeeded : AwaiterStatus.Pending;
+                this.asyncOperation = (this.status.IsCompleted()) ? null : asyncOperation;
+                this.continuationAction = null;
+            }
+
+            public bool IsCompleted => status.IsCompleted();
+            public AwaiterStatus Status => status;
+
+            public void GetResult()
+            {
+                if (status == AwaiterStatus.Succeeded) return;
+
+                if (status == AwaiterStatus.Pending)
+                {
+                    // first timing of call
+                    if (asyncOperation.isDone)
+                    {
+                        status = AwaiterStatus.Succeeded;
+                    }
+                    else
+                    {
+                        Error.ThrowNotYetCompleted();
+                    }
+                }
+
+                asyncOperation = null; // remove reference.
+
+                if (continuationAction != null)
+                {
+                    asyncOperation.completed -= continuationAction;
+                    continuationAction = null;
+                }
+            }
+
+            public void OnCompleted(Action continuation)
+            {
+                UnsafeOnCompleted(continuation);
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction);
+                continuationAction = continuation.AsFuncOfT<AsyncOperation>();
+                asyncOperation.completed += continuationAction;
+            }
+        }
+
+        class AsyncOperationConfiguredAwaiter : IAwaiter, IPlayerLoopItem
+        {
+            AsyncOperation asyncOperation;
+            IProgress<float> progress;
+            CancellationToken cancellationToken;
+            AwaiterStatus status;
+            Action continuation;
+
+            public AsyncOperationConfiguredAwaiter(AsyncOperation asyncOperation, IProgress<float> progress, CancellationToken cancellationToken)
+            {
+                this.status = cancellationToken.IsCancellationRequested ? AwaiterStatus.Canceled
+                            : asyncOperation.isDone ? AwaiterStatus.Succeeded
+                            : AwaiterStatus.Pending;
+
+                if (this.status.IsCompleted()) return;
+
+                this.asyncOperation = asyncOperation;
+                this.progress = progress;
+                this.cancellationToken = cancellationToken;
+                this.continuation = null;
+
+                TaskTracker.TrackActiveTask(this, 2);
+            }
+
+            public bool IsCompleted => status.IsCompleted();
+            public AwaiterStatus Status => status;
+
+            public void GetResult()
+            {
+                if (status == AwaiterStatus.Succeeded)
+                {
+                    return;
+                }
+                else if (status == AwaiterStatus.Canceled)
+                {
+                    Error.ThrowOperationCanceledException();
+                }
+
+                Error.ThrowNotYetCompleted();
+            }
+
+            public bool MoveNext()
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    InvokeContinuation(AwaiterStatus.Canceled);
+                    return false;
+                }
+
+                if (progress != null)
+                {
+                    progress.Report(asyncOperation.progress);
+                }
+
+                if (asyncOperation.isDone)
+                {
+                    InvokeContinuation(AwaiterStatus.Succeeded);
+                    return false;
+                }
+
+                return true;
+            }
+
+            void InvokeContinuation(AwaiterStatus status)
+            {
+                this.status = status;
+                var cont = this.continuation;
+
+                // cleanup
+                TaskTracker.RemoveTracking(this);
+                this.continuation = null;
+                this.cancellationToken = CancellationToken.None;
+                this.progress = null;
+                this.asyncOperation = null;
+
+                if (cont != null) cont.Invoke();
+            }
+
+            public void OnCompleted(Action continuation)
+            {
+                UnsafeOnCompleted(continuation);
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                Error.ThrowWhenContinuationIsAlreadyRegistered(this.continuation);
+                this.continuation = continuation;
+            }
+        }
+
+        public struct ResourceRequestAwaiter : IAwaiter<UnityEngine.Object>
+        {
+            ResourceRequest asyncOperation;
+            Action<AsyncOperation> continuationAction;
+            AwaiterStatus status;
+            UnityEngine.Object result;
+
+            public ResourceRequestAwaiter(ResourceRequest asyncOperation)
+            {
+                this.status = asyncOperation.isDone ? AwaiterStatus.Succeeded : AwaiterStatus.Pending;
+                this.asyncOperation = (this.status.IsCompleted()) ? null : asyncOperation;
+                this.result = (this.status.IsCompletedSuccessfully()) ? asyncOperation.asset : null;
+                this.continuationAction = null;
+            }
+
+            public bool IsCompleted => status.IsCompleted();
+            public AwaiterStatus Status => status;
+
+            public UnityEngine.Object GetResult()
+            {
+                if (status == AwaiterStatus.Succeeded) return this.result;
+
+                if (status == AwaiterStatus.Pending)
+                {
+                    // first timing of call
+                    if (asyncOperation.isDone)
+                    {
+                        status = AwaiterStatus.Succeeded;
+                    }
+                    else
+                    {
+                        Error.ThrowNotYetCompleted();
+                    }
+                }
+
+                this.result = asyncOperation.asset;
+                asyncOperation = null; // remove reference.
+
+                if (continuationAction != null)
+                {
+                    asyncOperation.completed -= continuationAction;
+                    continuationAction = null;
+                }
+
+                return this.result;
+            }
+
+            void IAwaiter.GetResult() => GetResult();
+
+            public void OnCompleted(Action continuation)
+            {
+                UnsafeOnCompleted(continuation);
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction);
+                continuationAction = continuation.AsFuncOfT<AsyncOperation>();
+                asyncOperation.completed += continuationAction;
+            }
+        }
+
+        class ResourceRequestConfiguredAwaiter : IAwaiter<UnityEngine.Object>, IPlayerLoopItem
+        {
+            ResourceRequest asyncOperation;
+            IProgress<float> progress;
+            CancellationToken cancellationToken;
+            AwaiterStatus status;
+            Action continuation;
+            UnityEngine.Object result;
+
+            public ResourceRequestConfiguredAwaiter(ResourceRequest asyncOperation, IProgress<float> progress, CancellationToken cancellationToken)
+            {
+                this.status = cancellationToken.IsCancellationRequested ? AwaiterStatus.Canceled
+                            : asyncOperation.isDone ? AwaiterStatus.Succeeded
+                            : AwaiterStatus.Pending;
+
+                if (this.status.IsCompletedSuccessfully()) this.result = asyncOperation.asset;
+                if (this.status.IsCompleted()) return;
+
+                this.asyncOperation = asyncOperation;
+                this.progress = progress;
+                this.cancellationToken = cancellationToken;
+                this.continuation = null;
+                this.result = null;
+
+                TaskTracker.TrackActiveTask(this, 2);
+            }
+
+            public bool IsCompleted => status.IsCompleted();
+            public AwaiterStatus Status => status;
+            void IAwaiter.GetResult() => GetResult();
+
+            public UnityEngine.Object GetResult()
+            {
+                if (status == AwaiterStatus.Succeeded) return this.result;
+
+                if (status == AwaiterStatus.Canceled)
+                {
+                    Error.ThrowOperationCanceledException();
+                }
+
+                return Error.ThrowNotYetCompleted<UnityEngine.Object>();
+            }
+
+            public bool MoveNext()
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    InvokeContinuation(AwaiterStatus.Canceled);
+                    return false;
+                }
+
+                if (progress != null)
+                {
+                    progress.Report(asyncOperation.progress);
+                }
+
+                if (asyncOperation.isDone)
+                {
+                    this.result = asyncOperation.asset;
+                    InvokeContinuation(AwaiterStatus.Succeeded);
+                    return false;
+                }
+
+                return true;
+            }
+
+            void InvokeContinuation(AwaiterStatus status)
+            {
+                this.status = status;
+                var cont = this.continuation;
+
+                // cleanup
+                TaskTracker.RemoveTracking(this);
+                this.continuation = null;
+                this.cancellationToken = CancellationToken.None;
+                this.progress = null;
+                this.asyncOperation = null;
+
+                if (cont != null) cont.Invoke();
+            }
+
+            public void OnCompleted(Action continuation)
+            {
+                Error.ThrowWhenContinuationIsAlreadyRegistered(this.continuation);
+                this.continuation = continuation;
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                Error.ThrowWhenContinuationIsAlreadyRegistered(this.continuation);
+                this.continuation = continuation;
+            }
+        }
+
+#if ENABLE_WWW
+
+#if UNITY_2018_3_OR_NEWER
+#pragma warning disable CS0618
+#endif
+
+        class WWWConfiguredAwaiter : IAwaiter, IPlayerLoopItem
+        {
+            WWW asyncOperation;
+            IProgress<float> progress;
+            CancellationToken cancellationToken;
+            AwaiterStatus status;
+            Action continuation;
+
+            public WWWConfiguredAwaiter(WWW asyncOperation, IProgress<float> progress, CancellationToken cancellationToken)
+            {
+                this.status = cancellationToken.IsCancellationRequested ? AwaiterStatus.Canceled
+                            : asyncOperation.isDone ? AwaiterStatus.Succeeded
+                            : AwaiterStatus.Pending;
+
+                if (this.status.IsCompleted()) return;
+
+                this.asyncOperation = asyncOperation;
+                this.progress = progress;
+                this.cancellationToken = cancellationToken;
+                this.continuation = null;
+
+                TaskTracker.TrackActiveTask(this, 2);
+            }
+
+            public bool IsCompleted => status.IsCompleted();
+            public AwaiterStatus Status => status;
+
+            public void GetResult()
+            {
+                if (status == AwaiterStatus.Succeeded)
+                {
+                    return;
+                }
+                else if (status == AwaiterStatus.Canceled)
+                {
+                    Error.ThrowOperationCanceledException();
+                }
+
+                Error.ThrowNotYetCompleted();
+            }
+
+            public bool MoveNext()
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    InvokeContinuation(AwaiterStatus.Canceled);
+                    return false;
+                }
+
+                if (progress != null)
+                {
+                    progress.Report(asyncOperation.progress);
+                }
+
+                if (asyncOperation.isDone)
+                {
+                    InvokeContinuation(AwaiterStatus.Succeeded);
+                    return false;
+                }
+
+                return true;
+            }
+
+            void InvokeContinuation(AwaiterStatus status)
+            {
+                this.status = status;
+                var cont = this.continuation;
+
+                // cleanup
+                TaskTracker.RemoveTracking(this);
+                this.continuation = null;
+                this.cancellationToken = CancellationToken.None;
+                this.progress = null;
+                this.asyncOperation = null;
+
+                if (cont != null) cont.Invoke();
+            }
+
+            public void OnCompleted(Action continuation)
+            {
+                UnsafeOnCompleted(continuation);
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                Error.ThrowWhenContinuationIsAlreadyRegistered(this.continuation);
+                this.continuation = continuation;
+            }
+        }
+
+#if UNITY_2018_3_OR_NEWER
+#pragma warning restore CS0618
+#endif
+
+#endif
+
+#if ENABLE_UNITYWEBREQUEST
+
+        public struct UnityWebRequestAsyncOperationAwaiter : IAwaiter<UnityWebRequest>
+        {
+            UnityWebRequestAsyncOperation asyncOperation;
+            Action<AsyncOperation> continuationAction;
+            AwaiterStatus status;
+            UnityWebRequest result;
+
+            public UnityWebRequestAsyncOperationAwaiter(UnityWebRequestAsyncOperation asyncOperation)
+            {
+                this.status = asyncOperation.isDone ? AwaiterStatus.Succeeded : AwaiterStatus.Pending;
+                this.asyncOperation = (this.status.IsCompleted()) ? null : asyncOperation;
+                this.result = (this.status.IsCompletedSuccessfully()) ? asyncOperation.webRequest : null;
+                this.continuationAction = null;
+            }
+
+            public bool IsCompleted => status.IsCompleted();
+            public AwaiterStatus Status => status;
+
+            public UnityWebRequest GetResult()
+            {
+                if (status == AwaiterStatus.Succeeded) return this.result;
+
+                if (status == AwaiterStatus.Pending)
+                {
+                    // first timing of call
+                    if (asyncOperation.isDone)
+                    {
+                        status = AwaiterStatus.Succeeded;
+                    }
+                    else
+                    {
+                        Error.ThrowNotYetCompleted();
+                    }
+                }
+
+                this.result = asyncOperation.webRequest;
+                asyncOperation = null; // remove reference.
+
+                if (continuationAction != null)
+                {
+                    asyncOperation.completed -= continuationAction;
+                    continuationAction = null;
+                }
+
+                return this.result;
+            }
+
+            void IAwaiter.GetResult() => GetResult();
+
+            public void OnCompleted(Action continuation)
+            {
+                UnsafeOnCompleted(continuation);
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction);
+                continuationAction = continuation.AsFuncOfT<AsyncOperation>();
+                asyncOperation.completed += continuationAction;
+            }
+        }
+
+        class UnityWebRequestAsyncOperationConfiguredAwaiter : IAwaiter<UnityWebRequest>, IPlayerLoopItem
+        {
+            UnityWebRequestAsyncOperation asyncOperation;
+            IProgress<float> progress;
+            CancellationToken cancellationToken;
+            AwaiterStatus status;
+            Action continuation;
+            UnityWebRequest result;
+
+            public UnityWebRequestAsyncOperationConfiguredAwaiter(UnityWebRequestAsyncOperation asyncOperation, IProgress<float> progress, CancellationToken cancellationToken)
+            {
+                this.status = cancellationToken.IsCancellationRequested ? AwaiterStatus.Canceled
+                            : asyncOperation.isDone ? AwaiterStatus.Succeeded
+                            : AwaiterStatus.Pending;
+
+                if (this.status.IsCompletedSuccessfully()) this.result = asyncOperation.webRequest;
+                if (this.status.IsCompleted()) return;
+
+                this.asyncOperation = asyncOperation;
+                this.progress = progress;
+                this.cancellationToken = cancellationToken;
+                this.continuation = null;
+                this.result = null;
+
+                TaskTracker.TrackActiveTask(this, 2);
+            }
+
+            public bool IsCompleted => status.IsCompleted();
+            public AwaiterStatus Status => status;
+            void IAwaiter.GetResult() => GetResult();
+
+            public UnityWebRequest GetResult()
+            {
+                if (status == AwaiterStatus.Succeeded) return this.result;
+
+                if (status == AwaiterStatus.Canceled)
+                {
+                    Error.ThrowOperationCanceledException();
+                }
+
+                return Error.ThrowNotYetCompleted<UnityWebRequest>();
+            }
+
+            public bool MoveNext()
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    InvokeContinuation(AwaiterStatus.Canceled);
+                    return false;
+                }
+
+                if (progress != null)
+                {
+                    progress.Report(asyncOperation.progress);
+                }
+
+                if (asyncOperation.isDone)
+                {
+                    this.result = asyncOperation.webRequest;
+                    InvokeContinuation(AwaiterStatus.Succeeded);
+                    return false;
+                }
+
+                return true;
+            }
+
+            void InvokeContinuation(AwaiterStatus status)
+            {
+                this.status = status;
+                var cont = this.continuation;
+
+                // cleanup
+                TaskTracker.RemoveTracking(this);
+                this.continuation = null;
+                this.cancellationToken = CancellationToken.None;
+                this.progress = null;
+                this.asyncOperation = null;
+
+                if (cont != null) cont.Invoke();
+            }
+
+            public void OnCompleted(Action continuation)
+            {
+                Error.ThrowWhenContinuationIsAlreadyRegistered(this.continuation);
+                this.continuation = continuation;
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                Error.ThrowWhenContinuationIsAlreadyRegistered(this.continuation);
+                this.continuation = continuation;
+            }
+        }
+
+#endif
+    }
+}
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/UnityAsyncExtensions.cs.meta b/Assets/UniRx.Async/UnityAsyncExtensions.cs.meta
new file mode 100644
index 0000000..6dfab81
--- /dev/null
+++ b/Assets/UniRx.Async/UnityAsyncExtensions.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8cc7fd65dd1433e419be4764aeb51391
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/UniRx.Async/UnityAsyncExtensions.uGUI.cs b/Assets/UniRx.Async/UnityAsyncExtensions.uGUI.cs
new file mode 100644
index 0000000..b0effcb
--- /dev/null
+++ b/Assets/UniRx.Async/UnityAsyncExtensions.uGUI.cs
@@ -0,0 +1,434 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using UniRx.Async.Internal;
+using UnityEngine;
+using UnityEngine.Events;
+using UnityEngine.UI;
+using UniRx.Async.Triggers;
+
+namespace UniRx.Async
+{
+    public static partial class UnityAsyncExtensions
+    {
+        public static AsyncUnityEventHandler GetAsyncEventHandler(this UnityEvent unityEvent, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler(unityEvent, cancellationToken, false);
+        }
+
+        public static UniTask OnInvokeAsync(this UnityEvent unityEvent, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler(unityEvent, cancellationToken, true).OnInvokeAsync();
+        }
+
+        public static IAsyncClickEventHandler GetAsyncClickEventHandler(this Button button)
+        {
+            return new AsyncUnityEventHandler(button.onClick, button.GetCancellationTokenOnDestroy(), false);
+        }
+
+        public static IAsyncClickEventHandler GetAsyncClickEventHandler(this Button button, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler(button.onClick, cancellationToken, false);
+        }
+
+        public static UniTask OnClickAsync(this Button button)
+        {
+            return new AsyncUnityEventHandler(button.onClick, button.GetCancellationTokenOnDestroy(), true).OnInvokeAsync();
+        }
+
+        public static UniTask OnClickAsync(this Button button, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler(button.onClick, cancellationToken, true).OnInvokeAsync();
+        }
+
+        public static IAsyncValueChangedEventHandler<bool> GetAsyncValueChangedEventHandler(this Toggle toggle)
+        {
+            return new AsyncUnityEventHandler<bool>(toggle.onValueChanged, toggle.GetCancellationTokenOnDestroy(), false);
+        }
+
+        public static IAsyncValueChangedEventHandler<bool> GetAsyncValueChangedEventHandler(this Toggle toggle, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<bool>(toggle.onValueChanged, cancellationToken, false);
+        }
+
+        public static UniTask<bool> OnValueChangedAsync(this Toggle toggle)
+        {
+            return new AsyncUnityEventHandler<bool>(toggle.onValueChanged, toggle.GetCancellationTokenOnDestroy(), true).OnInvokeAsync();
+        }
+
+        public static UniTask<bool> OnValueChangedAsync(this Toggle toggle, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<bool>(toggle.onValueChanged, cancellationToken, true).OnInvokeAsync();
+        }
+
+        public static IAsyncValueChangedEventHandler<float> GetAsyncValueChangedEventHandler(this Scrollbar scrollbar)
+        {
+            return new AsyncUnityEventHandler<float>(scrollbar.onValueChanged, scrollbar.GetCancellationTokenOnDestroy(), false);
+        }
+
+        public static IAsyncValueChangedEventHandler<float> GetAsyncValueChangedEventHandler(this Scrollbar scrollbar, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<float>(scrollbar.onValueChanged, cancellationToken, false);
+        }
+
+        public static UniTask<float> OnValueChangedAsync(this Scrollbar scrollbar)
+        {
+            return new AsyncUnityEventHandler<float>(scrollbar.onValueChanged, scrollbar.GetCancellationTokenOnDestroy(), true).OnInvokeAsync();
+        }
+
+        public static UniTask<float> OnValueChangedAsync(this Scrollbar scrollbar, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<float>(scrollbar.onValueChanged, cancellationToken, true).OnInvokeAsync();
+        }
+
+        public static IAsyncValueChangedEventHandler<Vector2> GetAsyncValueChangedEventHandler(this ScrollRect scrollRect)
+        {
+            return new AsyncUnityEventHandler<Vector2>(scrollRect.onValueChanged, scrollRect.GetCancellationTokenOnDestroy(), false);
+        }
+
+        public static IAsyncValueChangedEventHandler<Vector2> GetAsyncValueChangedEventHandler(this ScrollRect scrollRect, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<Vector2>(scrollRect.onValueChanged, cancellationToken, false);
+        }
+
+        public static UniTask<Vector2> OnValueChangedAsync(this ScrollRect scrollRect)
+        {
+            return new AsyncUnityEventHandler<Vector2>(scrollRect.onValueChanged, scrollRect.GetCancellationTokenOnDestroy(), true).OnInvokeAsync();
+        }
+
+        public static UniTask<Vector2> OnValueChangedAsync(this ScrollRect scrollRect, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<Vector2>(scrollRect.onValueChanged, cancellationToken, true).OnInvokeAsync();
+        }
+
+        public static IAsyncValueChangedEventHandler<float> GetAsyncValueChangedEventHandler(this Slider slider)
+        {
+            return new AsyncUnityEventHandler<float>(slider.onValueChanged, slider.GetCancellationTokenOnDestroy(), false);
+        }
+
+        public static IAsyncValueChangedEventHandler<float> GetAsyncValueChangedEventHandler(this Slider slider, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<float>(slider.onValueChanged, cancellationToken, false);
+        }
+
+        public static UniTask<float> OnValueChangedAsync(this Slider slider)
+        {
+            return new AsyncUnityEventHandler<float>(slider.onValueChanged, slider.GetCancellationTokenOnDestroy(), true).OnInvokeAsync();
+        }
+
+        public static UniTask<float> OnValueChangedAsync(this Slider slider, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<float>(slider.onValueChanged, cancellationToken, true).OnInvokeAsync();
+        }
+
+        public static IAsyncEndEditEventHandler<string> GetAsyncEndEditEventHandler(this InputField inputField)
+        {
+            return new AsyncUnityEventHandler<string>(inputField.onEndEdit, inputField.GetCancellationTokenOnDestroy(), false);
+        }
+
+        public static IAsyncEndEditEventHandler<string> GetAsyncEndEditEventHandler(this InputField inputField, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<string>(inputField.onEndEdit, cancellationToken, false);
+        }
+
+        public static UniTask<string> OnEndEditAsync(this InputField inputField)
+        {
+            return new AsyncUnityEventHandler<string>(inputField.onEndEdit, inputField.GetCancellationTokenOnDestroy(), true).OnInvokeAsync();
+        }
+
+        public static UniTask<string> OnEndEditAsync(this InputField inputField, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<string>(inputField.onEndEdit, cancellationToken, true).OnInvokeAsync();
+        }
+
+        public static IAsyncValueChangedEventHandler<int> GetAsyncValueChangedEventHandler(this Dropdown dropdown)
+        {
+            return new AsyncUnityEventHandler<int>(dropdown.onValueChanged, dropdown.GetCancellationTokenOnDestroy(), false);
+        }
+
+        public static IAsyncValueChangedEventHandler<int> GetAsyncValueChangedEventHandler(this Dropdown dropdown, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<int>(dropdown.onValueChanged, cancellationToken, false);
+        }
+
+        public static UniTask<int> OnValueChanged(this Dropdown dropdown)
+        {
+            return new AsyncUnityEventHandler<int>(dropdown.onValueChanged, dropdown.GetCancellationTokenOnDestroy(), true).OnInvokeAsync();
+        }
+
+        public static UniTask<int> OnValueChanged(this Dropdown dropdown, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<int>(dropdown.onValueChanged, cancellationToken, true).OnInvokeAsync();
+        }
+    }
+
+    public interface IAsyncClickEventHandler : IDisposable
+    {
+        UniTask OnClickAsync();
+        UniTask<bool> OnClickAsyncSuppressCancellationThrow();
+    }
+
+    public interface IAsyncValueChangedEventHandler<T> : IDisposable
+    {
+        UniTask<T> OnValueChangedAsync();
+        UniTask<(bool IsCanceled, T Result)> OnValueChangedAsyncSuppressCancellationThrow();
+    }
+
+    public interface IAsyncEndEditEventHandler<T> : IDisposable
+    {
+        UniTask<T> OnEndEditAsync();
+        UniTask<(bool IsCanceled, T Result)> OnEndEditAsyncSuppressCancellationThrow();
+    }
+
+    // event handler is reusable when callOnce = false.
+    public class AsyncUnityEventHandler : IAwaiter, IDisposable, IAsyncClickEventHandler
+    {
+        static Action<object> cancellationCallback = CancellationCallback;
+
+        readonly UnityAction action;
+        readonly UnityEvent unityEvent;
+        Action continuation;
+        CancellationTokenRegistration registration;
+        bool isDisposed;
+        bool callOnce;
+        UniTask<bool>? suppressCancellationThrowTask;
+
+        public AsyncUnityEventHandler(UnityEvent unityEvent, CancellationToken cancellationToken, bool callOnce)
+        {
+            this.callOnce = callOnce;
+
+            if (cancellationToken.IsCancellationRequested)
+            {
+                isDisposed = true;
+                return;
+            }
+
+            action = Invoke;
+            unityEvent.AddListener(action);
+            this.unityEvent = unityEvent;
+
+            if (cancellationToken.CanBeCanceled)
+            {
+                registration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, this);
+            }
+
+            TaskTracker.TrackActiveTask(this, 3);
+        }
+
+        public UniTask OnInvokeAsync()
+        {
+            // zero allocation wait handler.
+            return new UniTask(this);
+        }
+
+        public UniTask<bool> OnInvokeAsyncSuppressCancellationThrow()
+        {
+            if (suppressCancellationThrowTask == null)
+            {
+                suppressCancellationThrowTask = OnInvokeAsync().SuppressCancellationThrow();
+            }
+            return suppressCancellationThrowTask.Value;
+        }
+
+        void Invoke()
+        {
+            var c = continuation;
+            continuation = null;
+            if (c != null)
+            {
+                c.Invoke();
+            }
+        }
+
+        static void CancellationCallback(object state)
+        {
+            var self = (AsyncUnityEventHandler)state;
+            self.Dispose();
+            self.Invoke(); // call continuation if exists yet(GetResult -> throw OperationCanceledException).
+        }
+
+        public void Dispose()
+        {
+            if (!isDisposed)
+            {
+                isDisposed = true;
+                TaskTracker.RemoveTracking(this);
+                registration.Dispose();
+                if (unityEvent != null)
+                {
+                    unityEvent.RemoveListener(action);
+                }
+            }
+        }
+
+        bool IAwaiter.IsCompleted => isDisposed ? true : false;
+        AwaiterStatus IAwaiter.Status => isDisposed ? AwaiterStatus.Canceled : AwaiterStatus.Pending;
+        void IAwaiter.GetResult()
+        {
+            if (isDisposed) throw new OperationCanceledException();
+            if (callOnce) Dispose();
+        }
+
+        void INotifyCompletion.OnCompleted(Action action)
+        {
+            ((ICriticalNotifyCompletion)this).UnsafeOnCompleted(action);
+        }
+
+        void ICriticalNotifyCompletion.UnsafeOnCompleted(Action action)
+        {
+            Error.ThrowWhenContinuationIsAlreadyRegistered(this.continuation);
+            this.continuation = action;
+        }
+
+        // Interface events.
+
+        UniTask IAsyncClickEventHandler.OnClickAsync()
+        {
+            return OnInvokeAsync();
+        }
+
+        UniTask<bool> IAsyncClickEventHandler.OnClickAsyncSuppressCancellationThrow()
+        {
+            return OnInvokeAsyncSuppressCancellationThrow();
+        }
+    }
+
+    // event handler is reusable when callOnce = false.
+    public class AsyncUnityEventHandler<T> : IAwaiter<T>, IDisposable, IAsyncValueChangedEventHandler<T>, IAsyncEndEditEventHandler<T>
+    {
+        static Action<object> cancellationCallback = CancellationCallback;
+
+        readonly UnityAction<T> action;
+        readonly UnityEvent<T> unityEvent;
+        Action continuation;
+        CancellationTokenRegistration registration;
+        bool isDisposed;
+        T eventValue;
+        bool callOnce;
+        UniTask<(bool, T)>? suppressCancellationThrowTask;
+
+        public AsyncUnityEventHandler(UnityEvent<T> unityEvent, CancellationToken cancellationToken, bool callOnce)
+        {
+            this.callOnce = callOnce;
+
+            if (cancellationToken.IsCancellationRequested)
+            {
+                isDisposed = true;
+                return;
+            }
+
+            action = Invoke;
+            unityEvent.AddListener(action);
+            this.unityEvent = unityEvent;
+
+            if (cancellationToken.CanBeCanceled)
+            {
+                registration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, this);
+            }
+
+            TaskTracker.TrackActiveTask(this, 3);
+        }
+
+        public UniTask<T> OnInvokeAsync()
+        {
+            // zero allocation wait handler.
+            return new UniTask<T>(this);
+        }
+
+        public UniTask<(bool IsCanceled, T Result)> OnInvokeAsyncSuppressCancellationThrow()
+        {
+            if (suppressCancellationThrowTask == null)
+            {
+                suppressCancellationThrowTask = OnInvokeAsync().SuppressCancellationThrow();
+            }
+            return suppressCancellationThrowTask.Value;
+        }
+
+        void Invoke(T value)
+        {
+            this.eventValue = value;
+
+            var c = continuation;
+            continuation = null;
+            if (c != null)
+            {
+                c.Invoke();
+            }
+        }
+
+        static void CancellationCallback(object state)
+        {
+            var self = (AsyncUnityEventHandler<T>)state;
+            self.Dispose();
+            self.Invoke(default(T)); // call continuation if exists yet(GetResult -> throw OperationCanceledException).
+        }
+
+        public void Dispose()
+        {
+            if (!isDisposed)
+            {
+                isDisposed = true;
+                TaskTracker.RemoveTracking(this);
+                registration.Dispose();
+                if (unityEvent != null)
+                {
+                    unityEvent.RemoveListener(action);
+                }
+            }
+        }
+
+        bool IAwaiter.IsCompleted => isDisposed ? true : false;
+        AwaiterStatus IAwaiter.Status => isDisposed ? AwaiterStatus.Canceled : AwaiterStatus.Pending;
+
+        T IAwaiter<T>.GetResult()
+        {
+            if (isDisposed) throw new OperationCanceledException();
+            if (callOnce) Dispose();
+            return eventValue;
+        }
+
+        void IAwaiter.GetResult()
+        {
+            if (isDisposed) throw new OperationCanceledException();
+            if (callOnce) Dispose();
+        }
+
+        void INotifyCompletion.OnCompleted(Action action)
+        {
+            ((ICriticalNotifyCompletion)this).UnsafeOnCompleted(action);
+        }
+
+        void ICriticalNotifyCompletion.UnsafeOnCompleted(Action action)
+        {
+            Error.ThrowWhenContinuationIsAlreadyRegistered(this.continuation);
+            this.continuation = action;
+        }
+
+        // Interface events.
+
+        UniTask<T> IAsyncValueChangedEventHandler<T>.OnValueChangedAsync()
+        {
+            return OnInvokeAsync();
+        }
+
+        UniTask<(bool IsCanceled, T Result)> IAsyncValueChangedEventHandler<T>.OnValueChangedAsyncSuppressCancellationThrow()
+        {
+            return OnInvokeAsyncSuppressCancellationThrow();
+        }
+
+        UniTask<T> IAsyncEndEditEventHandler<T>.OnEndEditAsync()
+        {
+            return OnInvokeAsync();
+        }
+
+        UniTask<(bool IsCanceled, T Result)> IAsyncEndEditEventHandler<T>.OnEndEditAsyncSuppressCancellationThrow()
+        {
+            return OnInvokeAsyncSuppressCancellationThrow();
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Assets/UniRx.Async/UnityAsyncExtensions.uGUI.cs.meta b/Assets/UniRx.Async/UnityAsyncExtensions.uGUI.cs.meta
new file mode 100644
index 0000000..90c5d51
--- /dev/null
+++ b/Assets/UniRx.Async/UnityAsyncExtensions.uGUI.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6804799fba2376d4099561d176101aff
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/LICENSE.md b/LICENSE
similarity index 95%
rename from LICENSE.md
rename to LICENSE
index 22a9dec..e44b59b 100644
--- a/LICENSE.md
+++ b/LICENSE
@@ -1,7 +1,6 @@
-
 The MIT License (MIT)
 
-Copyright (c) 2019 Yoshifumi Kawai
+Copyright (c) 2019 Yoshifumi Kawai / Cysharp, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/ProjectSettings/AudioManager.asset b/ProjectSettings/AudioManager.asset
new file mode 100644
index 0000000..4f31e74
--- /dev/null
+++ b/ProjectSettings/AudioManager.asset
@@ -0,0 +1,17 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!11 &1
+AudioManager:
+  m_ObjectHideFlags: 0
+  m_Volume: 1
+  Rolloff Scale: 1
+  Doppler Factor: 1
+  Default Speaker Mode: 2
+  m_SampleRate: 0
+  m_DSPBufferSize: 1024
+  m_VirtualVoiceCount: 512
+  m_RealVoiceCount: 32
+  m_SpatializerPlugin: 
+  m_AmbisonicDecoderPlugin: 
+  m_DisableAudio: 0
+  m_VirtualizeEffects: 1
diff --git a/ProjectSettings/ClusterInputManager.asset b/ProjectSettings/ClusterInputManager.asset
new file mode 100644
index 0000000..e7886b2
--- /dev/null
+++ b/ProjectSettings/ClusterInputManager.asset
@@ -0,0 +1,6 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!236 &1
+ClusterInputManager:
+  m_ObjectHideFlags: 0
+  m_Inputs: []
diff --git a/ProjectSettings/DynamicsManager.asset b/ProjectSettings/DynamicsManager.asset
new file mode 100644
index 0000000..4144c06
--- /dev/null
+++ b/ProjectSettings/DynamicsManager.asset
@@ -0,0 +1,30 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!55 &1
+PhysicsManager:
+  m_ObjectHideFlags: 0
+  serializedVersion: 7
+  m_Gravity: {x: 0, y: -9.81, z: 0}
+  m_DefaultMaterial: {fileID: 0}
+  m_BounceThreshold: 2
+  m_SleepThreshold: 0.005
+  m_DefaultContactOffset: 0.01
+  m_DefaultSolverIterations: 6
+  m_DefaultSolverVelocityIterations: 1
+  m_QueriesHitBackfaces: 0
+  m_QueriesHitTriggers: 1
+  m_EnableAdaptiveForce: 0
+  m_ClothInterCollisionDistance: 0
+  m_ClothInterCollisionStiffness: 0
+  m_ContactsGeneration: 1
+  m_LayerCollisionMatrix: ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+  m_AutoSimulation: 1
+  m_AutoSyncTransforms: 0
+  m_ReuseCollisionCallbacks: 1
+  m_ClothInterCollisionSettingsToggle: 0
+  m_ContactPairsMode: 0
+  m_BroadphaseType: 0
+  m_WorldBounds:
+    m_Center: {x: 0, y: 0, z: 0}
+    m_Extent: {x: 250, y: 250, z: 250}
+  m_WorldSubdivisions: 8
diff --git a/ProjectSettings/EditorBuildSettings.asset b/ProjectSettings/EditorBuildSettings.asset
new file mode 100644
index 0000000..d2b5b9d
--- /dev/null
+++ b/ProjectSettings/EditorBuildSettings.asset
@@ -0,0 +1,11 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1045 &1
+EditorBuildSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_Scenes:
+  - enabled: 1
+    path: Assets/Scenes/SandboxMain.unity
+    guid: 2cda990e2423bbf4892e6590ba056729
+  m_configObjects: {}
diff --git a/ProjectSettings/EditorSettings.asset b/ProjectSettings/EditorSettings.asset
new file mode 100644
index 0000000..8d9e83b
--- /dev/null
+++ b/ProjectSettings/EditorSettings.asset
@@ -0,0 +1,21 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!159 &1
+EditorSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 7
+  m_ExternalVersionControlSupport: Visible Meta Files
+  m_SerializationMode: 2
+  m_LineEndingsForNewScripts: 2
+  m_DefaultBehaviorMode: 1
+  m_SpritePackerMode: 4
+  m_SpritePackerPaddingPower: 1
+  m_EtcTextureCompressorBehavior: 1
+  m_EtcTextureFastCompressor: 1
+  m_EtcTextureNormalCompressor: 2
+  m_EtcTextureBestCompressor: 4
+  m_ProjectGenerationIncludedExtensions: txt;xml;fnt;cd
+  m_ProjectGenerationRootNamespace: 
+  m_UserGeneratedProjectSuffix: 
+  m_CollabEditorSettings:
+    inProgressEnabled: 1
diff --git a/ProjectSettings/GraphicsSettings.asset b/ProjectSettings/GraphicsSettings.asset
new file mode 100644
index 0000000..ab4d074
--- /dev/null
+++ b/ProjectSettings/GraphicsSettings.asset
@@ -0,0 +1,60 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!30 &1
+GraphicsSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 12
+  m_Deferred:
+    m_Mode: 1
+    m_Shader: {fileID: 69, guid: 0000000000000000f000000000000000, type: 0}
+  m_DeferredReflections:
+    m_Mode: 1
+    m_Shader: {fileID: 74, guid: 0000000000000000f000000000000000, type: 0}
+  m_ScreenSpaceShadows:
+    m_Mode: 1
+    m_Shader: {fileID: 64, guid: 0000000000000000f000000000000000, type: 0}
+  m_LegacyDeferred:
+    m_Mode: 1
+    m_Shader: {fileID: 63, guid: 0000000000000000f000000000000000, type: 0}
+  m_DepthNormals:
+    m_Mode: 1
+    m_Shader: {fileID: 62, guid: 0000000000000000f000000000000000, type: 0}
+  m_MotionVectors:
+    m_Mode: 1
+    m_Shader: {fileID: 75, guid: 0000000000000000f000000000000000, type: 0}
+  m_LightHalo:
+    m_Mode: 1
+    m_Shader: {fileID: 105, guid: 0000000000000000f000000000000000, type: 0}
+  m_LensFlare:
+    m_Mode: 1
+    m_Shader: {fileID: 102, guid: 0000000000000000f000000000000000, type: 0}
+  m_AlwaysIncludedShaders:
+  - {fileID: 10753, guid: 0000000000000000f000000000000000, type: 0}
+  - {fileID: 10770, guid: 0000000000000000f000000000000000, type: 0}
+  - {fileID: 16000, guid: 0000000000000000f000000000000000, type: 0}
+  - {fileID: 16001, guid: 0000000000000000f000000000000000, type: 0}
+  - {fileID: 17000, guid: 0000000000000000f000000000000000, type: 0}
+  m_PreloadedShaders: []
+  m_SpritesDefaultMaterial: {fileID: 10754, guid: 0000000000000000f000000000000000,
+    type: 0}
+  m_CustomRenderPipeline: {fileID: 0}
+  m_TransparencySortMode: 0
+  m_TransparencySortAxis: {x: 0, y: 0, z: 1}
+  m_DefaultRenderingPath: 1
+  m_DefaultMobileRenderingPath: 1
+  m_TierSettings: []
+  m_LightmapStripping: 0
+  m_FogStripping: 0
+  m_InstancingStripping: 0
+  m_LightmapKeepPlain: 1
+  m_LightmapKeepDirCombined: 1
+  m_LightmapKeepDynamicPlain: 1
+  m_LightmapKeepDynamicDirCombined: 1
+  m_LightmapKeepShadowMask: 1
+  m_LightmapKeepSubtractive: 1
+  m_FogKeepLinear: 1
+  m_FogKeepExp: 1
+  m_FogKeepExp2: 1
+  m_AlbedoSwatchInfos: []
+  m_LightsUseLinearIntensity: 0
+  m_LightsUseColorTemperature: 0
diff --git a/ProjectSettings/InputManager.asset b/ProjectSettings/InputManager.asset
new file mode 100644
index 0000000..17c8f53
--- /dev/null
+++ b/ProjectSettings/InputManager.asset
@@ -0,0 +1,295 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!13 &1
+InputManager:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_Axes:
+  - serializedVersion: 3
+    m_Name: Horizontal
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: left
+    positiveButton: right
+    altNegativeButton: a
+    altPositiveButton: d
+    gravity: 3
+    dead: 0.001
+    sensitivity: 3
+    snap: 1
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Vertical
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: down
+    positiveButton: up
+    altNegativeButton: s
+    altPositiveButton: w
+    gravity: 3
+    dead: 0.001
+    sensitivity: 3
+    snap: 1
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Fire1
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: left ctrl
+    altNegativeButton: 
+    altPositiveButton: mouse 0
+    gravity: 1000
+    dead: 0.001
+    sensitivity: 1000
+    snap: 0
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Fire2
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: left alt
+    altNegativeButton: 
+    altPositiveButton: mouse 1
+    gravity: 1000
+    dead: 0.001
+    sensitivity: 1000
+    snap: 0
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Fire3
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: left shift
+    altNegativeButton: 
+    altPositiveButton: mouse 2
+    gravity: 1000
+    dead: 0.001
+    sensitivity: 1000
+    snap: 0
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Jump
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: space
+    altNegativeButton: 
+    altPositiveButton: 
+    gravity: 1000
+    dead: 0.001
+    sensitivity: 1000
+    snap: 0
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Mouse X
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: 
+    altNegativeButton: 
+    altPositiveButton: 
+    gravity: 0
+    dead: 0
+    sensitivity: 0.1
+    snap: 0
+    invert: 0
+    type: 1
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Mouse Y
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: 
+    altNegativeButton: 
+    altPositiveButton: 
+    gravity: 0
+    dead: 0
+    sensitivity: 0.1
+    snap: 0
+    invert: 0
+    type: 1
+    axis: 1
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Mouse ScrollWheel
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: 
+    altNegativeButton: 
+    altPositiveButton: 
+    gravity: 0
+    dead: 0
+    sensitivity: 0.1
+    snap: 0
+    invert: 0
+    type: 1
+    axis: 2
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Horizontal
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: 
+    altNegativeButton: 
+    altPositiveButton: 
+    gravity: 0
+    dead: 0.19
+    sensitivity: 1
+    snap: 0
+    invert: 0
+    type: 2
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Vertical
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: 
+    altNegativeButton: 
+    altPositiveButton: 
+    gravity: 0
+    dead: 0.19
+    sensitivity: 1
+    snap: 0
+    invert: 1
+    type: 2
+    axis: 1
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Fire1
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: joystick button 0
+    altNegativeButton: 
+    altPositiveButton: 
+    gravity: 1000
+    dead: 0.001
+    sensitivity: 1000
+    snap: 0
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Fire2
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: joystick button 1
+    altNegativeButton: 
+    altPositiveButton: 
+    gravity: 1000
+    dead: 0.001
+    sensitivity: 1000
+    snap: 0
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Fire3
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: joystick button 2
+    altNegativeButton: 
+    altPositiveButton: 
+    gravity: 1000
+    dead: 0.001
+    sensitivity: 1000
+    snap: 0
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Jump
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: joystick button 3
+    altNegativeButton: 
+    altPositiveButton: 
+    gravity: 1000
+    dead: 0.001
+    sensitivity: 1000
+    snap: 0
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Submit
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: return
+    altNegativeButton: 
+    altPositiveButton: joystick button 0
+    gravity: 1000
+    dead: 0.001
+    sensitivity: 1000
+    snap: 0
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Submit
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: enter
+    altNegativeButton: 
+    altPositiveButton: space
+    gravity: 1000
+    dead: 0.001
+    sensitivity: 1000
+    snap: 0
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0
+  - serializedVersion: 3
+    m_Name: Cancel
+    descriptiveName: 
+    descriptiveNegativeName: 
+    negativeButton: 
+    positiveButton: escape
+    altNegativeButton: 
+    altPositiveButton: joystick button 1
+    gravity: 1000
+    dead: 0.001
+    sensitivity: 1000
+    snap: 0
+    invert: 0
+    type: 0
+    axis: 0
+    joyNum: 0
diff --git a/ProjectSettings/NavMeshAreas.asset b/ProjectSettings/NavMeshAreas.asset
new file mode 100644
index 0000000..3b0b7c3
--- /dev/null
+++ b/ProjectSettings/NavMeshAreas.asset
@@ -0,0 +1,91 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!126 &1
+NavMeshProjectSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  areas:
+  - name: Walkable
+    cost: 1
+  - name: Not Walkable
+    cost: 1
+  - name: Jump
+    cost: 2
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  - name: 
+    cost: 1
+  m_LastAgentTypeID: -887442657
+  m_Settings:
+  - serializedVersion: 2
+    agentTypeID: 0
+    agentRadius: 0.5
+    agentHeight: 2
+    agentSlope: 45
+    agentClimb: 0.75
+    ledgeDropHeight: 0
+    maxJumpAcrossDistance: 0
+    minRegionArea: 2
+    manualCellSize: 0
+    cellSize: 0.16666667
+    manualTileSize: 0
+    tileSize: 256
+    accuratePlacement: 0
+    debug:
+      m_Flags: 0
+  m_SettingNames:
+  - Humanoid
diff --git a/ProjectSettings/NetworkManager.asset b/ProjectSettings/NetworkManager.asset
new file mode 100644
index 0000000..5dc6a83
--- /dev/null
+++ b/ProjectSettings/NetworkManager.asset
@@ -0,0 +1,8 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!149 &1
+NetworkManager:
+  m_ObjectHideFlags: 0
+  m_DebugLevel: 0
+  m_Sendrate: 15
+  m_AssetToPrefab: {}
diff --git a/ProjectSettings/Physics2DSettings.asset b/ProjectSettings/Physics2DSettings.asset
new file mode 100644
index 0000000..71e5981
Binary files /dev/null and b/ProjectSettings/Physics2DSettings.asset differ
diff --git a/ProjectSettings/PresetManager.asset b/ProjectSettings/PresetManager.asset
new file mode 100644
index 0000000..636a595
--- /dev/null
+++ b/ProjectSettings/PresetManager.asset
@@ -0,0 +1,6 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1386491679 &1
+PresetManager:
+  m_ObjectHideFlags: 0
+  m_DefaultList: []
diff --git a/ProjectSettings/ProjectSettings.asset b/ProjectSettings/ProjectSettings.asset
new file mode 100644
index 0000000..f788aee
--- /dev/null
+++ b/ProjectSettings/ProjectSettings.asset
@@ -0,0 +1,620 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!129 &1
+PlayerSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 17
+  productGUID: 904cd7a3163037f42a9204c0e2f2b7bd
+  AndroidProfiler: 0
+  AndroidFilterTouchesWhenObscured: 0
+  AndroidEnableSustainedPerformanceMode: 0
+  defaultScreenOrientation: 4
+  targetDevice: 2
+  useOnDemandResources: 0
+  accelerometerFrequency: 60
+  companyName: DefaultCompany
+  productName: UniTask
+  defaultCursor: {fileID: 0}
+  cursorHotspot: {x: 0, y: 0}
+  m_SplashScreenBackgroundColor: {r: 0.13725491, g: 0.12156863, b: 0.1254902, a: 1}
+  m_ShowUnitySplashScreen: 1
+  m_ShowUnitySplashLogo: 1
+  m_SplashScreenOverlayOpacity: 1
+  m_SplashScreenAnimation: 1
+  m_SplashScreenLogoStyle: 1
+  m_SplashScreenDrawMode: 0
+  m_SplashScreenBackgroundAnimationZoom: 1
+  m_SplashScreenLogoAnimationZoom: 1
+  m_SplashScreenBackgroundLandscapeAspect: 1
+  m_SplashScreenBackgroundPortraitAspect: 1
+  m_SplashScreenBackgroundLandscapeUvs:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  m_SplashScreenBackgroundPortraitUvs:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  m_SplashScreenLogos: []
+  m_VirtualRealitySplashScreen: {fileID: 0}
+  m_HolographicTrackingLossScreen: {fileID: 0}
+  defaultScreenWidth: 1024
+  defaultScreenHeight: 768
+  defaultScreenWidthWeb: 960
+  defaultScreenHeightWeb: 600
+  m_StereoRenderingPath: 0
+  m_ActiveColorSpace: 0
+  m_MTRendering: 1
+  m_StackTraceTypes: 010000000100000001000000010000000100000001000000
+  iosShowActivityIndicatorOnLoading: -1
+  androidShowActivityIndicatorOnLoading: -1
+  iosAppInBackgroundBehavior: 0
+  displayResolutionDialog: 0
+  iosAllowHTTPDownload: 1
+  allowedAutorotateToPortrait: 1
+  allowedAutorotateToPortraitUpsideDown: 1
+  allowedAutorotateToLandscapeRight: 1
+  allowedAutorotateToLandscapeLeft: 1
+  useOSAutorotation: 1
+  use32BitDisplayBuffer: 1
+  preserveFramebufferAlpha: 0
+  disableDepthAndStencilBuffers: 0
+  androidStartInFullscreen: 1
+  androidRenderOutsideSafeArea: 1
+  androidUseSwappy: 0
+  androidBlitType: 0
+  defaultIsNativeResolution: 1
+  macRetinaSupport: 1
+  runInBackground: 1
+  captureSingleScreen: 0
+  muteOtherAudioSources: 0
+  Prepare IOS For Recording: 0
+  Force IOS Speakers When Recording: 0
+  deferSystemGesturesMode: 0
+  hideHomeButton: 0
+  submitAnalytics: 1
+  usePlayerLog: 1
+  bakeCollisionMeshes: 0
+  forceSingleInstance: 0
+  resizableWindow: 1
+  useMacAppStoreValidation: 0
+  macAppStoreCategory: public.app-category.games
+  gpuSkinning: 0
+  graphicsJobs: 0
+  xboxPIXTextureCapture: 0
+  xboxEnableAvatar: 0
+  xboxEnableKinect: 0
+  xboxEnableKinectAutoTracking: 0
+  xboxEnableFitness: 0
+  visibleInBackground: 1
+  allowFullscreenSwitch: 1
+  graphicsJobMode: 0
+  fullscreenMode: 3
+  xboxSpeechDB: 0
+  xboxEnableHeadOrientation: 0
+  xboxEnableGuest: 0
+  xboxEnablePIXSampling: 0
+  metalFramebufferOnly: 0
+  xboxOneResolution: 0
+  xboxOneSResolution: 0
+  xboxOneXResolution: 3
+  xboxOneMonoLoggingLevel: 0
+  xboxOneLoggingLevel: 1
+  xboxOneDisableEsram: 0
+  xboxOnePresentImmediateThreshold: 0
+  switchQueueCommandMemory: 0
+  switchQueueControlMemory: 16384
+  switchQueueComputeMemory: 262144
+  switchNVNShaderPoolsGranularity: 33554432
+  switchNVNDefaultPoolsGranularity: 16777216
+  switchNVNOtherPoolsGranularity: 16777216
+  vulkanEnableSetSRGBWrite: 0
+  m_SupportedAspectRatios:
+    4:3: 1
+    5:4: 1
+    16:10: 1
+    16:9: 1
+    Others: 1
+  bundleVersion: 0.1
+  preloadedAssets: []
+  metroInputSource: 0
+  wsaTransparentSwapchain: 0
+  m_HolographicPauseOnTrackingLoss: 1
+  xboxOneDisableKinectGpuReservation: 1
+  xboxOneEnable7thCore: 1
+  vrSettings:
+    cardboard:
+      depthFormat: 0
+      enableTransitionView: 0
+    daydream:
+      depthFormat: 0
+      useSustainedPerformanceMode: 0
+      enableVideoLayer: 0
+      useProtectedVideoMemory: 0
+      minimumSupportedHeadTracking: 0
+      maximumSupportedHeadTracking: 1
+    hololens:
+      depthFormat: 1
+      depthBufferSharingEnabled: 1
+    lumin:
+      depthFormat: 0
+      frameTiming: 2
+      enableGLCache: 0
+      glCacheMaxBlobSize: 524288
+      glCacheMaxFileSize: 8388608
+    oculus:
+      sharedDepthBuffer: 1
+      dashSupport: 1
+      lowOverheadMode: 0
+    enable360StereoCapture: 0
+  isWsaHolographicRemotingEnabled: 0
+  protectGraphicsMemory: 0
+  enableFrameTimingStats: 0
+  useHDRDisplay: 0
+  m_ColorGamuts: 00000000
+  targetPixelDensity: 30
+  resolutionScalingMode: 0
+  androidSupportedAspectRatio: 1
+  androidMaxAspectRatio: 2.1
+  applicationIdentifier:
+    Standalone: com.Company.ProductName
+  buildNumber: {}
+  AndroidBundleVersionCode: 1
+  AndroidMinSdkVersion: 16
+  AndroidTargetSdkVersion: 0
+  AndroidPreferredInstallLocation: 1
+  aotOptions: 
+  stripEngineCode: 1
+  iPhoneStrippingLevel: 0
+  iPhoneScriptCallOptimization: 0
+  ForceInternetPermission: 0
+  ForceSDCardPermission: 0
+  CreateWallpaper: 0
+  APKExpansionFiles: 0
+  keepLoadedShadersAlive: 0
+  StripUnusedMeshComponents: 1
+  VertexChannelCompressionMask: 4054
+  iPhoneSdkVersion: 988
+  iOSTargetOSVersionString: 9.0
+  tvOSSdkVersion: 0
+  tvOSRequireExtendedGameController: 0
+  tvOSTargetOSVersionString: 9.0
+  uIPrerenderedIcon: 0
+  uIRequiresPersistentWiFi: 0
+  uIRequiresFullScreen: 1
+  uIStatusBarHidden: 1
+  uIExitOnSuspend: 0
+  uIStatusBarStyle: 0
+  iPhoneSplashScreen: {fileID: 0}
+  iPhoneHighResSplashScreen: {fileID: 0}
+  iPhoneTallHighResSplashScreen: {fileID: 0}
+  iPhone47inSplashScreen: {fileID: 0}
+  iPhone55inPortraitSplashScreen: {fileID: 0}
+  iPhone55inLandscapeSplashScreen: {fileID: 0}
+  iPhone58inPortraitSplashScreen: {fileID: 0}
+  iPhone58inLandscapeSplashScreen: {fileID: 0}
+  iPadPortraitSplashScreen: {fileID: 0}
+  iPadHighResPortraitSplashScreen: {fileID: 0}
+  iPadLandscapeSplashScreen: {fileID: 0}
+  iPadHighResLandscapeSplashScreen: {fileID: 0}
+  iPhone65inPortraitSplashScreen: {fileID: 0}
+  iPhone65inLandscapeSplashScreen: {fileID: 0}
+  iPhone61inPortraitSplashScreen: {fileID: 0}
+  iPhone61inLandscapeSplashScreen: {fileID: 0}
+  appleTVSplashScreen: {fileID: 0}
+  appleTVSplashScreen2x: {fileID: 0}
+  tvOSSmallIconLayers: []
+  tvOSSmallIconLayers2x: []
+  tvOSLargeIconLayers: []
+  tvOSLargeIconLayers2x: []
+  tvOSTopShelfImageLayers: []
+  tvOSTopShelfImageLayers2x: []
+  tvOSTopShelfImageWideLayers: []
+  tvOSTopShelfImageWideLayers2x: []
+  iOSLaunchScreenType: 0
+  iOSLaunchScreenPortrait: {fileID: 0}
+  iOSLaunchScreenLandscape: {fileID: 0}
+  iOSLaunchScreenBackgroundColor:
+    serializedVersion: 2
+    rgba: 0
+  iOSLaunchScreenFillPct: 100
+  iOSLaunchScreenSize: 100
+  iOSLaunchScreenCustomXibPath: 
+  iOSLaunchScreeniPadType: 0
+  iOSLaunchScreeniPadImage: {fileID: 0}
+  iOSLaunchScreeniPadBackgroundColor:
+    serializedVersion: 2
+    rgba: 0
+  iOSLaunchScreeniPadFillPct: 100
+  iOSLaunchScreeniPadSize: 100
+  iOSLaunchScreeniPadCustomXibPath: 
+  iOSUseLaunchScreenStoryboard: 0
+  iOSLaunchScreenCustomStoryboardPath: 
+  iOSDeviceRequirements: []
+  iOSURLSchemes: []
+  iOSBackgroundModes: 0
+  iOSMetalForceHardShadows: 0
+  metalEditorSupport: 1
+  metalAPIValidation: 1
+  iOSRenderExtraFrameOnPause: 0
+  appleDeveloperTeamID: 
+  iOSManualSigningProvisioningProfileID: 
+  tvOSManualSigningProvisioningProfileID: 
+  iOSManualSigningProvisioningProfileType: 0
+  tvOSManualSigningProvisioningProfileType: 0
+  appleEnableAutomaticSigning: 0
+  iOSRequireARKit: 0
+  iOSAutomaticallyDetectAndAddCapabilities: 1
+  appleEnableProMotion: 0
+  clonedFromGUID: 5f34be1353de5cf4398729fda238591b
+  templatePackageId: com.unity.template.2d@3.1.0
+  templateDefaultScene: Assets/Scenes/SampleScene.unity
+  AndroidTargetArchitectures: 1
+  AndroidSplashScreenScale: 0
+  androidSplashScreen: {fileID: 0}
+  AndroidKeystoreName: '{inproject}: '
+  AndroidKeyaliasName: 
+  AndroidBuildApkPerCpuArchitecture: 0
+  AndroidTVCompatibility: 0
+  AndroidIsGame: 1
+  AndroidEnableTango: 0
+  androidEnableBanner: 1
+  androidUseLowAccuracyLocation: 0
+  androidUseCustomKeystore: 0
+  m_AndroidBanners:
+  - width: 320
+    height: 180
+    banner: {fileID: 0}
+  androidGamepadSupportLevel: 0
+  AndroidValidateAppBundleSize: 1
+  AndroidAppBundleSizeToValidate: 100
+  resolutionDialogBanner: {fileID: 0}
+  m_BuildTargetIcons: []
+  m_BuildTargetPlatformIcons: []
+  m_BuildTargetBatching: []
+  m_BuildTargetGraphicsAPIs:
+  - m_BuildTarget: AndroidPlayer
+    m_APIs: 150000000b000000
+    m_Automatic: 0
+  m_BuildTargetVRSettings: []
+  m_BuildTargetEnableVuforiaSettings: []
+  openGLRequireES31: 0
+  openGLRequireES31AEP: 0
+  openGLRequireES32: 0
+  m_TemplateCustomTags: {}
+  mobileMTRendering:
+    Android: 1
+    iPhone: 1
+    tvOS: 1
+  m_BuildTargetGroupLightmapEncodingQuality: []
+  m_BuildTargetGroupLightmapSettings: []
+  playModeTestRunnerEnabled: 0
+  runPlayModeTestAsEditModeTest: 0
+  actionOnDotNetUnhandledException: 1
+  enableInternalProfiler: 0
+  logObjCUncaughtExceptions: 1
+  enableCrashReportAPI: 0
+  cameraUsageDescription: 
+  locationUsageDescription: 
+  microphoneUsageDescription: 
+  switchNetLibKey: 
+  switchSocketMemoryPoolSize: 6144
+  switchSocketAllocatorPoolSize: 128
+  switchSocketConcurrencyLimit: 14
+  switchScreenResolutionBehavior: 2
+  switchUseCPUProfiler: 0
+  switchApplicationID: 0x01004b9000490000
+  switchNSODependencies: 
+  switchTitleNames_0: 
+  switchTitleNames_1: 
+  switchTitleNames_2: 
+  switchTitleNames_3: 
+  switchTitleNames_4: 
+  switchTitleNames_5: 
+  switchTitleNames_6: 
+  switchTitleNames_7: 
+  switchTitleNames_8: 
+  switchTitleNames_9: 
+  switchTitleNames_10: 
+  switchTitleNames_11: 
+  switchTitleNames_12: 
+  switchTitleNames_13: 
+  switchTitleNames_14: 
+  switchPublisherNames_0: 
+  switchPublisherNames_1: 
+  switchPublisherNames_2: 
+  switchPublisherNames_3: 
+  switchPublisherNames_4: 
+  switchPublisherNames_5: 
+  switchPublisherNames_6: 
+  switchPublisherNames_7: 
+  switchPublisherNames_8: 
+  switchPublisherNames_9: 
+  switchPublisherNames_10: 
+  switchPublisherNames_11: 
+  switchPublisherNames_12: 
+  switchPublisherNames_13: 
+  switchPublisherNames_14: 
+  switchIcons_0: {fileID: 0}
+  switchIcons_1: {fileID: 0}
+  switchIcons_2: {fileID: 0}
+  switchIcons_3: {fileID: 0}
+  switchIcons_4: {fileID: 0}
+  switchIcons_5: {fileID: 0}
+  switchIcons_6: {fileID: 0}
+  switchIcons_7: {fileID: 0}
+  switchIcons_8: {fileID: 0}
+  switchIcons_9: {fileID: 0}
+  switchIcons_10: {fileID: 0}
+  switchIcons_11: {fileID: 0}
+  switchIcons_12: {fileID: 0}
+  switchIcons_13: {fileID: 0}
+  switchIcons_14: {fileID: 0}
+  switchSmallIcons_0: {fileID: 0}
+  switchSmallIcons_1: {fileID: 0}
+  switchSmallIcons_2: {fileID: 0}
+  switchSmallIcons_3: {fileID: 0}
+  switchSmallIcons_4: {fileID: 0}
+  switchSmallIcons_5: {fileID: 0}
+  switchSmallIcons_6: {fileID: 0}
+  switchSmallIcons_7: {fileID: 0}
+  switchSmallIcons_8: {fileID: 0}
+  switchSmallIcons_9: {fileID: 0}
+  switchSmallIcons_10: {fileID: 0}
+  switchSmallIcons_11: {fileID: 0}
+  switchSmallIcons_12: {fileID: 0}
+  switchSmallIcons_13: {fileID: 0}
+  switchSmallIcons_14: {fileID: 0}
+  switchManualHTML: 
+  switchAccessibleURLs: 
+  switchLegalInformation: 
+  switchMainThreadStackSize: 1048576
+  switchPresenceGroupId: 
+  switchLogoHandling: 0
+  switchReleaseVersion: 0
+  switchDisplayVersion: 1.0.0
+  switchStartupUserAccount: 0
+  switchTouchScreenUsage: 0
+  switchSupportedLanguagesMask: 0
+  switchLogoType: 0
+  switchApplicationErrorCodeCategory: 
+  switchUserAccountSaveDataSize: 0
+  switchUserAccountSaveDataJournalSize: 0
+  switchApplicationAttribute: 0
+  switchCardSpecSize: -1
+  switchCardSpecClock: -1
+  switchRatingsMask: 0
+  switchRatingsInt_0: 0
+  switchRatingsInt_1: 0
+  switchRatingsInt_2: 0
+  switchRatingsInt_3: 0
+  switchRatingsInt_4: 0
+  switchRatingsInt_5: 0
+  switchRatingsInt_6: 0
+  switchRatingsInt_7: 0
+  switchRatingsInt_8: 0
+  switchRatingsInt_9: 0
+  switchRatingsInt_10: 0
+  switchRatingsInt_11: 0
+  switchLocalCommunicationIds_0: 
+  switchLocalCommunicationIds_1: 
+  switchLocalCommunicationIds_2: 
+  switchLocalCommunicationIds_3: 
+  switchLocalCommunicationIds_4: 
+  switchLocalCommunicationIds_5: 
+  switchLocalCommunicationIds_6: 
+  switchLocalCommunicationIds_7: 
+  switchParentalControl: 0
+  switchAllowsScreenshot: 1
+  switchAllowsVideoCapturing: 1
+  switchAllowsRuntimeAddOnContentInstall: 0
+  switchDataLossConfirmation: 0
+  switchUserAccountLockEnabled: 0
+  switchSystemResourceMemory: 16777216
+  switchSupportedNpadStyles: 3
+  switchNativeFsCacheSize: 32
+  switchIsHoldTypeHorizontal: 0
+  switchSupportedNpadCount: 8
+  switchSocketConfigEnabled: 0
+  switchTcpInitialSendBufferSize: 32
+  switchTcpInitialReceiveBufferSize: 64
+  switchTcpAutoSendBufferSizeMax: 256
+  switchTcpAutoReceiveBufferSizeMax: 256
+  switchUdpSendBufferSize: 9
+  switchUdpReceiveBufferSize: 42
+  switchSocketBufferEfficiency: 4
+  switchSocketInitializeEnabled: 1
+  switchNetworkInterfaceManagerInitializeEnabled: 1
+  switchPlayerConnectionEnabled: 1
+  ps4NPAgeRating: 12
+  ps4NPTitleSecret: 
+  ps4NPTrophyPackPath: 
+  ps4ParentalLevel: 11
+  ps4ContentID: ED1633-NPXX51362_00-0000000000000000
+  ps4Category: 0
+  ps4MasterVersion: 01.00
+  ps4AppVersion: 01.00
+  ps4AppType: 0
+  ps4ParamSfxPath: 
+  ps4VideoOutPixelFormat: 0
+  ps4VideoOutInitialWidth: 1920
+  ps4VideoOutBaseModeInitialWidth: 1920
+  ps4VideoOutReprojectionRate: 60
+  ps4PronunciationXMLPath: 
+  ps4PronunciationSIGPath: 
+  ps4BackgroundImagePath: 
+  ps4StartupImagePath: 
+  ps4StartupImagesFolder: 
+  ps4IconImagesFolder: 
+  ps4SaveDataImagePath: 
+  ps4SdkOverride: 
+  ps4BGMPath: 
+  ps4ShareFilePath: 
+  ps4ShareOverlayImagePath: 
+  ps4PrivacyGuardImagePath: 
+  ps4NPtitleDatPath: 
+  ps4RemotePlayKeyAssignment: -1
+  ps4RemotePlayKeyMappingDir: 
+  ps4PlayTogetherPlayerCount: 0
+  ps4EnterButtonAssignment: 1
+  ps4ApplicationParam1: 0
+  ps4ApplicationParam2: 0
+  ps4ApplicationParam3: 0
+  ps4ApplicationParam4: 0
+  ps4DownloadDataSize: 0
+  ps4GarlicHeapSize: 2048
+  ps4ProGarlicHeapSize: 2560
+  playerPrefsMaxSize: 32768
+  ps4Passcode: frAQBc8Wsa1xVPfvJcrgRYwTiizs2trQ
+  ps4pnSessions: 1
+  ps4pnPresence: 1
+  ps4pnFriends: 1
+  ps4pnGameCustomData: 1
+  playerPrefsSupport: 0
+  enableApplicationExit: 0
+  resetTempFolder: 1
+  restrictedAudioUsageRights: 0
+  ps4UseResolutionFallback: 0
+  ps4ReprojectionSupport: 0
+  ps4UseAudio3dBackend: 0
+  ps4SocialScreenEnabled: 0
+  ps4ScriptOptimizationLevel: 0
+  ps4Audio3dVirtualSpeakerCount: 14
+  ps4attribCpuUsage: 0
+  ps4PatchPkgPath: 
+  ps4PatchLatestPkgPath: 
+  ps4PatchChangeinfoPath: 
+  ps4PatchDayOne: 0
+  ps4attribUserManagement: 0
+  ps4attribMoveSupport: 0
+  ps4attrib3DSupport: 0
+  ps4attribShareSupport: 0
+  ps4attribExclusiveVR: 0
+  ps4disableAutoHideSplash: 0
+  ps4videoRecordingFeaturesUsed: 0
+  ps4contentSearchFeaturesUsed: 0
+  ps4attribEyeToEyeDistanceSettingVR: 0
+  ps4IncludedModules: []
+  monoEnv: 
+  splashScreenBackgroundSourceLandscape: {fileID: 0}
+  splashScreenBackgroundSourcePortrait: {fileID: 0}
+  blurSplashScreenBackground: 1
+  spritePackerPolicy: 
+  webGLMemorySize: 16
+  webGLExceptionSupport: 1
+  webGLNameFilesAsHashes: 0
+  webGLDataCaching: 1
+  webGLDebugSymbols: 0
+  webGLEmscriptenArgs: 
+  webGLModulesDirectory: 
+  webGLTemplate: APPLICATION:Default
+  webGLAnalyzeBuildSize: 0
+  webGLUseEmbeddedResources: 0
+  webGLCompressionFormat: 1
+  webGLLinkerTarget: 1
+  webGLThreadsSupport: 0
+  webGLWasmStreaming: 0
+  scriptingDefineSymbols: {}
+  platformArchitecture: {}
+  scriptingBackend:
+    Standalone: 1
+  il2cppCompilerConfiguration: {}
+  managedStrippingLevel: {}
+  incrementalIl2cppBuild: {}
+  allowUnsafeCode: 0
+  additionalIl2CppArgs: 
+  scriptingRuntimeVersion: 1
+  gcIncremental: 0
+  gcWBarrierValidation: 0
+  apiCompatibilityLevelPerPlatform: {}
+  m_RenderingPath: 1
+  m_MobileRenderingPath: 1
+  metroPackageName: Template_2D
+  metroPackageVersion: 
+  metroCertificatePath: 
+  metroCertificatePassword: 
+  metroCertificateSubject: 
+  metroCertificateIssuer: 
+  metroCertificateNotAfter: 0000000000000000
+  metroApplicationDescription: Template_2D
+  wsaImages: {}
+  metroTileShortName: 
+  metroTileShowName: 0
+  metroMediumTileShowName: 0
+  metroLargeTileShowName: 0
+  metroWideTileShowName: 0
+  metroSupportStreamingInstall: 0
+  metroLastRequiredScene: 0
+  metroDefaultTileSize: 1
+  metroTileForegroundText: 2
+  metroTileBackgroundColor: {r: 0.13333334, g: 0.17254902, b: 0.21568628, a: 0}
+  metroSplashScreenBackgroundColor: {r: 0.12941177, g: 0.17254902, b: 0.21568628,
+    a: 1}
+  metroSplashScreenUseBackgroundColor: 0
+  platformCapabilities: {}
+  metroTargetDeviceFamilies: {}
+  metroFTAName: 
+  metroFTAFileTypes: []
+  metroProtocolName: 
+  XboxOneProductId: 
+  XboxOneUpdateKey: 
+  XboxOneSandboxId: 
+  XboxOneContentId: 
+  XboxOneTitleId: 
+  XboxOneSCId: 
+  XboxOneGameOsOverridePath: 
+  XboxOnePackagingOverridePath: 
+  XboxOneAppManifestOverridePath: 
+  XboxOneVersion: 1.0.0.0
+  XboxOnePackageEncryption: 0
+  XboxOnePackageUpdateGranularity: 2
+  XboxOneDescription: 
+  XboxOneLanguage:
+  - enus
+  XboxOneCapability: []
+  XboxOneGameRating: {}
+  XboxOneIsContentPackage: 0
+  XboxOneEnableGPUVariability: 1
+  XboxOneSockets: {}
+  XboxOneSplashScreen: {fileID: 0}
+  XboxOneAllowedProductIds: []
+  XboxOnePersistentLocalStorageSize: 0
+  XboxOneXTitleMemory: 8
+  XboxOneOverrideIdentityName: 
+  vrEditorSettings:
+    daydream:
+      daydreamIconForeground: {fileID: 0}
+      daydreamIconBackground: {fileID: 0}
+  cloudServicesEnabled:
+    UNet: 1
+  luminIcon:
+    m_Name: 
+    m_ModelFolderPath: 
+    m_PortalFolderPath: 
+  luminCert:
+    m_CertPath: 
+    m_SignPackage: 1
+  luminIsChannelApp: 0
+  luminVersion:
+    m_VersionCode: 1
+    m_VersionName: 
+  facebookSdkVersion: 7.9.4
+  facebookAppId: 
+  facebookCookies: 1
+  facebookLogging: 1
+  facebookStatus: 1
+  facebookXfbml: 0
+  facebookFrictionlessRequests: 1
+  apiCompatibilityLevel: 6
+  cloudProjectId: 
+  framebufferDepthMemorylessMode: 0
+  projectName: 
+  organizationId: 
+  cloudEnabled: 0
+  enableNativePlatformBackendsForNewInputSystem: 0
+  disableOldInputManagerSupport: 0
+  legacyClampBlendShapeWeights: 1
diff --git a/ProjectSettings/ProjectVersion.txt b/ProjectSettings/ProjectVersion.txt
new file mode 100644
index 0000000..83a1801
--- /dev/null
+++ b/ProjectSettings/ProjectVersion.txt
@@ -0,0 +1,2 @@
+m_EditorVersion: 2019.3.0a2
+m_EditorVersionWithRevision: 2019.3.0a2 (fa7740529556)
diff --git a/ProjectSettings/QualitySettings.asset b/ProjectSettings/QualitySettings.asset
new file mode 100644
index 0000000..4ae8c38
--- /dev/null
+++ b/ProjectSettings/QualitySettings.asset
@@ -0,0 +1,191 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!47 &1
+QualitySettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 5
+  m_CurrentQuality: 3
+  m_QualitySettings:
+  - serializedVersion: 2
+    name: Very Low
+    pixelLightCount: 0
+    shadows: 0
+    shadowResolution: 0
+    shadowProjection: 1
+    shadowCascades: 1
+    shadowDistance: 15
+    shadowNearPlaneOffset: 3
+    shadowCascade2Split: 0.33333334
+    shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667}
+    shadowmaskMode: 0
+    blendWeights: 1
+    textureQuality: 1
+    anisotropicTextures: 0
+    antiAliasing: 0
+    softParticles: 0
+    softVegetation: 0
+    realtimeReflectionProbes: 0
+    billboardsFaceCameraPosition: 0
+    vSyncCount: 0
+    lodBias: 0.3
+    maximumLODLevel: 0
+    particleRaycastBudget: 4
+    asyncUploadTimeSlice: 2
+    asyncUploadBufferSize: 16
+    resolutionScalingFixedDPIFactor: 1
+    excludedTargetPlatforms: []
+  - serializedVersion: 2
+    name: Low
+    pixelLightCount: 0
+    shadows: 0
+    shadowResolution: 0
+    shadowProjection: 1
+    shadowCascades: 1
+    shadowDistance: 20
+    shadowNearPlaneOffset: 3
+    shadowCascade2Split: 0.33333334
+    shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667}
+    shadowmaskMode: 0
+    blendWeights: 2
+    textureQuality: 0
+    anisotropicTextures: 0
+    antiAliasing: 0
+    softParticles: 0
+    softVegetation: 0
+    realtimeReflectionProbes: 0
+    billboardsFaceCameraPosition: 0
+    vSyncCount: 0
+    lodBias: 0.4
+    maximumLODLevel: 0
+    particleRaycastBudget: 16
+    asyncUploadTimeSlice: 2
+    asyncUploadBufferSize: 16
+    resolutionScalingFixedDPIFactor: 1
+    excludedTargetPlatforms: []
+  - serializedVersion: 2
+    name: Medium
+    pixelLightCount: 1
+    shadows: 0
+    shadowResolution: 0
+    shadowProjection: 1
+    shadowCascades: 1
+    shadowDistance: 20
+    shadowNearPlaneOffset: 3
+    shadowCascade2Split: 0.33333334
+    shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667}
+    shadowmaskMode: 0
+    blendWeights: 2
+    textureQuality: 0
+    anisotropicTextures: 0
+    antiAliasing: 0
+    softParticles: 0
+    softVegetation: 0
+    realtimeReflectionProbes: 0
+    billboardsFaceCameraPosition: 0
+    vSyncCount: 1
+    lodBias: 0.7
+    maximumLODLevel: 0
+    particleRaycastBudget: 64
+    asyncUploadTimeSlice: 2
+    asyncUploadBufferSize: 16
+    resolutionScalingFixedDPIFactor: 1
+    excludedTargetPlatforms: []
+  - serializedVersion: 2
+    name: High
+    pixelLightCount: 2
+    shadows: 0
+    shadowResolution: 1
+    shadowProjection: 1
+    shadowCascades: 2
+    shadowDistance: 40
+    shadowNearPlaneOffset: 3
+    shadowCascade2Split: 0.33333334
+    shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667}
+    shadowmaskMode: 1
+    blendWeights: 2
+    textureQuality: 0
+    anisotropicTextures: 0
+    antiAliasing: 0
+    softParticles: 0
+    softVegetation: 1
+    realtimeReflectionProbes: 0
+    billboardsFaceCameraPosition: 0
+    vSyncCount: 1
+    lodBias: 1
+    maximumLODLevel: 0
+    particleRaycastBudget: 256
+    asyncUploadTimeSlice: 2
+    asyncUploadBufferSize: 16
+    resolutionScalingFixedDPIFactor: 1
+    excludedTargetPlatforms: []
+  - serializedVersion: 2
+    name: Very High
+    pixelLightCount: 3
+    shadows: 0
+    shadowResolution: 2
+    shadowProjection: 1
+    shadowCascades: 2
+    shadowDistance: 70
+    shadowNearPlaneOffset: 3
+    shadowCascade2Split: 0.33333334
+    shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667}
+    shadowmaskMode: 1
+    blendWeights: 4
+    textureQuality: 0
+    anisotropicTextures: 0
+    antiAliasing: 0
+    softParticles: 0
+    softVegetation: 1
+    realtimeReflectionProbes: 0
+    billboardsFaceCameraPosition: 0
+    vSyncCount: 1
+    lodBias: 1.5
+    maximumLODLevel: 0
+    particleRaycastBudget: 1024
+    asyncUploadTimeSlice: 2
+    asyncUploadBufferSize: 16
+    resolutionScalingFixedDPIFactor: 1
+    excludedTargetPlatforms: []
+  - serializedVersion: 2
+    name: Ultra
+    pixelLightCount: 4
+    shadows: 0
+    shadowResolution: 0
+    shadowProjection: 1
+    shadowCascades: 4
+    shadowDistance: 150
+    shadowNearPlaneOffset: 3
+    shadowCascade2Split: 0.33333334
+    shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667}
+    shadowmaskMode: 1
+    blendWeights: 4
+    textureQuality: 0
+    anisotropicTextures: 0
+    antiAliasing: 0
+    softParticles: 0
+    softVegetation: 1
+    realtimeReflectionProbes: 0
+    billboardsFaceCameraPosition: 0
+    vSyncCount: 1
+    lodBias: 2
+    maximumLODLevel: 0
+    particleRaycastBudget: 4096
+    asyncUploadTimeSlice: 2
+    asyncUploadBufferSize: 16
+    resolutionScalingFixedDPIFactor: 1
+    excludedTargetPlatforms: []
+  m_PerPlatformDefaultQuality:
+    Android: 2
+    Nintendo 3DS: 5
+    Nintendo Switch: 5
+    PS4: 5
+    PSM: 5
+    PSP2: 2
+    Standalone: 5
+    Tizen: 2
+    WebGL: 3
+    WiiU: 5
+    Windows Store Apps: 5
+    XboxOne: 5
+    iPhone: 2
+    tvOS: 2
diff --git a/ProjectSettings/TagManager.asset b/ProjectSettings/TagManager.asset
new file mode 100644
index 0000000..1c92a78
--- /dev/null
+++ b/ProjectSettings/TagManager.asset
@@ -0,0 +1,43 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!78 &1
+TagManager:
+  serializedVersion: 2
+  tags: []
+  layers:
+  - Default
+  - TransparentFX
+  - Ignore Raycast
+  - 
+  - Water
+  - UI
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  - 
+  m_SortingLayers:
+  - name: Default
+    uniqueID: 0
+    locked: 0
diff --git a/ProjectSettings/TimeManager.asset b/ProjectSettings/TimeManager.asset
new file mode 100644
index 0000000..06bcc6d
--- /dev/null
+++ b/ProjectSettings/TimeManager.asset
@@ -0,0 +1,9 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!5 &1
+TimeManager:
+  m_ObjectHideFlags: 0
+  Fixed Timestep: 0.02
+  Maximum Allowed Timestep: 0.1
+  m_TimeScale: 1
+  Maximum Particle Timestep: 0.03
diff --git a/ProjectSettings/UnityConnectSettings.asset b/ProjectSettings/UnityConnectSettings.asset
new file mode 100644
index 0000000..c3ae9a0
--- /dev/null
+++ b/ProjectSettings/UnityConnectSettings.asset
@@ -0,0 +1,34 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!310 &1
+UnityConnectSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 1
+  m_Enabled: 1
+  m_TestMode: 0
+  m_EventOldUrl: https://api.uca.cloud.unity3d.com/v1/events
+  m_EventUrl: https://cdp.cloud.unity3d.com/v1/events
+  m_ConfigUrl: https://config.uca.cloud.unity3d.com
+  m_TestInitMode: 0
+  CrashReportingSettings:
+    m_EventUrl: https://perf-events.cloud.unity3d.com
+    m_Enabled: 0
+    m_LogBufferSize: 10
+    m_CaptureEditorExceptions: 1
+  UnityPurchasingSettings:
+    m_Enabled: 0
+    m_TestMode: 0
+  UnityAnalyticsSettings:
+    m_Enabled: 0
+    m_TestMode: 0
+    m_InitializeOnStartup: 1
+  UnityAdsSettings:
+    m_Enabled: 0
+    m_InitializeOnStartup: 1
+    m_TestMode: 0
+    m_IosGameId: 
+    m_AndroidGameId: 
+    m_GameIds: {}
+    m_GameId: 
+  PerformanceReportingSettings:
+    m_Enabled: 0
diff --git a/ProjectSettings/VFXManager.asset b/ProjectSettings/VFXManager.asset
new file mode 100644
index 0000000..0ce5434
--- /dev/null
+++ b/ProjectSettings/VFXManager.asset
@@ -0,0 +1,7 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!937362698 &1
+VFXManager:
+  m_ObjectHideFlags: 0
+  m_IndirectShader: {fileID: 0}
+  m_RenderPipeSettingsPath: 
diff --git a/ProjectSettings/XRSettings.asset b/ProjectSettings/XRSettings.asset
new file mode 100644
index 0000000..482590c
--- /dev/null
+++ b/ProjectSettings/XRSettings.asset
@@ -0,0 +1,10 @@
+{
+    "m_SettingKeys": [
+        "VR Device Disabled",
+        "VR Device User Alert"
+    ],
+    "m_SettingValues": [
+        "False",
+        "False"
+    ]
+}
\ No newline at end of file