diff --git a/apps/demo/src/plugin-demos/canvas.ts b/apps/demo/src/plugin-demos/canvas.ts
index 9d58ab4b..7d298f59 100644
--- a/apps/demo/src/plugin-demos/canvas.ts
+++ b/apps/demo/src/plugin-demos/canvas.ts
@@ -70,6 +70,15 @@ export class DemoModel extends DemoSharedCanvas {
 		{ x: 128, y: 0 },
 	];
 
+	start = { x: 0, y: 0 };
+	end = { x: 256, y: 256 };
+
+  
+  start1 = { x: 128, y: 128 };
+	end1 = { x: 128, y: 16 };
+
+	colors = ['blue', 'yellow'];
+
 	image = new ImageAsset();
 
 	width = 256;
diff --git a/apps/demo/src/plugin-demos/canvas.xml b/apps/demo/src/plugin-demos/canvas.xml
index ed35cd2c..dcc19bd1 100644
--- a/apps/demo/src/plugin-demos/canvas.xml
+++ b/apps/demo/src/plugin-demos/canvas.xml
@@ -6,7 +6,7 @@
 
   <GridLayout rows="*" columns="*" loaded="{{ gridLoaded }}" iosOverflowSafeArea="false" width="100%" height="100%">
   
-  <!-- <ui:Dom rowSpan="2" colSpan="2"> -->
+  <ui:Dom rowSpan="2" colSpan="2">
 
   <!-- <ui:Fill color="#e8f4f8" />
 
@@ -21,7 +21,21 @@
         r="25"
         color="lightblue"
       /> -->
-    <!-- <ui:Circle cx="128" cy="128" r="128" color="lightblue" /> -->
+    <ui:Rect x="0" y="0" width="256" height="256">
+ <!-- <ui:LinearGradient
+          start="{{ start }}"
+          end="{{ end }}"
+          colors="{{colors}}"
+        /> -->
+
+        <ui:TwoPointConicalGradient
+           start="{{ start1 }}"
+          startR="128"
+          end="{{ end1 }}"
+          endR="16"
+           colors="{{colors}}"
+        />
+    </ui:Rect>
 
      <!-- <ui:Points
         points="{{ points }}"
@@ -91,12 +105,12 @@
       </ui:RoundedRect>
 -->
         
-  <!-- </ui:Dom>  -->
+  </ui:Dom> 
    
   
   <!-- <WebView rowSpan="2" colSpan="2" height="100%" width="100%" loaded="loaded"/> -->
-		 <canvas:Canvas rowSpan="2" colSpan="2" width="100%" height="100%" ready="{{ canvasLoaded }}"
-									 layoutChanged="{{ onLayout }}"/> 
+		 <!-- <canvas:Canvas rowSpan="2" colSpan="2" ready="{{ canvasLoaded }}"
+									 layoutChanged="{{ onLayout }}"/>  -->
                                      <!-- <canvas:Svg  id="1" width="100%" height="100%" src="{{src1}}" loaded="{{svgViewLoaded}}"/>
                                      <canvas:Svg  id="2" col="1" width="100%" height="100%" src="{{src2}}" loaded="{{svgViewLoaded}}"/>
                                       <canvas:Svg  id="3" row="1" width="100%" height="100%" src="{{src3}}" loaded="{{svgViewLoaded}}"/>
diff --git a/packages/canvas/platforms/android/canvas-release.aar b/packages/canvas/platforms/android/canvas-release.aar
index e87559ee..5f0c019d 100644
Binary files a/packages/canvas/platforms/android/canvas-release.aar and b/packages/canvas/platforms/android/canvas-release.aar differ
diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/CanvasNative b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/CanvasNative
index 30f38072..2399ed9c 100755
Binary files a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/CanvasNative and b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/CanvasNative differ
diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/canvas_native.h b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/canvas_native.h
index f637f7f7..e6720899 100644
--- a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/canvas_native.h
+++ b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/canvas_native.h
@@ -1213,6 +1213,8 @@ bool canvas_native_webgl_make_current(struct WebGLState *state);
 
 bool canvas_native_webgl_swap_buffers(struct WebGLState *state);
 
+bool canvas_native_webgl_make_current_and_swap_buffers(struct WebGLState *state);
+
 void canvas_native_webgl_resized(struct WebGLState *_state);
 
 const char *canvas_native_webgl_to_data_url(struct WebGLState *state,
diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative
index b8447807..c32705fe 100644
Binary files a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative and b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative differ
diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/CanvasNative b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/CanvasNative
index 24d47efc..7e8c59c2 100755
Binary files a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/CanvasNative and b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/CanvasNative differ
diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/Headers/canvas_native.h b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/Headers/canvas_native.h
index f637f7f7..e6720899 100644
--- a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/Headers/canvas_native.h
+++ b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/Headers/canvas_native.h
@@ -1213,6 +1213,8 @@ bool canvas_native_webgl_make_current(struct WebGLState *state);
 
 bool canvas_native_webgl_swap_buffers(struct WebGLState *state);
 
+bool canvas_native_webgl_make_current_and_swap_buffers(struct WebGLState *state);
+
 void canvas_native_webgl_resized(struct WebGLState *_state);
 
 const char *canvas_native_webgl_to_data_url(struct WebGLState *state,
diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/_CodeSignature/CodeResources b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/_CodeSignature/CodeResources
index a32579bb..b4b234b8 100644
--- a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/_CodeSignature/CodeResources
+++ b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/_CodeSignature/CodeResources
@@ -18,7 +18,7 @@
 		</data>
 		<key>Headers/canvas_native.h</key>
 		<data>
-		XsX2QGyWWWRx+Re/2nxFcoBoMjg=
+		fHjKG7aDZ9ZVi79Vu9g8z8IS9lo=
 		</data>
 		<key>Info.plist</key>
 		<data>
@@ -108,7 +108,7 @@
 		<dict>
 			<key>hash2</key>
 			<data>
-			xQtVdm5vJz/Oga/nNrCvEeqLDQmYAbn6yURH5MwoH0k=
+			aufqGvTGgpXa9ipXAyNSFoJPEdAdB2J5O3Cf8sPHYMM=
 			</data>
 		</dict>
 		<key>Modules/CanvasNative.swiftmodule/Project/arm64-apple-ios-simulator.swiftsourceinfo</key>
diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative
index adac5bfd..b51a2704 100644
Binary files a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative and b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative differ
diff --git a/packages/canvas/platforms/ios/src/cpp/canvas2d/CanvasRenderingContext2DImpl.cpp b/packages/canvas/platforms/ios/src/cpp/canvas2d/CanvasRenderingContext2DImpl.cpp
index 95903e59..adcc768e 100644
--- a/packages/canvas/platforms/ios/src/cpp/canvas2d/CanvasRenderingContext2DImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/canvas2d/CanvasRenderingContext2DImpl.cpp
@@ -6,6 +6,11 @@
 #include "Caches.h"
 #include "OneByteStringResource.h"
 
+v8::CFunction CanvasRenderingContext2DImpl::fast_start_raf_(
+        v8::CFunction::Make(CanvasRenderingContext2DImpl::__FastStartRaf));
+
+v8::CFunction CanvasRenderingContext2DImpl::fast_stop_raf_(
+        v8::CFunction::Make(CanvasRenderingContext2DImpl::__FastStopRaf));
 
 v8::CFunction CanvasRenderingContext2DImpl::fast_draw_point_(
         v8::CFunction::Make(CanvasRenderingContext2DImpl::FastDrawPoint));
@@ -251,6 +256,27 @@ CanvasRenderingContext2DImpl::GetPointer(const v8::Local<v8::Object> &object) {
     return static_cast<CanvasRenderingContext2DImpl *>(ptr);
 }
 
+
+void CanvasRenderingContext2DImpl::StartRaf() {
+    auto raf = this->GetRaf();
+    if (raf != nullptr) {
+        if (!canvas_native_raf_get_started(raf->GetRaf())) {
+            canvas_native_raf_start(raf->GetRaf());
+        }
+    }
+}
+
+
+void CanvasRenderingContext2DImpl::StopRaf() {
+    auto raf = this->GetRaf();
+    if (raf != nullptr) {
+        if (canvas_native_raf_get_started(raf->GetRaf())) {
+            canvas_native_raf_stop(raf->GetRaf());
+        }
+    }
+}
+
+
 v8::Local<v8::FunctionTemplate> CanvasRenderingContext2DImpl::GetCtor(v8::Isolate *isolate) {
     auto cache = Caches::Get(isolate);
     auto ctor = cache->CanvasRenderingContext2DTmpl.get();
@@ -264,6 +290,13 @@ v8::Local<v8::FunctionTemplate> CanvasRenderingContext2DImpl::GetCtor(v8::Isolat
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
+
+    SetFastMethod(isolate, tmpl, "__startRaf", __StartRaf, &fast_start_raf_,
+                  v8::Local<v8::Value>());
+
+    SetFastMethod(isolate, tmpl, "__stopRaf", __StopRaf, &fast_stop_raf_,
+                  v8::Local<v8::Value>());
+
     SetFastMethod(isolate, tmpl, "drawPoint", DrawPoint, &fast_draw_point_, v8::Local<v8::Value>());
 
     tmpl->Set(ConvertToV8String(isolate, "drawPoints"),
@@ -278,6 +311,9 @@ v8::Local<v8::FunctionTemplate> CanvasRenderingContext2DImpl::GetCtor(v8::Isolat
               v8::FunctionTemplate::New(isolate, __GetPointer));
     tmpl->Set(ConvertToV8String(isolate, "__resize"), v8::FunctionTemplate::New(isolate, __Resize));
 
+    tmpl->SetAccessor(ConvertToV8String(isolate, "continuousRenderMode"), GetContinuousRenderMode,
+                      SetContinuousRenderMode);
+
     tmpl->SetAccessor(ConvertToV8String(isolate, "filter"), GetFilter, SetFilter);
     tmpl->SetAccessor(ConvertToV8String(isolate, "font"), GetFont, SetFont);
     tmpl->SetAccessor(ConvertToV8String(isolate, "letterSpacing"), GetLetterSpacing,
@@ -319,24 +355,19 @@ v8::Local<v8::FunctionTemplate> CanvasRenderingContext2DImpl::GetCtor(v8::Isolat
 
     SetFastMethod(isolate, tmpl, "beginPath", BeginPath, &fast_begin_path_, v8::Local<v8::Value>());
 
-
     SetFastMethod(isolate, tmpl, "bezierCurveTo", BezierCurveTo, &fast_bezier_curve_to_,
                   v8::Local<v8::Value>());
 
-
     tmpl->Set(ConvertToV8String(isolate, "clearHitRegions"),
               v8::FunctionTemplate::New(isolate, &ClearHitRegions));
 
-
     SetFastMethod(isolate, tmpl, "clearRect", ClearRect, &fast_clear_rect_, v8::Local<v8::Value>());
 
-
     SetFastMethodWithOverLoads(isolate, tmpl, "clip", Clip, fast_clip_overloads_,
                                v8::Local<v8::Value>());
 
     SetFastMethod(isolate, tmpl, "closePath", ClosePath, &fast_close_path_, v8::Local<v8::Value>());
 
-
     tmpl->Set(ConvertToV8String(isolate, "createImageData"),
               v8::FunctionTemplate::New(isolate, &CreateImageData));
     tmpl->Set(ConvertToV8String(isolate, "createPattern"),
@@ -352,7 +383,6 @@ v8::Local<v8::FunctionTemplate> CanvasRenderingContext2DImpl::GetCtor(v8::Isolat
     tmpl->Set(ConvertToV8String(isolate, "drawFocusIfNeeded"),
               v8::FunctionTemplate::New(isolate, &DrawFocusIfNeeded));
 
-
     SetFastMethodWithOverLoads(isolate, tmpl, "drawImage", DrawImage, fast_draw_overloads_,
                                v8::Local<v8::Value>());
 
@@ -466,6 +496,59 @@ RafImpl *CanvasRenderingContext2DImpl::GetRaf() {
     return this->raf_.get();
 }
 
+
+void CanvasRenderingContext2DImpl::__StartRaf(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    CanvasRenderingContext2DImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    ptr->StartRaf();
+
+}
+
+void CanvasRenderingContext2DImpl::__StopRaf(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    CanvasRenderingContext2DImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    ptr->StopRaf();
+
+}
+
+
+void CanvasRenderingContext2DImpl::GetContinuousRenderMode(v8::Local<v8::String> property,
+                                                           const v8::PropertyCallbackInfo<v8::Value> &info) {
+    CanvasRenderingContext2DImpl *ptr = GetPointer(info.This());
+    if (ptr == nullptr) {
+        info.GetReturnValue().Set(false);
+        return;
+    }
+    info.GetReturnValue().Set(ptr->continuousRender_);
+}
+
+void CanvasRenderingContext2DImpl::SetContinuousRenderMode(v8::Local<v8::String> property,
+                                                           v8::Local<v8::Value> value,
+                                                           const v8::PropertyCallbackInfo<void> &info) {
+    CanvasRenderingContext2DImpl *ptr = GetPointer(info.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    auto isolate = info.GetIsolate();
+    auto val = value->BooleanValue(isolate);
+    if (val == ptr->continuousRender_) {
+        return;
+    }
+    if (val) {
+        ptr->StartRaf();
+    } else {
+        ptr->StopRaf();
+    }
+    ptr->continuousRender_ = val;
+}
+
+
 /* Non Standard 2D */
 
 void CanvasRenderingContext2DImpl::DrawPoint(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -490,53 +573,41 @@ void CanvasRenderingContext2DImpl::DrawPoints(const v8::FunctionCallbackInfo<v8:
     if (ptr == nullptr) {
         return;
     }
-
+    
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
-
-
-    auto mode = ConvertFromV8String(isolate, args[0]);
+    
+    
+    auto mode = args[0];
     auto points = args[1].As<v8::Array>();
     auto size = points->Length();
-
-
-    if ((size % 2) == 0) {
-        int32_t pointMode = -1;
-        if (mode == "points") {
-            pointMode = 0;
-        } else if (mode == "lines") {
-            pointMode = 1;
-        } else if (mode == "polygon") {
-            pointMode = 2;
-        }
-        if (pointMode == -1) {
-            return;
-        }
+    
+    if (size == 0){return;}
+    uint32_t pointMode = 0;
+    if(mode->IsUint32() && mode->Uint32Value(context).To(&pointMode)){
         std::vector<float> store;
-        store.reserve(size);
-        int next = 0;
+        auto len = size * 2;
+        store.reserve(len);
         for (int i = 0; i < size; i++) {
-
+            
             auto object = points->Get(
-                    context, i).ToLocalChecked().As<v8::Object>();
-
+                                      context, i).ToLocalChecked().As<v8::Object>();
+            
             auto x = object->Get(context,
                                  ConvertToV8String(isolate, "x")).ToLocalChecked()->NumberValue(
-                    context).ToChecked();
+                                                                                                context).ToChecked();
             auto y = object->Get(context,
                                  ConvertToV8String(isolate, "y")).ToLocalChecked()->NumberValue(
-                    context).ToChecked();
-            store[next] = (float) x;
-            store[next + 1] = (float) y;
-
-            next = i + 2;
+                                                                                                context).ToChecked();
+            store.emplace_back((float) x);
+            store.emplace_back((float) y);
         }
-
+        
         canvas_native_context_draw_points(
-                ptr->GetContext(), pointMode,
-                store.data(), store.size());
-
-
+                                          ptr->GetContext(), pointMode,
+                                          store.data(), store.size());
+        
+        
         ptr->UpdateInvalidateState();
     }
 }
@@ -2785,11 +2856,7 @@ void CanvasRenderingContext2DImpl::Flush() {
     auto state = (int) this->GetInvalidateState() & (int) InvalidateState::InvalidateStatePending;
     if (state == (int) InvalidateState::InvalidateStatePending) {
         this->SetInvalidateState(InvalidateState::InvalidateStateInvalidating);
-        //   canvas_native_context_flush(ptr->GetContext());
-
         canvas_native_context_render(this->GetContext());
-        //        canvas_native_context_gl_make_current(ptr->GetContext());
-        //        canvas_native_context_gl_swap_buffers(ptr->GetContext());
         this->SetInvalidateState(InvalidateState::InvalidateStateNone);
     }
 }
diff --git a/packages/canvas/platforms/ios/src/cpp/canvas2d/CanvasRenderingContext2DImpl.h b/packages/canvas/platforms/ios/src/cpp/canvas2d/CanvasRenderingContext2DImpl.h
index 13074f61..f30c85a8 100644
--- a/packages/canvas/platforms/ios/src/cpp/canvas2d/CanvasRenderingContext2DImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/canvas2d/CanvasRenderingContext2DImpl.h
@@ -28,6 +28,10 @@
 class CanvasRenderingContext2DImpl : ObjectWrapperImpl {
 public:
 
+    static v8::CFunction fast_start_raf_;
+
+    static v8::CFunction fast_stop_raf_;
+
     static v8::CFunction fast_draw_point_;
 
     static v8::CFunction fast_arc_;
@@ -121,6 +125,34 @@ class CanvasRenderingContext2DImpl : ObjectWrapperImpl {
 
     CanvasRenderingContext2DImpl(CanvasRenderingContext2D *context);
 
+    void StartRaf();
+
+    void StopRaf();
+
+    static void __StartRaf(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void __FastStartRaf(v8::Local<v8::Object> receiver_obj) {
+        CanvasRenderingContext2DImpl *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        ptr->StartRaf();
+
+    }
+
+    static void __StopRaf(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void __FastStopRaf(v8::Local<v8::Object> receiver_obj) {
+        CanvasRenderingContext2DImpl *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        ptr->StopRaf();
+
+    }
+
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
     static CanvasRenderingContext2DImpl *GetPointer(const v8::Local<v8::Object> &object);
@@ -163,6 +195,15 @@ class CanvasRenderingContext2DImpl : ObjectWrapperImpl {
 
     static void __Resize(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+
+    static void SetContinuousRenderMode(v8::Local<v8::String> property,
+                                        v8::Local<v8::Value> value,
+                                        const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetContinuousRenderMode(v8::Local<v8::String> property,
+                                        const v8::PropertyCallbackInfo<v8::Value> &info);
+
+
     static void GetFilter(v8::Local<v8::String> property,
                           const v8::PropertyCallbackInfo<v8::Value> &info);
 
@@ -489,18 +530,10 @@ class CanvasRenderingContext2DImpl : ObjectWrapperImpl {
 
         if (GetNativeType(path_obj) == NativeType::Path2D) {
             auto path = Path2D::GetPointer(path_obj);
-            switch (rule) {
-                case 0:
-                case 1:
-                    canvas_native_context_clip(
-                            ptr->GetContext(), path->GetPath(), rule);
-                    break;
-                default:
-                    break;
-            }
+            canvas_native_context_clip(
+                    ptr->GetContext(), path->GetPath(), rule);
         }
 
-
     }
 
     static void ClosePath(const v8::FunctionCallbackInfo<v8::Value> &args);
@@ -800,18 +833,10 @@ class CanvasRenderingContext2DImpl : ObjectWrapperImpl {
         auto object = Path2D::GetPointer(path);
 
         if (object != nullptr) {
-            switch (rule) {
-                case 0:
-                case 1:
-                    canvas_native_context_fill_with_path(
-                            ptr->GetContext(),
-                            object->GetPath(),
-                            rule);
-                    break;
-                default:
-                    break;
-            }
-
+            canvas_native_context_fill_with_path(
+                    ptr->GetContext(),
+                    object->GetPath(),
+                    rule);
             ptr->UpdateInvalidateState();
         }
     }
@@ -837,16 +862,9 @@ class CanvasRenderingContext2DImpl : ObjectWrapperImpl {
             return;
         }
 
-        switch (rule) {
-            case 0:
-            case 1:
-                canvas_native_context_fill(
-                        ptr->GetContext(), rule);
-                ptr->UpdateInvalidateState();
-                break;
-            default:
-                break;
-        }
+        canvas_native_context_fill(
+                ptr->GetContext(), rule);
+        ptr->UpdateInvalidateState();
     }
 
     static void FastFill(v8::Local<v8::Object> receiver_obj) {
@@ -907,18 +925,8 @@ class CanvasRenderingContext2DImpl : ObjectWrapperImpl {
             return false;
         }
 
-        bool ret = false;
-        switch (rule) {
-            case 0:
-            case 1:
-                ret = canvas_native_context_is_point_in_path(
-                        ptr->GetContext(), static_cast<float>(x), static_cast<float>(y), rule);
-                break;
-            default:
-                break;
-        }
-
-        return ret;
+        return canvas_native_context_is_point_in_path(
+                ptr->GetContext(), static_cast<float>(x), static_cast<float>(y), rule);
     }
 
     static bool
@@ -939,17 +947,9 @@ class CanvasRenderingContext2DImpl : ObjectWrapperImpl {
             auto path = Path2D::GetPointer(path_obj);
 
 
-            switch (rule) {
-                case 0:
-                case 1:
-                    ret = canvas_native_context_is_point_in_path_with_path(
-                            ptr->GetContext(),
-                            path->GetPath(), x, y, rule);
-                    break;
-                    break;
-                default:
-                    break;
-            }
+            ret = canvas_native_context_is_point_in_path_with_path(
+                    ptr->GetContext(),
+                    path->GetPath(), x, y, rule);
 
         }
         return ret;
@@ -1385,4 +1385,6 @@ class CanvasRenderingContext2DImpl : ObjectWrapperImpl {
 
     std::shared_ptr<RafImpl> raf_;
 
+    bool continuousRender_ = true;
+
 };
diff --git a/packages/canvas/platforms/ios/src/cpp/webgl/WebGLRenderingContext.cpp b/packages/canvas/platforms/ios/src/cpp/webgl/WebGLRenderingContext.cpp
index 56152a34..620e623f 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgl/WebGLRenderingContext.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgl/WebGLRenderingContext.cpp
@@ -6302,6 +6302,11 @@ WebGLRenderingContext::SetMethods(v8::Isolate *isolate, const v8::Local<v8::Obje
                   v8::Local<v8::Value>());
 
 
+
+    tmpl->SetAccessor(ConvertToV8String(isolate, "continuousRenderMode"), GetContinuousRenderMode,
+                      SetContinuousRenderMode);
+
+
     // todo
     tmpl->Set(ConvertToV8String(isolate, "__toDataURL"),
               v8::FunctionTemplate::New(isolate, &__ToDataURL));
diff --git a/packages/canvas/platforms/ios/src/cpp/webgl/WebGLRenderingContextBase.cpp b/packages/canvas/platforms/ios/src/cpp/webgl/WebGLRenderingContextBase.cpp
index b16a32bf..bd2c564c 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgl/WebGLRenderingContextBase.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgl/WebGLRenderingContextBase.cpp
@@ -7,8 +7,8 @@
 WebGLRenderingContextBase::WebGLRenderingContextBase(WebGLState* state,
                                                      WebGLRenderingVersion version)
 : state_(state), version_(version) {
-    
-    
+
+
     auto ctx_ptr = reinterpret_cast<intptr_t>(reinterpret_cast<intptr_t *>(this));
     auto raf_callback = new OnRafCallback(
                                           ctx_ptr,
@@ -19,13 +19,44 @@ WebGLRenderingContextBase::WebGLRenderingContextBase(WebGLState* state,
                  std::make_shared<RafImpl>(
                                            raf_callback,
                                            raf_callback_ptr, raf));
-    
+
     auto _raf = this->GetRaf();
-    
+
     if (_raf != nullptr) {
         canvas_native_raf_start(_raf->GetRaf());
     }
-    
+
+}
+
+
+void WebGLRenderingContextBase::GetContinuousRenderMode(v8::Local<v8::String> property,
+                                                           const v8::PropertyCallbackInfo<v8::Value> &info) {
+    WebGLRenderingContextBase *ptr = GetPointer(info.This());
+    if (ptr == nullptr) {
+        info.GetReturnValue().Set(false);
+        return;
+    }
+    info.GetReturnValue().Set(ptr->continuousRender_);
+}
+
+void WebGLRenderingContextBase::SetContinuousRenderMode(v8::Local<v8::String> property,
+                                                           v8::Local<v8::Value> value,
+                                                           const v8::PropertyCallbackInfo<void> &info) {
+    WebGLRenderingContextBase *ptr = GetPointer(info.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    auto isolate = info.GetIsolate();
+    auto val = value->BooleanValue(isolate);
+    if (val == ptr->continuousRender_) {
+        return;
+    }
+    if (val) {
+        ptr->StartRaf();
+    } else {
+        ptr->StopRaf();
+    }
+    ptr->continuousRender_ = val;
 }
 
 
@@ -64,8 +95,7 @@ void WebGLRenderingContextBase::Flush() {
     auto state = this->GetInvalidateState() & (int) InvalidateState::InvalidateStatePending;
     if (state == (int) InvalidateState::InvalidateStatePending) {
         this->SetInvalidateState((int) InvalidateState::InvalidateStateInvalidating);
-        canvas_native_webgl_make_current(this->GetState());
-        canvas_native_webgl_swap_buffers(this->GetState());
+        canvas_native_webgl_make_current_and_swap_buffers(this->GetState());
         this->SetInvalidateState((int) InvalidateState::InvalidateStateNone);
     }
 }
diff --git a/packages/canvas/platforms/ios/src/cpp/webgl/WebGLRenderingContextBase.h b/packages/canvas/platforms/ios/src/cpp/webgl/WebGLRenderingContextBase.h
index 63facfd7..f4f8b0c1 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgl/WebGLRenderingContextBase.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgl/WebGLRenderingContextBase.h
@@ -32,6 +32,14 @@ class WebGLRenderingContextBase: public ObjectWrapperImpl {
         return static_cast<WebGLRenderingContextBase *>(ptr);
     }
 
+
+    static void GetContinuousRenderMode(v8::Local<v8::String> property,
+                                                            const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetContinuousRenderMode(v8::Local<v8::String> property,
+                                                            v8::Local<v8::Value> value,
+                                                            const v8::PropertyCallbackInfo<void> &info);
+
     ~WebGLRenderingContextBase();
 
     void UpdateInvalidateState();
@@ -66,5 +74,7 @@ class WebGLRenderingContextBase: public ObjectWrapperImpl {
     int invalidateState_ = static_cast<int>(InvalidateState::InvalidateStateNone);
 
     std::shared_ptr<RafImpl> raf_;
+
+    bool continuousRender_ = true;
 };
 
diff --git a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/include/canvas_native.h b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/include/canvas_native.h
index f637f7f7..dd7575e4 100644
--- a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/include/canvas_native.h
+++ b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/include/canvas_native.h
@@ -9,91 +9,91 @@
 #include <stdlib.h>
 
 typedef enum GLConstants {
-  UNPACK_FLIP_Y_WEBGL = 37440,
-  UNPACK_PREMULTIPLY_ALPHA_WEBGL = 37441,
-  UNPACK_COLORSPACE_CONVERSION_WEBGL = 37443,
+    UNPACK_FLIP_Y_WEBGL = 37440,
+    UNPACK_PREMULTIPLY_ALPHA_WEBGL = 37441,
+    UNPACK_COLORSPACE_CONVERSION_WEBGL = 37443,
 } GLConstants;
 
 typedef enum ImageBitmapColorSpaceConversion {
-  ImageBitmapColorSpaceConversionDefault,
-  ImageBitmapColorSpaceConversionNone,
+    ImageBitmapColorSpaceConversionDefault,
+    ImageBitmapColorSpaceConversionNone,
 } ImageBitmapColorSpaceConversion;
 
 typedef enum ImageBitmapPremultiplyAlpha {
-  ImageBitmapPremultiplyAlphaDefault,
-  ImageBitmapPremultiplyAlphaPremultiply,
-  ImageBitmapPremultiplyAlphaNone,
+    ImageBitmapPremultiplyAlphaDefault,
+    ImageBitmapPremultiplyAlphaPremultiply,
+    ImageBitmapPremultiplyAlphaNone,
 } ImageBitmapPremultiplyAlpha;
 
 typedef enum ImageBitmapResizeQuality {
-  ImageBitmapResizeQualityLow,
-  ImageBitmapResizeQualityMedium,
-  ImageBitmapResizeQualityHigh,
-  ImageBitmapResizeQualityPixelated,
+    ImageBitmapResizeQualityLow,
+    ImageBitmapResizeQualityMedium,
+    ImageBitmapResizeQualityHigh,
+    ImageBitmapResizeQualityPixelated,
 } ImageBitmapResizeQuality;
 
 typedef enum InvalidateState {
-  InvalidateStateNone,
-  InvalidateStatePending,
-  InvalidateStateInvalidating,
+    InvalidateStateNone,
+    InvalidateStatePending,
+    InvalidateStateInvalidating,
 } InvalidateState;
 
 typedef enum PaintStyleType {
-  PaintStyleTypeNone,
-  PaintStyleTypeColor,
-  PaintStyleTypeGradient,
-  PaintStyleTypePattern,
+    PaintStyleTypeNone,
+    PaintStyleTypeColor,
+    PaintStyleTypeGradient,
+    PaintStyleTypePattern,
 } PaintStyleType;
 
 typedef enum TextBaseLine {
-  TOP = 0,
-  HANGING = 1,
-  MIDDLE = 2,
-  ALPHABETIC = 3,
-  IDEOGRAPHIC = 4,
-  BOTTOM = 5,
+    TOP = 0,
+    HANGING = 1,
+    MIDDLE = 2,
+    ALPHABETIC = 3,
+    IDEOGRAPHIC = 4,
+    BOTTOM = 5,
 } TextBaseLine;
 
 typedef enum WebGLExtensionType {
-  WebGLExtensionTypeEXT_blend_minmax,
-  WebGLExtensionTypeEXT_color_buffer_half_float,
-  WebGLExtensionTypeEXT_disjoint_timer_query,
-  WebGLExtensionTypeEXT_sRGB,
-  WebGLExtensionTypeEXT_shader_texture_lod,
-  WebGLExtensionTypeEXT_texture_filter_anisotropic,
-  WebGLExtensionTypeOES_element_index_uint,
-  WebGLExtensionTypeOES_standard_derivatives,
-  WebGLExtensionTypeOES_texture_float,
-  WebGLExtensionTypeOES_texture_float_linear,
-  WebGLExtensionTypeOES_texture_half_float,
-  WebGLExtensionTypeOES_texture_half_float_linear,
-  WebGLExtensionTypeOES_vertex_array_object,
-  WebGLExtensionTypeWEBGL_color_buffer_float,
-  WebGLExtensionTypeWEBGL_compressed_texture_atc,
-  WebGLExtensionTypeWEBGL_compressed_texture_etc1,
-  WebGLExtensionTypeWEBGL_compressed_texture_s3tc,
-  WebGLExtensionTypeWEBGL_compressed_texture_s3tc_srgb,
-  WebGLExtensionTypeWEBGL_compressed_texture_etc,
-  WebGLExtensionTypeWEBGL_compressed_texture_pvrtc,
-  WebGLExtensionTypeWEBGL_lose_context,
-  WebGLExtensionTypeANGLE_instanced_arrays,
-  WebGLExtensionTypeWEBGL_depth_texture,
-  WebGLExtensionTypeWEBGL_draw_buffers,
-  WebGLExtensionTypeOES_fbo_render_mipmap,
-  WebGLExtensionTypeNone,
+    WebGLExtensionTypeEXT_blend_minmax,
+    WebGLExtensionTypeEXT_color_buffer_half_float,
+    WebGLExtensionTypeEXT_disjoint_timer_query,
+    WebGLExtensionTypeEXT_sRGB,
+    WebGLExtensionTypeEXT_shader_texture_lod,
+    WebGLExtensionTypeEXT_texture_filter_anisotropic,
+    WebGLExtensionTypeOES_element_index_uint,
+    WebGLExtensionTypeOES_standard_derivatives,
+    WebGLExtensionTypeOES_texture_float,
+    WebGLExtensionTypeOES_texture_float_linear,
+    WebGLExtensionTypeOES_texture_half_float,
+    WebGLExtensionTypeOES_texture_half_float_linear,
+    WebGLExtensionTypeOES_vertex_array_object,
+    WebGLExtensionTypeWEBGL_color_buffer_float,
+    WebGLExtensionTypeWEBGL_compressed_texture_atc,
+    WebGLExtensionTypeWEBGL_compressed_texture_etc1,
+    WebGLExtensionTypeWEBGL_compressed_texture_s3tc,
+    WebGLExtensionTypeWEBGL_compressed_texture_s3tc_srgb,
+    WebGLExtensionTypeWEBGL_compressed_texture_etc,
+    WebGLExtensionTypeWEBGL_compressed_texture_pvrtc,
+    WebGLExtensionTypeWEBGL_lose_context,
+    WebGLExtensionTypeANGLE_instanced_arrays,
+    WebGLExtensionTypeWEBGL_depth_texture,
+    WebGLExtensionTypeWEBGL_draw_buffers,
+    WebGLExtensionTypeOES_fbo_render_mipmap,
+    WebGLExtensionTypeNone,
 } WebGLExtensionType;
 
 typedef enum WebGLResultType {
-  WebGLResultTypeBoolean,
-  WebGLResultTypeI32Array,
-  WebGLResultTypeU32Array,
-  WebGLResultTypeF32Array,
-  WebGLResultTypeBooleanArray,
-  WebGLResultTypeU32,
-  WebGLResultTypeI32,
-  WebGLResultTypeF32,
-  WebGLResultTypeString,
-  WebGLResultTypeNone,
+    WebGLResultTypeBoolean,
+    WebGLResultTypeI32Array,
+    WebGLResultTypeU32Array,
+    WebGLResultTypeF32Array,
+    WebGLResultTypeBooleanArray,
+    WebGLResultTypeU32,
+    WebGLResultTypeI32,
+    WebGLResultTypeF32,
+    WebGLResultTypeString,
+    WebGLResultTypeNone,
 } WebGLResultType;
 
 typedef struct ANGLE_instanced_arrays ANGLE_instanced_arrays;
@@ -1213,6 +1213,8 @@ bool canvas_native_webgl_make_current(struct WebGLState *state);
 
 bool canvas_native_webgl_swap_buffers(struct WebGLState *state);
 
+bool canvas_native_webgl_make_current_and_swap_buffers(struct WebGLState *state);
+
 void canvas_native_webgl_resized(struct WebGLState *_state);
 
 const char *canvas_native_webgl_to_data_url(struct WebGLState *state,
diff --git a/packages/canvas/src-native/canvas-ios/CanvasNative.xcodeproj/project.xcworkspace/xcuserdata/triniwiz.xcuserdatad/UserInterfaceState.xcuserstate b/packages/canvas/src-native/canvas-ios/CanvasNative.xcodeproj/project.xcworkspace/xcuserdata/triniwiz.xcuserdatad/UserInterfaceState.xcuserstate
index 77d1067c..edf5e027 100644
Binary files a/packages/canvas/src-native/canvas-ios/CanvasNative.xcodeproj/project.xcworkspace/xcuserdata/triniwiz.xcuserdatad/UserInterfaceState.xcuserstate and b/packages/canvas/src-native/canvas-ios/CanvasNative.xcodeproj/project.xcworkspace/xcuserdata/triniwiz.xcuserdatad/UserInterfaceState.xcuserstate differ
diff --git a/packages/canvas/src-native/canvas-ios/CanvasNative/include/canvas_native.h b/packages/canvas/src-native/canvas-ios/CanvasNative/include/canvas_native.h
index f637f7f7..e6720899 100644
--- a/packages/canvas/src-native/canvas-ios/CanvasNative/include/canvas_native.h
+++ b/packages/canvas/src-native/canvas-ios/CanvasNative/include/canvas_native.h
@@ -1213,6 +1213,8 @@ bool canvas_native_webgl_make_current(struct WebGLState *state);
 
 bool canvas_native_webgl_swap_buffers(struct WebGLState *state);
 
+bool canvas_native_webgl_make_current_and_swap_buffers(struct WebGLState *state);
+
 void canvas_native_webgl_resized(struct WebGLState *_state);
 
 const char *canvas_native_webgl_to_data_url(struct WebGLState *state,
diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/CanvasNative b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/CanvasNative
index 30f38072..2399ed9c 100755
Binary files a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/CanvasNative and b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/CanvasNative differ
diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/canvas_native.h b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/canvas_native.h
index f637f7f7..e6720899 100644
--- a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/canvas_native.h
+++ b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/canvas_native.h
@@ -1213,6 +1213,8 @@ bool canvas_native_webgl_make_current(struct WebGLState *state);
 
 bool canvas_native_webgl_swap_buffers(struct WebGLState *state);
 
+bool canvas_native_webgl_make_current_and_swap_buffers(struct WebGLState *state);
+
 void canvas_native_webgl_resized(struct WebGLState *_state);
 
 const char *canvas_native_webgl_to_data_url(struct WebGLState *state,
diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative
index b8447807..c32705fe 100644
Binary files a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative and b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative differ
diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/CanvasNative b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/CanvasNative
index 24d47efc..7e8c59c2 100755
Binary files a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/CanvasNative and b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/CanvasNative differ
diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/Headers/canvas_native.h b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/Headers/canvas_native.h
index f637f7f7..e6720899 100644
--- a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/Headers/canvas_native.h
+++ b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/Headers/canvas_native.h
@@ -1213,6 +1213,8 @@ bool canvas_native_webgl_make_current(struct WebGLState *state);
 
 bool canvas_native_webgl_swap_buffers(struct WebGLState *state);
 
+bool canvas_native_webgl_make_current_and_swap_buffers(struct WebGLState *state);
+
 void canvas_native_webgl_resized(struct WebGLState *_state);
 
 const char *canvas_native_webgl_to_data_url(struct WebGLState *state,
diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/_CodeSignature/CodeResources b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/_CodeSignature/CodeResources
index a32579bb..b4b234b8 100644
--- a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/_CodeSignature/CodeResources
+++ b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/_CodeSignature/CodeResources
@@ -18,7 +18,7 @@
 		</data>
 		<key>Headers/canvas_native.h</key>
 		<data>
-		XsX2QGyWWWRx+Re/2nxFcoBoMjg=
+		fHjKG7aDZ9ZVi79Vu9g8z8IS9lo=
 		</data>
 		<key>Info.plist</key>
 		<data>
@@ -108,7 +108,7 @@
 		<dict>
 			<key>hash2</key>
 			<data>
-			xQtVdm5vJz/Oga/nNrCvEeqLDQmYAbn6yURH5MwoH0k=
+			aufqGvTGgpXa9ipXAyNSFoJPEdAdB2J5O3Cf8sPHYMM=
 			</data>
 		</dict>
 		<key>Modules/CanvasNative.swiftmodule/Project/arm64-apple-ios-simulator.swiftsourceinfo</key>
diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative
index adac5bfd..b51a2704 100644
Binary files a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative and b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative differ
diff --git a/packages/canvas/src-native/canvas-native/canvas-2d/src/context/non_standard.rs b/packages/canvas/src-native/canvas-native/canvas-2d/src/context/non_standard.rs
index 777fefa4..adde11f8 100644
--- a/packages/canvas/src-native/canvas-native/canvas-2d/src/context/non_standard.rs
+++ b/packages/canvas/src-native/canvas-native/canvas-2d/src/context/non_standard.rs
@@ -1,9 +1,8 @@
-use std::os::raw::c_float;
+use std::os::raw::{c_float, c_ushort};
 
-use csscolorparser::Color;
-use skia_safe::paint::Style;
-use skia_safe::{BlendMode, Paint, Rect};
+use skia_safe::Paint;
 
+use crate::context::compositing::composite_operation_type::CompositeOperationType;
 use crate::context::Context;
 use crate::utils::color;
 
@@ -65,8 +64,8 @@ impl Context {
     pub fn draw_paint(&mut self, color: &str) {
         if let Some(color) = color::parse_color(color) {
             let mut paint = Paint::default();
-            paint.set_anti_alias(true);
-            paint.set_color(color);
+            paint.set_anti_alias(true)
+                .set_color(color);
             self.surface.canvas().draw_paint(&paint);
         }
     }
@@ -93,4 +92,44 @@ impl Context {
             );
         }
     }
+
+    pub fn draw_vertices(&mut self, vertices: &[c_float], mode: skia_safe::vertices::VertexMode, indices: &[c_ushort], textures: &[c_float], colors: &[&str], blend_mode: CompositeOperationType){
+        let positions: Vec<_> = vertices
+            .chunks(2)
+            .into_iter()
+            .map(|point| (point[0], point[1]).into())
+            .collect();
+
+        let texs: Vec<_> = textures
+            .chunks(2)
+            .into_iter()
+            .map(|point| (point[0], point[1]).into())
+            .collect();
+
+        let colors: Vec<_> = colors.iter()
+            .filter_map(|color| {
+                csscolorparser::Color::from_html(*color)
+                    .map(|color| {
+                        let color = color.rgba_u8();
+                        skia_safe::Color::from_argb(color.3, color.0, color.1, color.2)
+                    })
+                    .ok()
+            })
+            .collect();
+
+        if vertices.len() % 2 == 0 && textures.len() % 2 == 0 {
+            let v = skia_safe::vertices::Vertices::new_copy(
+                mode,
+                &positions,
+                &texs,
+                &colors,
+                if indices.is_empty() {
+                    None
+                }else { Some(indices)}
+            );
+            let mut paint = Paint::default();
+                paint.set_anti_alias(true);
+            self.surface.canvas().draw_vertices(&v, blend_mode.get_blend_mode(), &paint);
+        }
+    }
 }
diff --git a/packages/canvas/src-native/canvas-native/canvas-c/src/lib.rs b/packages/canvas/src-native/canvas-native/canvas-c/src/lib.rs
index aa55be99..f2cca078 100644
--- a/packages/canvas/src-native/canvas-native/canvas-c/src/lib.rs
+++ b/packages/canvas/src-native/canvas-native/canvas-c/src/lib.rs
@@ -4847,6 +4847,17 @@ pub extern "C" fn canvas_native_webgl_swap_buffers(state: *mut WebGLState) -> bo
     let state = unsafe { &mut *state };
     state.get_inner().swap_buffers()
 }
+
+
+
+#[no_mangle]
+pub extern "C" fn canvas_native_webgl_make_current_and_swap_buffers(state: *mut WebGLState) -> bool {
+    assert!(!state.is_null());
+    let state = unsafe { &mut *state };
+    state.get_inner().make_current_and_swap_buffers()
+}
+
+
 /* GL */
 
 /* WebGL */
diff --git a/packages/canvas/src-native/canvas-native/canvas-webgl/src/prelude.rs b/packages/canvas/src-native/canvas-native/canvas-webgl/src/prelude.rs
index 3840be32..a2ffe6ea 100644
--- a/packages/canvas/src-native/canvas-native/canvas-webgl/src/prelude.rs
+++ b/packages/canvas/src-native/canvas-native/canvas-webgl/src/prelude.rs
@@ -6,9 +6,6 @@ use std::cell::{Ref, RefCell, RefMut};
 use std::ffi::CString;
 use std::os::raw::c_void;
 use std::rc::Rc;
-use std::sync::Arc;
-
-use parking_lot::RawRwLock;
 
 use canvas_core::gl::GLContext;
 
@@ -407,10 +404,22 @@ impl WebGLState {
         self.get().gl_context.make_current()
     }
 
+    #[inline(always)]
     pub fn swap_buffers(&self) -> bool {
         self.get().gl_context.swap_buffers()
     }
 
+    #[inline(always)]
+    pub fn make_current_and_swap_buffers(&self) -> bool {
+        let current = self.get();
+        if !current.gl_context.make_current(){
+            return false;
+        }
+
+        return  current.gl_context.swap_buffers()
+    }
+
+
     pub fn remove_if_current(&self) {
         self.get().gl_context.remove_if_current();
     }
diff --git a/packages/canvas/src-native/canvas-native/canvas_native.h b/packages/canvas/src-native/canvas-native/canvas_native.h
index f637f7f7..e6720899 100644
--- a/packages/canvas/src-native/canvas-native/canvas_native.h
+++ b/packages/canvas/src-native/canvas-native/canvas_native.h
@@ -1213,6 +1213,8 @@ bool canvas_native_webgl_make_current(struct WebGLState *state);
 
 bool canvas_native_webgl_swap_buffers(struct WebGLState *state);
 
+bool canvas_native_webgl_make_current_and_swap_buffers(struct WebGLState *state);
+
 void canvas_native_webgl_resized(struct WebGLState *_state);
 
 const char *canvas_native_webgl_to_data_url(struct WebGLState *state,
diff --git a/tools/demo/canvas/canvas2d/lines.ts b/tools/demo/canvas/canvas2d/lines.ts
new file mode 100644
index 00000000..bfc4869e
--- /dev/null
+++ b/tools/demo/canvas/canvas2d/lines.ts
@@ -0,0 +1,90 @@
+import { Canvas } from '@nativescript/canvas';
+import { Screen } from '@nativescript/core';
+
+export function lines(c: Canvas) {
+	var w =  c.getMeasuredWidth()/ Screen.mainScreen.scale as number,
+		h = c.getMeasuredHeight()/ Screen.mainScreen.scale as number,
+		ctx = c.getContext('2d') as never as CanvasRenderingContext2D,
+		spawnProb = 1,
+		numberOfMoves = [8, 16], //[min, max]
+		distance = [50, 400],
+		attenuator = 30,
+		timeBetweenMoves = [4, 10],
+		lines = [] as any[],
+		frame = (Math.random() * 360) | 0;
+
+	ctx.lineWidth = 1;
+    
+
+  //  console.log(c.width, c.height, c.getMeasuredWidth(), c.getMeasuredHeight());
+
+	function rand(ar: any) {
+		return Math.random() * (ar[1] - ar[0]) + ar[0];
+	}
+	function Line() {
+		this.x = Math.random() * w;
+		this.y = Math.random() * h;
+		this.last = { x: 0, y: 0 };
+		this.target = { x: 0, y: 0 };
+		this.totalMoves = rand(numberOfMoves);
+		this.move = 0;
+		this.timeBetweenMoves = rand(timeBetweenMoves);
+		this.timeSpentThisMove = this.timeBetweenMoves;
+		this.distance = rand(distance);
+
+		this.color = `hsl(${frame % 360}, 80%, 50%)`;
+	}
+	Line.prototype.use = function () {
+		++this.timeSpentThisMove;
+		if (this.timeSpentThisMove >= this.timeBetweenMoves) {
+			++this.move;
+			this.timeSpentThisMove = 0;
+
+			var rad = Math.random() * 2 * Math.PI;
+			this.target.x = this.x + Math.cos(rad) * this.distance;
+			this.target.y = this.y + Math.sin(rad) * this.distance;
+		}
+
+		this.last.x = this.x;
+		this.last.y = this.y;
+
+		this.x += (this.x - this.target.x) / attenuator;
+		this.y += (this.y - this.target.y) / attenuator;
+
+		ctx.strokeStyle = this.color;
+		ctx.shadowColor = this.color;
+
+		ctx.beginPath();
+		ctx.moveTo(this.last.x, this.last.y);
+		ctx.lineTo(this.x, this.y);
+		ctx.stroke();
+	};
+
+	let start = 0;
+	function anim(now) {
+		if (start === 0) {
+			start = now;
+		}
+		frame = now - start + 1.5;
+		ctx.shadowBlur = 0;
+		ctx.fillStyle = 'rgba(0, 0, 0, .04)';
+		ctx.fillRect(0, 0, w, h);
+		ctx.shadowBlur = 10;
+
+		if (Math.random() < spawnProb) lines.push(new Line());
+
+		for (var i = 0; i < lines.length; ++i) {
+			const line = lines[i];
+			line.use();
+
+			if (line.move >= line.totalMoves) {
+				lines.splice(i, 1);
+				--i;
+			}
+		}
+
+		requestAnimationFrame(anim);
+	}
+
+	anim(0);
+}
diff --git a/tools/demo/canvas/index.ts b/tools/demo/canvas/index.ts
index 899065ea..d6eb939b 100644
--- a/tools/demo/canvas/index.ts
+++ b/tools/demo/canvas/index.ts
@@ -65,6 +65,7 @@ import { issue54, issue93 } from './issues';
 import { subTest } from './webgl/test';
 import { rnSkiaPerf } from './canvas2d/rn-skia-perf';
 import { breathe } from './canvas2d/breathe';
+import { lines } from './canvas2d/lines';
 var Vex;
 export class DemoSharedCanvas extends DemoSharedBase {
 	private canvas: any;
@@ -552,6 +553,67 @@ export class DemoSharedCanvas extends DemoSharedBase {
 		});
 	}
 
+	pathIssue(canvas) {
+		const d = [
+			[100, 68],
+			[109.40456403667957, 87.05572809000084],
+			[130.43380852144492, 90.11145618000168],
+			[115.21690426072246, 104.94427190999916],
+			[118.80912807335915, 125.88854381999832],
+			[100, 116],
+			[81.19087192664087, 125.88854381999832],
+			[84.78309573927754, 104.94427190999916],
+			[69.56619147855508, 90.1114561800017],
+			[90.59543596332043, 87.05572809000084],
+		];
+		function drawStarWithCoords(ctx) {
+			ctx.beginPath();
+			ctx.moveTo(d[0][0], d[0][1]);
+			for (let i = 1; i < d.length; i++) {
+				ctx.lineTo(d[i][0], d[i][1]);
+			}
+			ctx.closePath();
+			ctx.fill();
+		}
+
+		function drawStar(ctx, fetti: { x: number; y: number; scalar: number }) {
+			var rot = (Math.PI / 2) * 3;
+			var innerRadius = 4 * fetti.scalar;
+			var outerRadius = 8 * fetti.scalar;
+			var x = fetti.x;
+			var y = fetti.y;
+			var spikes = 5;
+			var step = Math.PI / spikes;
+			ctx.beginPath();
+			while (spikes--) {
+				x = fetti.x + Math.cos(rot) * outerRadius;
+				y = fetti.y + Math.sin(rot) * outerRadius;
+				ctx.lineTo(x, y);
+
+				rot += step;
+
+				x = fetti.x + Math.cos(rot) * innerRadius;
+				y = fetti.y + Math.sin(rot) * innerRadius;
+
+				ctx.lineTo(x, y);
+				rot += step;
+			}
+
+			ctx.closePath();
+			ctx.fill();
+		}
+
+		const ctx = canvas.getContext('2d') as CanvasRenderingContext2D;
+
+		ctx.clearRect(0, 0, canvas.width, canvas.height);
+
+		ctx.fillStyle = 'red';
+		drawStar(ctx, { x: 100, y: 200, scalar: 4 });
+
+		ctx.fillStyle = 'blue';
+		drawStarWithCoords(ctx);
+	}
+
 	fillIssue(canvas) {
 		const ctx = canvas.getContext('2d') as CanvasRenderingContext2D;
 		ctx.beginPath();
@@ -569,8 +631,10 @@ export class DemoSharedCanvas extends DemoSharedBase {
 		ctx.clearRect(0, 0, canvas.width, canvas.height);
 	}
 	draw() {
+		this.pathIssue(this.canvas);
+		//lines(this.canvas);
 		//this.clearIssue(this.canvas);
-		this.fillIssue(this.canvas);
+		//this.fillIssue(this.canvas);
 		//rnSkiaPerf(this.canvas);
 		//breathe(this.canvas);
 		///this.drawOnCanvasWithCanvas(this.canvas);