diff --git a/demos/vector_graphic/lv_demo_vector_graphic.c b/demos/vector_graphic/lv_demo_vector_graphic.c
index 24958b4db6..ec1f2283a3 100644
--- a/demos/vector_graphic/lv_demo_vector_graphic.c
+++ b/demos/vector_graphic/lv_demo_vector_graphic.c
@@ -23,10 +23,10 @@
 /**********************
  *  STATIC PROTOTYPES
  **********************/
-static void draw_pattern(lv_vector_dsc_t * ctx, lv_vector_path_t * path)
+static void draw_pattern(lv_draw_vector_dsc_t * ctx, lv_vector_path_t * path)
 {
     lv_vector_path_clear(path);
-    lv_vector_dsc_identity(ctx);
+    lv_draw_vector_dsc_identity(ctx);
 
     lv_fpoint_t pts[] = {{200, 200}, {300, 200}, {300, 300}, {200, 300}};
     lv_vector_path_move_to(path, &pts[0]);
@@ -41,17 +41,17 @@ static void draw_pattern(lv_vector_dsc_t * ctx, lv_vector_path_t * path)
     img_dsc.header = img_demo_vector_avatar.header;
     img_dsc.src = &img_demo_vector_avatar;
 
-    lv_vector_dsc_set_fill_image(ctx, &img_dsc);
-    lv_vector_dsc_translate(ctx, 250, 250);
-    lv_vector_dsc_rotate(ctx, 25);
-    lv_vector_dsc_translate(ctx, -250, -250);
-    lv_vector_dsc_add_path(ctx, path); // draw a path
+    lv_draw_vector_dsc_set_fill_image(ctx, &img_dsc);
+    lv_draw_vector_dsc_translate(ctx, 250, 250);
+    lv_draw_vector_dsc_rotate(ctx, 25);
+    lv_draw_vector_dsc_translate(ctx, -250, -250);
+    lv_draw_vector_dsc_add_path(ctx, path); // draw a path
 }
 
-static void draw_gradient(lv_vector_dsc_t * ctx, lv_vector_path_t * path)
+static void draw_gradient(lv_draw_vector_dsc_t * ctx, lv_vector_path_t * path)
 {
     lv_vector_path_clear(path);
-    lv_vector_dsc_identity(ctx);
+    lv_draw_vector_dsc_identity(ctx);
 
     lv_fpoint_t pts[] = {{400, 200}, {600, 200}, {400, 400}};
     lv_vector_path_move_to(path, &pts[0]);
@@ -70,18 +70,18 @@ static void draw_gradient(lv_vector_dsc_t * ctx, lv_vector_path_t * path)
     lv_matrix_t mt;
     lv_matrix_identity(&mt);
     lv_matrix_rotate(&mt, 30);
-    lv_vector_dsc_set_fill_transform(ctx, &mt);
+    lv_draw_vector_dsc_set_fill_transform(ctx, &mt);
 
-    lv_vector_dsc_set_fill_linear_gradient(ctx, 200, 200, 400, 400);
-    lv_vector_dsc_set_fill_gradient_color_stops(ctx, stops, 2);
-    lv_vector_dsc_set_fill_gradient_spread(ctx, LV_VECTOR_GRADIENT_SPREAD_PAD);
-    lv_vector_dsc_add_path(ctx, path); // draw a path
+    lv_draw_vector_dsc_set_fill_linear_gradient(ctx, 200, 200, 400, 400);
+    lv_draw_vector_dsc_set_fill_gradient_color_stops(ctx, stops, 2);
+    lv_draw_vector_dsc_set_fill_gradient_spread(ctx, LV_VECTOR_GRADIENT_SPREAD_PAD);
+    lv_draw_vector_dsc_add_path(ctx, path); // draw a path
 }
 
-static void draw_radial_gradient(lv_vector_dsc_t * ctx, lv_vector_path_t * path)
+static void draw_radial_gradient(lv_draw_vector_dsc_t * ctx, lv_vector_path_t * path)
 {
     lv_vector_path_clear(path);
-    lv_vector_dsc_identity(ctx);
+    lv_draw_vector_dsc_identity(ctx);
 
     lv_fpoint_t pts[] = {{400, 50}, {500, 50}, {500, 200}, {400, 200}};
     lv_vector_path_move_to(path, &pts[0]);
@@ -99,107 +99,107 @@ static void draw_radial_gradient(lv_vector_dsc_t * ctx, lv_vector_path_t * path)
     stops[1].opa = LV_OPA_COVER;
     stops[1].frac = 255;
 
-    lv_vector_dsc_set_fill_radial_gradient(ctx, 450, 100, 20);
-    lv_vector_dsc_set_fill_gradient_color_stops(ctx, stops, 2);
-    lv_vector_dsc_set_fill_gradient_spread(ctx, LV_VECTOR_GRADIENT_SPREAD_REFLECT);
-    lv_vector_dsc_add_path(ctx, path); // draw a path
+    lv_draw_vector_dsc_set_fill_radial_gradient(ctx, 450, 100, 20);
+    lv_draw_vector_dsc_set_fill_gradient_color_stops(ctx, stops, 2);
+    lv_draw_vector_dsc_set_fill_gradient_spread(ctx, LV_VECTOR_GRADIENT_SPREAD_REFLECT);
+    lv_draw_vector_dsc_add_path(ctx, path); // draw a path
 }
 
-static void draw_shapes(lv_vector_dsc_t * ctx, lv_vector_path_t * path)
+static void draw_shapes(lv_draw_vector_dsc_t * ctx, lv_vector_path_t * path)
 {
     lv_vector_path_clear(path);
-    lv_vector_dsc_identity(ctx);
+    lv_draw_vector_dsc_identity(ctx);
 
     lv_fpoint_t pts[] = {{50, 50}, {200, 200}, {50, 200}};
     lv_vector_path_move_to(path, &pts[0]);
     lv_vector_path_line_to(path, &pts[1]);
     lv_vector_path_line_to(path, &pts[2]);
     lv_vector_path_close(path);
-    lv_vector_dsc_set_fill_color(ctx, lv_color_make(0xFF, 0x00, 0x00));
-    lv_vector_dsc_scale(ctx, 0.5, 0.5);
-    lv_vector_dsc_add_path(ctx, path); // draw a path
+    lv_draw_vector_dsc_set_fill_color(ctx, lv_color_make(0xFF, 0x00, 0x00));
+    lv_draw_vector_dsc_scale(ctx, 0.5, 0.5);
+    lv_draw_vector_dsc_add_path(ctx, path); // draw a path
 
     lv_vector_path_clear(path);
-    lv_vector_dsc_identity(ctx);
+    lv_draw_vector_dsc_identity(ctx);
 
     lv_area_t rect = {300, 300, 400, 400};
     lv_vector_path_append_rect(path, &rect, 50, 60);
-    lv_vector_dsc_set_fill_color(ctx, lv_color_make(0x00, 0x80, 0xff));
-    lv_vector_dsc_skew(ctx, 5, 0);
-    lv_vector_dsc_add_path(ctx, path); // draw a path
+    lv_draw_vector_dsc_set_fill_color(ctx, lv_color_make(0x00, 0x80, 0xff));
+    lv_draw_vector_dsc_skew(ctx, 5, 0);
+    lv_draw_vector_dsc_add_path(ctx, path); // draw a path
 
     lv_vector_path_clear(path);
-    lv_vector_dsc_identity(ctx);
+    lv_draw_vector_dsc_identity(ctx);
 
     lv_area_t rect2 = {100, 300, 200, 400};
     lv_vector_path_append_rect(path, &rect2, 10, 10);
-    lv_vector_dsc_set_fill_color(ctx, lv_color_make(0x80, 0x00, 0x80));
+    lv_draw_vector_dsc_set_fill_color(ctx, lv_color_make(0x80, 0x00, 0x80));
 
     lv_vector_path_t * path2 = lv_vector_path_create(LV_VECTOR_PATH_QUALITY_MEDIUM);
     lv_fpoint_t p = {50, 420};
     lv_vector_path_append_circle(path2, &p, 50, 30);
     lv_vector_path_append_path(path, path2);
 
-    lv_vector_dsc_add_path(ctx, path); // draw a path
+    lv_draw_vector_dsc_add_path(ctx, path); // draw a path
 
     lv_vector_path_delete(path2);
 }
 
-static void draw_lines(lv_vector_dsc_t * ctx, lv_vector_path_t * path)
+static void draw_lines(lv_draw_vector_dsc_t * ctx, lv_vector_path_t * path)
 {
     lv_vector_path_clear(path);
-    lv_vector_dsc_identity(ctx);
+    lv_draw_vector_dsc_identity(ctx);
 
     lv_fpoint_t pts[] = {{50, 50}, {200, 200}, {250, 300}, {350, 150}};
 
     lv_vector_path_move_to(path, &pts[0]);
     lv_vector_path_cubic_to(path, &pts[1], &pts[2], &pts[3]);
 
-    lv_vector_dsc_set_stroke_color(ctx, lv_color_make(0x00, 0xff, 0x00));
-    lv_vector_dsc_set_stroke_opa(ctx, LV_OPA_COVER);
-    lv_vector_dsc_set_fill_opa(ctx, LV_OPA_0);
-    lv_vector_dsc_set_stroke_width(ctx, 8.0f);
+    lv_draw_vector_dsc_set_stroke_color(ctx, lv_color_make(0x00, 0xff, 0x00));
+    lv_draw_vector_dsc_set_stroke_opa(ctx, LV_OPA_COVER);
+    lv_draw_vector_dsc_set_fill_opa(ctx, LV_OPA_0);
+    lv_draw_vector_dsc_set_stroke_width(ctx, 8.0f);
 
     float dashes[] = {10, 15, 20, 12};
-    lv_vector_dsc_set_stroke_dash(ctx, dashes, 4);
+    lv_draw_vector_dsc_set_stroke_dash(ctx, dashes, 4);
 
-    lv_vector_dsc_add_path(ctx, path); // draw a path
+    lv_draw_vector_dsc_add_path(ctx, path); // draw a path
 
-    lv_vector_dsc_set_stroke_opa(ctx, LV_OPA_0);
-    lv_vector_dsc_set_fill_opa(ctx, LV_OPA_COVER);
+    lv_draw_vector_dsc_set_stroke_opa(ctx, LV_OPA_0);
+    lv_draw_vector_dsc_set_fill_opa(ctx, LV_OPA_COVER);
 }
 
-static void draw_blend(lv_vector_dsc_t * ctx, lv_vector_path_t * path)
+static void draw_blend(lv_draw_vector_dsc_t * ctx, lv_vector_path_t * path)
 {
     lv_vector_path_clear(path);
-    lv_vector_dsc_identity(ctx);
+    lv_draw_vector_dsc_identity(ctx);
 
     lv_fpoint_t pts[] = {{200, 200}, {400, 200}, {450, 350}, {350, 150}};
 
     lv_vector_path_move_to(path, &pts[0]);
     lv_vector_path_cubic_to(path, &pts[1], &pts[2], &pts[3]);
     lv_vector_path_close(path);
-    lv_vector_dsc_set_fill_color(ctx, lv_color_make(0xFF, 0x00, 0xFF));
-    lv_vector_dsc_set_blend_mode(ctx, LV_VECTOR_BLEND_SCREEN);
+    lv_draw_vector_dsc_set_fill_color(ctx, lv_color_make(0xFF, 0x00, 0xFF));
+    lv_draw_vector_dsc_set_blend_mode(ctx, LV_VECTOR_BLEND_SCREEN);
 
-    lv_vector_dsc_add_path(ctx, path); // draw a path
+    lv_draw_vector_dsc_add_path(ctx, path); // draw a path
 }
 
-static void draw_arc(lv_vector_dsc_t * ctx, lv_vector_path_t * path)
+static void draw_arc(lv_draw_vector_dsc_t * ctx, lv_vector_path_t * path)
 {
     lv_vector_path_clear(path);
-    lv_vector_dsc_identity(ctx);
+    lv_draw_vector_dsc_identity(ctx);
 
     lv_area_t rect = {100, 0, 150, 50};
-    lv_vector_dsc_set_fill_color(ctx, lv_color_lighten(lv_color_black(), 50));
-    lv_vector_clear_area(ctx, &rect); // clear screen
+    lv_draw_vector_dsc_set_fill_color(ctx, lv_color_lighten(lv_color_black(), 50));
+    lv_draw_vector_dsc_clear_area(ctx, &rect); // clear screen
 
     lv_fpoint_t p = {100, 50}; /* Center */
-    lv_vector_dsc_set_stroke_color(ctx, lv_color_make(0x00, 0xff, 0xff));
-    lv_vector_dsc_set_stroke_opa(ctx, LV_OPA_COVER);
-    lv_vector_dsc_set_stroke_width(ctx, 2.0f);
-    lv_vector_dsc_set_stroke_dash(ctx, NULL, 0);
-    lv_vector_dsc_set_fill_color32(ctx, lv_color32_make(0xFF, 0x00, 0x00, 0x80));
+    lv_draw_vector_dsc_set_stroke_color(ctx, lv_color_make(0x00, 0xff, 0xff));
+    lv_draw_vector_dsc_set_stroke_opa(ctx, LV_OPA_COVER);
+    lv_draw_vector_dsc_set_stroke_width(ctx, 2.0f);
+    lv_draw_vector_dsc_set_stroke_dash(ctx, NULL, 0);
+    lv_draw_vector_dsc_set_fill_color32(ctx, lv_color32_make(0xFF, 0x00, 0x00, 0x80));
 
     lv_vector_path_move_to(path, &p);
     lv_fpoint_t temp = {p.x + 50, p.y};
@@ -208,21 +208,21 @@ static void draw_arc(lv_vector_dsc_t * ctx, lv_vector_path_t * path)
     lv_vector_path_line_to(path, &p);
     lv_vector_path_close(path);
 
-    lv_vector_dsc_add_path(ctx, path);
+    lv_draw_vector_dsc_add_path(ctx, path);
 
     /* Below code has same effect as above one. */
     lv_vector_path_clear(path);
     lv_vector_path_append_arc(path, &p, 50, 45, 45, true);
-    lv_vector_dsc_add_path(ctx, path); // draw a path
+    lv_draw_vector_dsc_add_path(ctx, path); // draw a path
 }
 
 static void draw_vector(lv_layer_t * layer)
 {
-    lv_vector_dsc_t * ctx = lv_vector_dsc_create(layer);
+    lv_draw_vector_dsc_t * ctx = lv_draw_vector_dsc_create(layer);
 
     lv_area_t rect = {0, 100, 300, 300};
-    lv_vector_dsc_set_fill_color(ctx, lv_color_lighten(lv_color_black(), 50));
-    lv_vector_clear_area(ctx, &rect); // clear screen
+    lv_draw_vector_dsc_set_fill_color(ctx, lv_color_lighten(lv_color_black(), 50));
+    lv_draw_vector_dsc_clear_area(ctx, &rect); // clear screen
 
     lv_vector_path_t * path = lv_vector_path_create(LV_VECTOR_PATH_QUALITY_MEDIUM);
 
@@ -235,7 +235,7 @@ static void draw_vector(lv_layer_t * layer)
     draw_arc(ctx, path);
     lv_draw_vector(ctx); // submit draw
     lv_vector_path_delete(path);
-    lv_vector_dsc_delete(ctx);
+    lv_draw_vector_dsc_delete(ctx);
 }
 
 static void delete_event_cb(lv_event_t * e)
diff --git a/examples/widgets/canvas/lv_example_canvas_8.c b/examples/widgets/canvas/lv_example_canvas_8.c
index ef8675f782..878ae0ced4 100644
--- a/examples/widgets/canvas/lv_example_canvas_8.c
+++ b/examples/widgets/canvas/lv_example_canvas_8.c
@@ -24,7 +24,7 @@ void lv_example_canvas_8(void)
     lv_layer_t layer;
     lv_canvas_init_layer(canvas, &layer);
 
-    lv_vector_dsc_t * dsc = lv_vector_dsc_create(&layer);
+    lv_draw_vector_dsc_t * dsc = lv_draw_vector_dsc_create(&layer);
     lv_vector_path_t * path = lv_vector_path_create(LV_VECTOR_PATH_QUALITY_MEDIUM);
 
     lv_fpoint_t pts[] = {{10, 10}, {130, 130}, {10, 130}};
@@ -33,12 +33,12 @@ void lv_example_canvas_8(void)
     lv_vector_path_line_to(path, &pts[2]);
     lv_vector_path_close(path);
 
-    lv_vector_dsc_set_fill_color(dsc, lv_color_make(0x00, 0x80, 0xff));
-    lv_vector_dsc_add_path(dsc, path);
+    lv_draw_vector_dsc_set_fill_color(dsc, lv_color_make(0x00, 0x80, 0xff));
+    lv_draw_vector_dsc_add_path(dsc, path);
 
     lv_draw_vector(dsc);
     lv_vector_path_delete(path);
-    lv_vector_dsc_delete(dsc);
+    lv_draw_vector_dsc_delete(dsc);
 
     lv_canvas_finish_layer(canvas, &layer);
 }
diff --git a/src/draw/lv_draw.c b/src/draw/lv_draw.c
index f925094625..24eecdadb6 100644
--- a/src/draw/lv_draw.c
+++ b/src/draw/lv_draw.c
@@ -613,7 +613,7 @@ static inline size_t get_draw_dsc_size(lv_draw_task_type_t type)
             return 0;
 #if LV_USE_VECTOR_GRAPHIC
         case LV_DRAW_TASK_TYPE_VECTOR:
-            return sizeof(lv_draw_vector_task_dsc_t);
+            return sizeof(lv_draw_vector_dsc_t);
 #endif
 #if LV_USE_3DTEXTURE
         case LV_DRAW_TASK_TYPE_3D:
diff --git a/src/draw/lv_draw_vector.c b/src/draw/lv_draw_vector.c
index bf4b307e1c..1d5a7e0486 100644
--- a/src/draw/lv_draw_vector.c
+++ b/src/draw/lv_draw_vector.c
@@ -54,16 +54,11 @@
  *      TYPEDEFS
  **********************/
 
-typedef struct {
-    lv_vector_path_t * path;
-    lv_vector_draw_dsc_t dsc;
-} lv_vector_draw_task;
-
 /**********************
  *  STATIC PROTOTYPES
  **********************/
 
-static void _copy_draw_dsc(lv_vector_draw_dsc_t * dst, const lv_vector_draw_dsc_t * src)
+static void _copy_draw_dsc(lv_vector_path_ctx_t * dst, const lv_vector_path_ctx_t * src)
 {
     lv_memcpy(&(dst->fill_dsc), &(src->fill_dsc), sizeof(lv_vector_fill_dsc_t));
 
@@ -82,6 +77,8 @@ static void _copy_draw_dsc(lv_vector_draw_dsc_t * dst, const lv_vector_draw_dsc_
     lv_memcpy(&(dst->matrix), &(src->matrix), sizeof(lv_matrix_t));
     lv_area_copy(&(dst->scissor_area), &(src->scissor_area));
 }
+
+
 /**********************
  *   GLOBAL FUNCTIONS
  **********************/
@@ -627,22 +624,33 @@ void lv_vector_path_append_path(lv_vector_path_t * path, const lv_vector_path_t
 
 /* draw dsc functions */
 
-lv_vector_dsc_t * lv_vector_dsc_create(lv_layer_t * layer)
+lv_draw_vector_dsc_t * lv_draw_vector_dsc_create(lv_layer_t * layer)
 {
-    lv_vector_dsc_t * dsc = lv_malloc(sizeof(lv_vector_dsc_t));
+
+    lv_draw_vector_dsc_t * dsc = lv_zalloc(sizeof(lv_draw_vector_dsc_t));
     LV_ASSERT_MALLOC(dsc);
-    lv_memzero(dsc, sizeof(lv_vector_dsc_t));
+    if(dsc == NULL) {
+        LV_LOG_WARN("Couldn't allocate lv_draw_vector_dsc_t");
+        return NULL;
+    }
 
-    dsc->layer = layer;
+    dsc->base.layer = layer;
 
-    lv_vector_fill_dsc_t * fill_dsc = &(dsc->current_dsc.fill_dsc);
+    dsc->ctx = lv_zalloc(sizeof(lv_vector_path_ctx_t));
+    if(dsc->ctx == NULL) {
+        LV_LOG_WARN("Couldn't allocate vector path context");
+        lv_free(dsc);
+        return NULL;
+    }
+
+    lv_vector_fill_dsc_t * fill_dsc = &(dsc->ctx->fill_dsc);
     fill_dsc->style = LV_VECTOR_DRAW_STYLE_SOLID;
     fill_dsc->color = lv_color_to_32(lv_color_black(), 0xFF);
     fill_dsc->opa = LV_OPA_COVER;
     fill_dsc->fill_rule = LV_VECTOR_FILL_NONZERO;
     lv_matrix_identity(&(fill_dsc->matrix)); /*identity matrix*/
 
-    lv_vector_stroke_dsc_t * stroke_dsc = &(dsc->current_dsc.stroke_dsc);
+    lv_vector_stroke_dsc_t * stroke_dsc = &(dsc->ctx->stroke_dsc);
     stroke_dsc->style = LV_VECTOR_DRAW_STYLE_SOLID;
     stroke_dsc->color = lv_color_to_32(lv_color_black(), 0xFF);
     stroke_dsc->opa = LV_OPA_0; /*default no stroke*/
@@ -652,138 +660,139 @@ lv_vector_dsc_t * lv_vector_dsc_create(lv_layer_t * layer)
     stroke_dsc->miter_limit = 4.0f;
     lv_matrix_identity(&(stroke_dsc->matrix)); /*identity matrix*/
 
-    dsc->current_dsc.blend_mode = LV_VECTOR_BLEND_SRC_OVER;
-    dsc->current_dsc.scissor_area = layer->_clip_area;
-    lv_matrix_identity(&(dsc->current_dsc.matrix)); /*identity matrix*/
-    dsc->tasks.task_list = NULL;
+    dsc->ctx->blend_mode = LV_VECTOR_BLEND_SRC_OVER;
+    dsc->ctx->scissor_area = layer->_clip_area;
+    lv_matrix_identity(&(dsc->ctx->matrix)); /*identity matrix*/
+    dsc->task_list = NULL;
     return dsc;
 }
 
-void lv_vector_dsc_delete(lv_vector_dsc_t * dsc)
+void lv_draw_vector_dsc_delete(lv_draw_vector_dsc_t * dsc)
 {
-    if(dsc->tasks.task_list) {
-        lv_ll_t * task_list = dsc->tasks.task_list;
+    if(dsc->task_list) {
+        lv_ll_t * task_list = dsc->task_list;
         lv_vector_for_each_destroy_tasks(task_list, NULL, NULL);
-        dsc->tasks.task_list = NULL;
+        dsc->task_list = NULL;
     }
-    lv_array_deinit(&(dsc->current_dsc.stroke_dsc.dash_pattern));
+    lv_array_deinit(&(dsc->ctx->stroke_dsc.dash_pattern));
+    lv_free(dsc->ctx);
     lv_free(dsc);
 }
 
-void lv_vector_dsc_set_blend_mode(lv_vector_dsc_t * dsc, lv_vector_blend_t blend)
+void lv_draw_vector_dsc_set_blend_mode(lv_draw_vector_dsc_t * dsc, lv_vector_blend_t blend)
 {
-    dsc->current_dsc.blend_mode = blend;
+    dsc->ctx->blend_mode = blend;
 }
 
-void lv_vector_dsc_set_transform(lv_vector_dsc_t * dsc, const lv_matrix_t * matrix)
+void lv_draw_vector_dsc_set_transform(lv_draw_vector_dsc_t * dsc, const lv_matrix_t * matrix)
 {
-    lv_memcpy(&(dsc->current_dsc.matrix), matrix, sizeof(lv_matrix_t));
+    lv_memcpy(&(dsc->ctx->matrix), matrix, sizeof(lv_matrix_t));
 }
 
-void lv_vector_dsc_set_fill_color(lv_vector_dsc_t * dsc, lv_color_t color)
+void lv_draw_vector_dsc_set_fill_color(lv_draw_vector_dsc_t * dsc, lv_color_t color)
 {
-    dsc->current_dsc.fill_dsc.style = LV_VECTOR_DRAW_STYLE_SOLID;
-    dsc->current_dsc.fill_dsc.color = lv_color_to_32(color, 0xFF);
+    dsc->ctx->fill_dsc.style = LV_VECTOR_DRAW_STYLE_SOLID;
+    dsc->ctx->fill_dsc.color = lv_color_to_32(color, 0xFF);
 }
 
-void lv_vector_dsc_set_fill_color32(lv_vector_dsc_t * dsc, lv_color32_t color)
+void lv_draw_vector_dsc_set_fill_color32(lv_draw_vector_dsc_t * dsc, lv_color32_t color)
 {
-    dsc->current_dsc.fill_dsc.style = LV_VECTOR_DRAW_STYLE_SOLID;
-    dsc->current_dsc.fill_dsc.color = color;
+    dsc->ctx->fill_dsc.style = LV_VECTOR_DRAW_STYLE_SOLID;
+    dsc->ctx->fill_dsc.color = color;
 }
 
-void lv_vector_dsc_set_fill_opa(lv_vector_dsc_t * dsc, lv_opa_t opa)
+void lv_draw_vector_dsc_set_fill_opa(lv_draw_vector_dsc_t * dsc, lv_opa_t opa)
 {
-    dsc->current_dsc.fill_dsc.opa = opa;
+    dsc->ctx->fill_dsc.opa = opa;
 }
 
-void lv_vector_dsc_set_fill_rule(lv_vector_dsc_t * dsc, lv_vector_fill_t rule)
+void lv_draw_vector_dsc_set_fill_rule(lv_draw_vector_dsc_t * dsc, lv_vector_fill_t rule)
 {
-    dsc->current_dsc.fill_dsc.fill_rule = rule;
+    dsc->ctx->fill_dsc.fill_rule = rule;
 }
 
-void lv_vector_dsc_set_fill_units(lv_vector_dsc_t * dsc, const lv_vector_fill_units_t units)
+void lv_draw_vector_dsc_set_fill_units(lv_draw_vector_dsc_t * dsc, const lv_vector_fill_units_t units)
 {
-    dsc->current_dsc.fill_dsc.fill_units = units;
+    dsc->ctx->fill_dsc.fill_units = units;
 }
 
-void lv_vector_dsc_set_fill_image(lv_vector_dsc_t * dsc, const lv_draw_image_dsc_t * img_dsc)
+void lv_draw_vector_dsc_set_fill_image(lv_draw_vector_dsc_t * dsc, const lv_draw_image_dsc_t * img_dsc)
 {
-    dsc->current_dsc.fill_dsc.style = LV_VECTOR_DRAW_STYLE_PATTERN;
-    lv_memcpy(&(dsc->current_dsc.fill_dsc.img_dsc), img_dsc, sizeof(lv_draw_image_dsc_t));
+    dsc->ctx->fill_dsc.style = LV_VECTOR_DRAW_STYLE_PATTERN;
+    lv_memcpy(&(dsc->ctx->fill_dsc.img_dsc), img_dsc, sizeof(lv_draw_image_dsc_t));
 }
 
-void lv_vector_dsc_set_fill_linear_gradient(lv_vector_dsc_t * dsc, float x1, float y1, float x2, float y2)
+void lv_draw_vector_dsc_set_fill_linear_gradient(lv_draw_vector_dsc_t * dsc, float x1, float y1, float x2, float y2)
 {
-    dsc->current_dsc.fill_dsc.style = LV_VECTOR_DRAW_STYLE_GRADIENT;
-    dsc->current_dsc.fill_dsc.gradient.style = LV_VECTOR_GRADIENT_STYLE_LINEAR;
-    dsc->current_dsc.fill_dsc.gradient.x1 = x1;
-    dsc->current_dsc.fill_dsc.gradient.y1 = y1;
-    dsc->current_dsc.fill_dsc.gradient.x2 = x2;
-    dsc->current_dsc.fill_dsc.gradient.y2 = y2;
+    dsc->ctx->fill_dsc.style = LV_VECTOR_DRAW_STYLE_GRADIENT;
+    dsc->ctx->fill_dsc.gradient.style = LV_VECTOR_GRADIENT_STYLE_LINEAR;
+    dsc->ctx->fill_dsc.gradient.x1 = x1;
+    dsc->ctx->fill_dsc.gradient.y1 = y1;
+    dsc->ctx->fill_dsc.gradient.x2 = x2;
+    dsc->ctx->fill_dsc.gradient.y2 = y2;
 }
 
-void lv_vector_dsc_set_fill_radial_gradient(lv_vector_dsc_t * dsc, float cx, float cy, float radius)
+void lv_draw_vector_dsc_set_fill_radial_gradient(lv_draw_vector_dsc_t * dsc, float cx, float cy, float radius)
 {
-    dsc->current_dsc.fill_dsc.style = LV_VECTOR_DRAW_STYLE_GRADIENT;
-    dsc->current_dsc.fill_dsc.gradient.style = LV_VECTOR_GRADIENT_STYLE_RADIAL;
-    dsc->current_dsc.fill_dsc.gradient.cx = cx;
-    dsc->current_dsc.fill_dsc.gradient.cy = cy;
-    dsc->current_dsc.fill_dsc.gradient.cr = radius;
+    dsc->ctx->fill_dsc.style = LV_VECTOR_DRAW_STYLE_GRADIENT;
+    dsc->ctx->fill_dsc.gradient.style = LV_VECTOR_GRADIENT_STYLE_RADIAL;
+    dsc->ctx->fill_dsc.gradient.cx = cx;
+    dsc->ctx->fill_dsc.gradient.cy = cy;
+    dsc->ctx->fill_dsc.gradient.cr = radius;
 }
 
-void lv_vector_dsc_set_fill_gradient_spread(lv_vector_dsc_t * dsc, lv_vector_gradient_spread_t spread)
+void lv_draw_vector_dsc_set_fill_gradient_spread(lv_draw_vector_dsc_t * dsc, lv_vector_gradient_spread_t spread)
 {
-    dsc->current_dsc.fill_dsc.gradient.spread = spread;
+    dsc->ctx->fill_dsc.gradient.spread = spread;
 }
 
-void lv_vector_dsc_set_fill_gradient_color_stops(lv_vector_dsc_t * dsc, const lv_grad_stop_t * stops,
-                                                 uint16_t count)
+void lv_draw_vector_dsc_set_fill_gradient_color_stops(lv_draw_vector_dsc_t * dsc, const lv_grad_stop_t * stops,
+                                                      uint16_t count)
 {
     if(count > LV_GRADIENT_MAX_STOPS) {
         LV_LOG_WARN("Gradient stops limited: %d, max: %d", count, LV_GRADIENT_MAX_STOPS);
         count = LV_GRADIENT_MAX_STOPS;
     }
 
-    lv_memcpy(&(dsc->current_dsc.fill_dsc.gradient.stops), stops, sizeof(lv_grad_stop_t) * count);
-    dsc->current_dsc.fill_dsc.gradient.stops_count = count;
+    lv_memcpy(&(dsc->ctx->fill_dsc.gradient.stops), stops, sizeof(lv_grad_stop_t) * count);
+    dsc->ctx->fill_dsc.gradient.stops_count = count;
 }
 
-void lv_vector_dsc_set_fill_transform(lv_vector_dsc_t * dsc, const lv_matrix_t * matrix)
+void lv_draw_vector_dsc_set_fill_transform(lv_draw_vector_dsc_t * dsc, const lv_matrix_t * matrix)
 {
-    lv_memcpy(&(dsc->current_dsc.fill_dsc.matrix), matrix, sizeof(lv_matrix_t));
+    lv_memcpy(&(dsc->ctx->fill_dsc.matrix), matrix, sizeof(lv_matrix_t));
 }
 
-void lv_vector_dsc_set_stroke_transform(lv_vector_dsc_t * dsc, const lv_matrix_t * matrix)
+void lv_draw_vector_dsc_set_stroke_transform(lv_draw_vector_dsc_t * dsc, const lv_matrix_t * matrix)
 {
-    lv_memcpy(&(dsc->current_dsc.stroke_dsc.matrix), matrix, sizeof(lv_matrix_t));
+    lv_memcpy(&(dsc->ctx->stroke_dsc.matrix), matrix, sizeof(lv_matrix_t));
 }
 
-void lv_vector_dsc_set_stroke_color32(lv_vector_dsc_t * dsc, lv_color32_t color)
+void lv_draw_vector_dsc_set_stroke_color32(lv_draw_vector_dsc_t * dsc, lv_color32_t color)
 {
-    dsc->current_dsc.stroke_dsc.style = LV_VECTOR_DRAW_STYLE_SOLID;
-    dsc->current_dsc.stroke_dsc.color = color;
+    dsc->ctx->stroke_dsc.style = LV_VECTOR_DRAW_STYLE_SOLID;
+    dsc->ctx->stroke_dsc.color = color;
 }
 
-void lv_vector_dsc_set_stroke_color(lv_vector_dsc_t * dsc, lv_color_t color)
+void lv_draw_vector_dsc_set_stroke_color(lv_draw_vector_dsc_t * dsc, lv_color_t color)
 {
-    dsc->current_dsc.stroke_dsc.style = LV_VECTOR_DRAW_STYLE_SOLID;
-    dsc->current_dsc.stroke_dsc.color = lv_color_to_32(color, 0xFF);
+    dsc->ctx->stroke_dsc.style = LV_VECTOR_DRAW_STYLE_SOLID;
+    dsc->ctx->stroke_dsc.color = lv_color_to_32(color, 0xFF);
 }
 
-void lv_vector_dsc_set_stroke_opa(lv_vector_dsc_t * dsc, lv_opa_t opa)
+void lv_draw_vector_dsc_set_stroke_opa(lv_draw_vector_dsc_t * dsc, lv_opa_t opa)
 {
-    dsc->current_dsc.stroke_dsc.opa = opa;
+    dsc->ctx->stroke_dsc.opa = opa;
 }
 
-void lv_vector_dsc_set_stroke_width(lv_vector_dsc_t * dsc, float width)
+void lv_draw_vector_dsc_set_stroke_width(lv_draw_vector_dsc_t * dsc, float width)
 {
-    dsc->current_dsc.stroke_dsc.width = width;
+    dsc->ctx->stroke_dsc.width = width;
 }
 
-void lv_vector_dsc_set_stroke_dash(lv_vector_dsc_t * dsc, float * dash_pattern, uint16_t dash_count)
+void lv_draw_vector_dsc_set_stroke_dash(lv_draw_vector_dsc_t * dsc, float * dash_pattern, uint16_t dash_count)
 {
-    lv_array_t * dash_array = &(dsc->current_dsc.stroke_dsc.dash_pattern);
+    lv_array_t * dash_array = &(dsc->ctx->stroke_dsc.dash_pattern);
     if(dash_pattern) {
         lv_array_clear(dash_array);
         if(lv_array_capacity(dash_array) == 0) {
@@ -801,90 +810,90 @@ void lv_vector_dsc_set_stroke_dash(lv_vector_dsc_t * dsc, float * dash_pattern,
     }
 }
 
-void lv_vector_dsc_set_stroke_cap(lv_vector_dsc_t * dsc, lv_vector_stroke_cap_t cap)
+void lv_draw_vector_dsc_set_stroke_cap(lv_draw_vector_dsc_t * dsc, lv_vector_stroke_cap_t cap)
 {
-    dsc->current_dsc.stroke_dsc.cap = cap;
+    dsc->ctx->stroke_dsc.cap = cap;
 }
 
-void lv_vector_dsc_set_stroke_join(lv_vector_dsc_t * dsc, lv_vector_stroke_join_t join)
+void lv_draw_vector_dsc_set_stroke_join(lv_draw_vector_dsc_t * dsc, lv_vector_stroke_join_t join)
 {
-    dsc->current_dsc.stroke_dsc.join = join;
+    dsc->ctx->stroke_dsc.join = join;
 }
 
-void lv_vector_dsc_set_stroke_miter_limit(lv_vector_dsc_t * dsc, uint16_t miter_limit)
+void lv_draw_vector_dsc_set_stroke_miter_limit(lv_draw_vector_dsc_t * dsc, uint16_t miter_limit)
 {
-    dsc->current_dsc.stroke_dsc.miter_limit = miter_limit;
+    dsc->ctx->stroke_dsc.miter_limit = miter_limit;
 }
 
-void lv_vector_dsc_set_stroke_linear_gradient(lv_vector_dsc_t * dsc, float x1, float y1, float x2, float y2)
+void lv_draw_vector_dsc_set_stroke_linear_gradient(lv_draw_vector_dsc_t * dsc, float x1, float y1, float x2, float y2)
 {
-    dsc->current_dsc.stroke_dsc.style = LV_VECTOR_DRAW_STYLE_GRADIENT;
-    dsc->current_dsc.stroke_dsc.gradient.style = LV_VECTOR_GRADIENT_STYLE_LINEAR;
-    dsc->current_dsc.stroke_dsc.gradient.x1 = x1;
-    dsc->current_dsc.stroke_dsc.gradient.y1 = y1;
-    dsc->current_dsc.stroke_dsc.gradient.x2 = x2;
-    dsc->current_dsc.stroke_dsc.gradient.y2 = y2;
+    dsc->ctx->stroke_dsc.style = LV_VECTOR_DRAW_STYLE_GRADIENT;
+    dsc->ctx->stroke_dsc.gradient.style = LV_VECTOR_GRADIENT_STYLE_LINEAR;
+    dsc->ctx->stroke_dsc.gradient.x1 = x1;
+    dsc->ctx->stroke_dsc.gradient.y1 = y1;
+    dsc->ctx->stroke_dsc.gradient.x2 = x2;
+    dsc->ctx->stroke_dsc.gradient.y2 = y2;
 }
 
-void lv_vector_dsc_set_stroke_radial_gradient(lv_vector_dsc_t * dsc, float cx, float cy, float radius)
+void lv_draw_vector_dsc_set_stroke_radial_gradient(lv_draw_vector_dsc_t * dsc, float cx, float cy, float radius)
 {
-    dsc->current_dsc.stroke_dsc.style = LV_VECTOR_DRAW_STYLE_GRADIENT;
-    dsc->current_dsc.stroke_dsc.gradient.style = LV_VECTOR_GRADIENT_STYLE_RADIAL;
-    dsc->current_dsc.stroke_dsc.gradient.cx = cx;
-    dsc->current_dsc.stroke_dsc.gradient.cy = cy;
-    dsc->current_dsc.stroke_dsc.gradient.cr = radius;
+    dsc->ctx->stroke_dsc.style = LV_VECTOR_DRAW_STYLE_GRADIENT;
+    dsc->ctx->stroke_dsc.gradient.style = LV_VECTOR_GRADIENT_STYLE_RADIAL;
+    dsc->ctx->stroke_dsc.gradient.cx = cx;
+    dsc->ctx->stroke_dsc.gradient.cy = cy;
+    dsc->ctx->stroke_dsc.gradient.cr = radius;
 }
 
-void lv_vector_dsc_set_stroke_gradient_spread(lv_vector_dsc_t * dsc, lv_vector_gradient_spread_t spread)
+void lv_draw_vector_dsc_set_stroke_gradient_spread(lv_draw_vector_dsc_t * dsc, lv_vector_gradient_spread_t spread)
 {
-    dsc->current_dsc.stroke_dsc.gradient.spread = spread;
+    dsc->ctx->stroke_dsc.gradient.spread = spread;
 }
 
-void lv_vector_dsc_set_stroke_gradient_color_stops(lv_vector_dsc_t * dsc, const lv_grad_stop_t * stops,
-                                                   uint16_t count)
+void lv_draw_vector_dsc_set_stroke_gradient_color_stops(lv_draw_vector_dsc_t * dsc, const lv_grad_stop_t * stops,
+                                                        uint16_t count)
 {
     if(count > LV_GRADIENT_MAX_STOPS) {
         LV_LOG_WARN("Gradient stops limited: %d, max: %d", count, LV_GRADIENT_MAX_STOPS);
         count = LV_GRADIENT_MAX_STOPS;
     }
 
-    lv_memcpy(&(dsc->current_dsc.stroke_dsc.gradient.stops), stops, sizeof(lv_grad_stop_t) * count);
-    dsc->current_dsc.stroke_dsc.gradient.stops_count = count;
+    lv_memcpy(&(dsc->ctx->stroke_dsc.gradient.stops), stops, sizeof(lv_grad_stop_t) * count);
+    dsc->ctx->stroke_dsc.gradient.stops_count = count;
 }
 
 /* draw functions */
-void lv_vector_dsc_add_path(lv_vector_dsc_t * dsc, const lv_vector_path_t * path)
+void lv_draw_vector_dsc_add_path(lv_draw_vector_dsc_t * dsc, const lv_vector_path_t * path)
 {
     lv_area_t rect;
-    if(!lv_area_intersect(&rect, &(dsc->layer->_clip_area), &(dsc->current_dsc.scissor_area))) {
+    if(!lv_area_intersect(&rect, &(dsc->base.layer->_clip_area), &(dsc->ctx->scissor_area))) {
         return;
     }
 
-    if(dsc->current_dsc.fill_dsc.opa == 0
-       && dsc->current_dsc.stroke_dsc.opa == 0) {
+    if(dsc->ctx->fill_dsc.opa == 0
+       && dsc->ctx->stroke_dsc.opa == 0) {
         return;
     }
 
-    if(!dsc->tasks.task_list) {
-        dsc->tasks.task_list = lv_malloc(sizeof(lv_ll_t));
-        LV_ASSERT_MALLOC(dsc->tasks.task_list);
-        lv_ll_init(dsc->tasks.task_list, sizeof(lv_vector_draw_task));
+    if(!dsc->task_list) {
+        dsc->task_list = lv_malloc(sizeof(lv_ll_t));
+        LV_ASSERT_MALLOC(dsc->task_list);
+        lv_ll_init(dsc->task_list, sizeof(lv_draw_vector_subtask_t));
     }
 
-    lv_vector_draw_task * new_task = (lv_vector_draw_task *)lv_ll_ins_tail(dsc->tasks.task_list);
-    lv_memset(new_task, 0, sizeof(lv_vector_draw_task));
+    lv_draw_vector_subtask_t * new_task = (lv_draw_vector_subtask_t *)lv_ll_ins_tail(dsc->task_list);
+    lv_memset(new_task, 0, sizeof(lv_draw_vector_subtask_t));
 
     new_task->path = lv_vector_path_create(0);
 
-    _copy_draw_dsc(&(new_task->dsc), &(dsc->current_dsc));
+    _copy_draw_dsc(&(new_task->ctx), dsc->ctx);
     lv_vector_path_copy(new_task->path, path);
-    new_task->dsc.scissor_area = rect;
+    new_task->ctx.scissor_area = rect;
 }
 
-void lv_vector_clear_area(lv_vector_dsc_t * dsc, const lv_area_t * rect)
+void lv_draw_vector_dsc_clear_area(lv_draw_vector_dsc_t * dsc, const lv_area_t * rect)
 {
     lv_area_t r;
-    if(!lv_area_intersect(&r, &(dsc->layer->_clip_area), &(dsc->current_dsc.scissor_area))) {
+    if(!lv_area_intersect(&r, &(dsc->base.layer->_clip_area), &(dsc->ctx->scissor_area))) {
         return;
     }
 
@@ -893,83 +902,89 @@ void lv_vector_clear_area(lv_vector_dsc_t * dsc, const lv_area_t * rect)
         return;
     }
 
-    if(!dsc->tasks.task_list) {
-        dsc->tasks.task_list = lv_malloc(sizeof(lv_ll_t));
-        LV_ASSERT_MALLOC(dsc->tasks.task_list);
-        lv_ll_init(dsc->tasks.task_list, sizeof(lv_vector_draw_task));
+    if(!dsc->task_list) {
+        dsc->task_list = lv_malloc(sizeof(lv_ll_t));
+        LV_ASSERT_MALLOC(dsc->task_list);
+        lv_ll_init(dsc->task_list, sizeof(lv_draw_vector_subtask_t));
     }
 
-    lv_vector_draw_task * new_task = (lv_vector_draw_task *)lv_ll_ins_tail(dsc->tasks.task_list);
-    lv_memset(new_task, 0, sizeof(lv_vector_draw_task));
+    lv_draw_vector_subtask_t * new_task = (lv_draw_vector_subtask_t *)lv_ll_ins_tail(dsc->task_list);
+    lv_memset(new_task, 0, sizeof(lv_draw_vector_subtask_t));
 
-    new_task->dsc.fill_dsc.color = dsc->current_dsc.fill_dsc.color;
-    new_task->dsc.fill_dsc.opa = dsc->current_dsc.fill_dsc.opa;
-    lv_area_copy(&(new_task->dsc.scissor_area), &final_rect);
+    new_task->ctx.fill_dsc.color = dsc->ctx->fill_dsc.color;
+    new_task->ctx.fill_dsc.opa = dsc->ctx->fill_dsc.opa;
+    lv_area_copy(&(new_task->ctx.scissor_area), &final_rect);
 }
 
-void lv_draw_vector(lv_vector_dsc_t * dsc)
+void lv_draw_vector(lv_draw_vector_dsc_t * dsc)
 {
-    if(!dsc->tasks.task_list) {
+    if(!dsc->task_list) {
         return;
     }
 
-    lv_layer_t * layer = dsc->layer;
+    lv_layer_t * layer = dsc->base.layer;
 
     lv_draw_task_t * t = lv_draw_add_task(layer, &(layer->_clip_area), LV_DRAW_TASK_TYPE_VECTOR);
-    lv_memcpy(t->draw_dsc, &(dsc->tasks), sizeof(lv_draw_vector_task_dsc_t));
+    lv_memcpy(t->draw_dsc, dsc, sizeof(lv_draw_vector_dsc_t));
     lv_draw_finalize_task_creation(layer, t);
-    dsc->tasks.task_list = NULL;
+    dsc->task_list = NULL;
 }
 
 /* draw dsc transform */
-void lv_vector_dsc_identity(lv_vector_dsc_t * dsc)
+void lv_draw_vector_dsc_identity(lv_draw_vector_dsc_t * dsc)
 {
-    lv_matrix_identity(&(dsc->current_dsc.matrix)); /*identity matrix*/
+    lv_matrix_identity(&(dsc->ctx->matrix)); /*identity matrix*/
 }
 
-void lv_vector_dsc_scale(lv_vector_dsc_t * dsc, float scale_x, float scale_y)
+void lv_draw_vector_dsc_scale(lv_draw_vector_dsc_t * dsc, float scale_x, float scale_y)
 {
-    lv_matrix_scale(&(dsc->current_dsc.matrix), scale_x, scale_y);
+    lv_matrix_scale(&(dsc->ctx->matrix), scale_x, scale_y);
 }
 
-void lv_vector_dsc_rotate(lv_vector_dsc_t * dsc, float degree)
+void lv_draw_vector_dsc_rotate(lv_draw_vector_dsc_t * dsc, float degree)
 {
-    lv_matrix_rotate(&(dsc->current_dsc.matrix), degree);
+    lv_matrix_rotate(&(dsc->ctx->matrix), degree);
 }
 
-void lv_vector_dsc_translate(lv_vector_dsc_t * dsc, float tx, float ty)
+void lv_draw_vector_dsc_translate(lv_draw_vector_dsc_t * dsc, float tx, float ty)
 {
-    lv_matrix_translate(&(dsc->current_dsc.matrix), tx, ty);
+    lv_matrix_translate(&(dsc->ctx->matrix), tx, ty);
 }
 
-void lv_vector_dsc_skew(lv_vector_dsc_t * dsc, float skew_x, float skew_y)
+void lv_draw_vector_dsc_skew(lv_draw_vector_dsc_t * dsc, float skew_x, float skew_y)
 {
-    lv_matrix_skew(&(dsc->current_dsc.matrix), skew_x, skew_y);
+    lv_matrix_skew(&(dsc->ctx->matrix), skew_x, skew_y);
 }
 
 void lv_vector_for_each_destroy_tasks(lv_ll_t * task_list, vector_draw_task_cb cb, void * data)
 {
     if(task_list == NULL) return;
 
-    lv_vector_draw_task * task = lv_ll_get_head(task_list);
-    lv_vector_draw_task * next_task = NULL;
+    lv_draw_vector_subtask_t * task = lv_ll_get_head(task_list);
+    lv_draw_vector_subtask_t * next_task = NULL;
 
     while(task != NULL) {
         next_task = lv_ll_get_next(task_list, task);
         lv_ll_remove(task_list, task);
 
         if(cb) {
-            cb(data, task->path, &(task->dsc));
+            cb(data, task->path, &task->ctx);
         }
 
         if(task->path) {
             lv_vector_path_delete(task->path);
         }
-        lv_array_deinit(&(task->dsc.stroke_dsc.dash_pattern));
+        lv_array_deinit(&(task->ctx.stroke_dsc.dash_pattern));
 
         lv_free(task);
         task = next_task;
     }
     lv_free(task_list);
 }
+
+lv_draw_vector_dsc_t * lv_draw_task_get_vector_dsc(lv_draw_task_t * task)
+{
+    return task->type == LV_DRAW_TASK_TYPE_VECTOR ? (lv_draw_vector_dsc_t *)task->draw_dsc : NULL;
+}
+
 #endif /* LV_USE_VECTOR_GRAPHIC */
diff --git a/src/draw/lv_draw_vector.h b/src/draw/lv_draw_vector.h
index f62b9945fc..c7e6d3bfee 100644
--- a/src/draw/lv_draw_vector.h
+++ b/src/draw/lv_draw_vector.h
@@ -182,7 +182,8 @@ void lv_vector_path_cubic_to(lv_vector_path_t * path, const lv_fpoint_t * p1, co
  * @param clockwise         true for clockwise, otherwise anticlockwise
  * @param p                 pointer to a `lv_fpoint_t` variable for end point
  */
-void lv_vector_path_arc_to(lv_vector_path_t * path, float radius_x, float radius_y, float rotate_angle, bool large_arc,
+void lv_vector_path_arc_to(lv_vector_path_t * path, float radius_x, float radius_y, float rotate_angle,
+                           bool large_arc,
                            bool clockwise, const lv_fpoint_t * p);
 
 /**
@@ -259,272 +260,309 @@ void lv_vector_path_append_path(lv_vector_path_t * path, const lv_vector_path_t
  * @param layer         pointer to a layer
  * @return              pointer to the created descriptor
  */
-lv_vector_dsc_t * lv_vector_dsc_create(lv_layer_t * layer);
+lv_draw_vector_dsc_t * lv_draw_vector_dsc_create(lv_layer_t * layer);
 
 /**
  * Delete the vector graphic descriptor
  * @param dsc              pointer to a vector graphic descriptor
  */
-void lv_vector_dsc_delete(lv_vector_dsc_t * dsc);
+void lv_draw_vector_dsc_delete(lv_draw_vector_dsc_t * dsc);
 
 /**
- * Set a matrix to current transformation matrix
+ * Set a matrix to current transformation matrix.
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this matrix.
  * @param dsc              pointer to a vector graphic descriptor
  * @param matrix           pointer to a matrix
  */
-void lv_vector_dsc_set_transform(lv_vector_dsc_t * dsc, const lv_matrix_t * matrix);
+void lv_draw_vector_dsc_set_transform(lv_draw_vector_dsc_t * dsc, const lv_matrix_t * matrix);
 
 /**
- * Set blend mode for descriptor
+ * Set blend mode for descriptor.
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this blend mode.
  * @param dsc              pointer to a vector graphic descriptor
  * @param blend            the blend mode to be set in `lv_vector_blend_t`
  */
-void lv_vector_dsc_set_blend_mode(lv_vector_dsc_t * dsc, lv_vector_blend_t blend);
+void lv_draw_vector_dsc_set_blend_mode(lv_draw_vector_dsc_t * dsc, lv_vector_blend_t blend);
 
 /**
- * Set fill color for descriptor
+ * Set the fill color for descriptor.
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this color.
  * @param dsc              pointer to a vector graphic descriptor
  * @param color            the color to be set in lv_color32_t format
  */
-void lv_vector_dsc_set_fill_color32(lv_vector_dsc_t * dsc, lv_color32_t color);
+void lv_draw_vector_dsc_set_fill_color32(lv_draw_vector_dsc_t * dsc, lv_color32_t color);
 
 /**
- * Set fill color for descriptor
+ * Set fill color for descriptor.
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this color.
  * @param dsc              pointer to a vector graphic descriptor
  * @param color            the color to be set in lv_color_t format
  */
-void lv_vector_dsc_set_fill_color(lv_vector_dsc_t * dsc, lv_color_t color);
+void lv_draw_vector_dsc_set_fill_color(lv_draw_vector_dsc_t * dsc, lv_color_t color);
 
 /**
- * Set fill opacity for descriptor
+ * Set fill opacity for descriptor.
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this opacity.
  * @param dsc              pointer to a vector graphic descriptor
  * @param opa              the opacity to be set in lv_opa_t format
  */
-void lv_vector_dsc_set_fill_opa(lv_vector_dsc_t * dsc, lv_opa_t opa);
+void lv_draw_vector_dsc_set_fill_opa(lv_draw_vector_dsc_t * dsc, lv_opa_t opa);
 
 /**
- * Set fill rule for descriptor
+ * Set fill rule for descriptor.
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this fill rule.
  * @param dsc              pointer to a vector graphic descriptor
  * @param rule             the fill rule to be set in lv_vector_fill_t format
  */
-void lv_vector_dsc_set_fill_rule(lv_vector_dsc_t * dsc, lv_vector_fill_t rule);
+void lv_draw_vector_dsc_set_fill_rule(lv_draw_vector_dsc_t * dsc, lv_vector_fill_t rule);
 
 /**
  * Set the fill units for descriptor.
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this fill units.
  * @param dsc              pointer to a vector graphic descriptor
  * @param units            the units to be set in lv_vector_fill_units_t format
  * @note The units can be either relative to the object bounding box or absolute in user space.
  *       This API specifically affects the drawing position of the fill image and does not impact other elements.
  */
-void lv_vector_dsc_set_fill_units(lv_vector_dsc_t * dsc, const lv_vector_fill_units_t units);
+void lv_draw_vector_dsc_set_fill_units(lv_draw_vector_dsc_t * dsc, const lv_vector_fill_units_t units);
 
 /**
- * Set fill image for descriptor
+ * Set fill image for descriptor.
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this fill image.
  * @param dsc              pointer to a vector graphic descriptor
  * @param img_dsc          pointer to a `lv_draw_image_dsc_t` variable
  */
-void lv_vector_dsc_set_fill_image(lv_vector_dsc_t * dsc, const lv_draw_image_dsc_t * img_dsc);
+void lv_draw_vector_dsc_set_fill_image(lv_draw_vector_dsc_t * dsc, const lv_draw_image_dsc_t * img_dsc);
 
 /**
  * Set fill linear gradient for descriptor
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this gradient.
  * @param dsc pointer to a vector graphic descriptor
  * @param x1 the x for start point
  * @param y1 the y for start point
  * @param x2 the x for end point
  * @param y2 the y for end point
  */
-void lv_vector_dsc_set_fill_linear_gradient(lv_vector_dsc_t * dsc, float x1, float y1, float x2, float y2);
+void lv_draw_vector_dsc_set_fill_linear_gradient(lv_draw_vector_dsc_t * dsc, float x1, float y1, float x2, float y2);
 
 /**
 
  * Set fill radial gradient radius for descriptor
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this gradient.
  * @param dsc pointer to a vector graphic descriptor
  * @param cx the x for center of the circle
  * @param cy the y for center of the circle
  * @param radius the radius for circle
  */
-void lv_vector_dsc_set_fill_radial_gradient(lv_vector_dsc_t * dsc, float cx, float cy, float radius);
+void lv_draw_vector_dsc_set_fill_radial_gradient(lv_draw_vector_dsc_t * dsc, float cx, float cy, float radius);
 
 /**
  * Set fill radial gradient spread for descriptor
  * @param dsc pointer to a vector graphic descriptor
  * @param spread the gradient spread to be set in lv_vector_gradient_spread_t format
  */
-void lv_vector_dsc_set_fill_gradient_spread(lv_vector_dsc_t * dsc, lv_vector_gradient_spread_t spread);
+void lv_draw_vector_dsc_set_fill_gradient_spread(lv_draw_vector_dsc_t * dsc, lv_vector_gradient_spread_t spread);
 
 /**
- * Set fill gradient color stops for descriptor
+ * Set fill gradient color stops for descriptor.
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this gradient color stops.
  * @param dsc              pointer to a vector graphic descriptor
  * @param stops            an array of `lv_grad_stop_t` variables
  * @param count            the number of stops in the array, range: 0..LV_GRADIENT_MAX_STOPS
  */
-void lv_vector_dsc_set_fill_gradient_color_stops(lv_vector_dsc_t * dsc, const lv_grad_stop_t * stops,
-                                                 uint16_t count);
+void lv_draw_vector_dsc_set_fill_gradient_color_stops(lv_draw_vector_dsc_t * dsc, const lv_grad_stop_t * stops,
+                                                      uint16_t count);
 
 /**
  * Set a matrix to current fill transformation matrix
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this matrix.
  * @param dsc              pointer to a vector graphic descriptor
  * @param matrix           pointer to a matrix
  */
-void lv_vector_dsc_set_fill_transform(lv_vector_dsc_t * dsc, const lv_matrix_t * matrix);
+void lv_draw_vector_dsc_set_fill_transform(lv_draw_vector_dsc_t * dsc, const lv_matrix_t * matrix);
 
 /**
- * Set stroke color for descriptor
+ * Set stroke color for descriptor.
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this color.
  * @param dsc              pointer to a vector graphic descriptor
  * @param color            the color to be set in lv_color32_t format
  */
-void lv_vector_dsc_set_stroke_color32(lv_vector_dsc_t * dsc, lv_color32_t color);
+void lv_draw_vector_dsc_set_stroke_color32(lv_draw_vector_dsc_t * dsc, lv_color32_t color);
 
 /**
- * Set stroke color for descriptor
+ * Set stroke color for descriptor.
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this color.
  * @param dsc              pointer to a vector graphic descriptor
  * @param color            the color to be set in lv_color_t format
  */
-void lv_vector_dsc_set_stroke_color(lv_vector_dsc_t * dsc, lv_color_t color);
+void lv_draw_vector_dsc_set_stroke_color(lv_draw_vector_dsc_t * dsc, lv_color_t color);
 
 /**
  * Set stroke opacity for descriptor
  * @param dsc              pointer to a vector graphic descriptor
  * @param opa              the opacity to be set in lv_opa_t format
  */
-void lv_vector_dsc_set_stroke_opa(lv_vector_dsc_t * dsc, lv_opa_t opa);
+void lv_draw_vector_dsc_set_stroke_opa(lv_draw_vector_dsc_t * dsc, lv_opa_t opa);
 
 /**
- * Set stroke line width for descriptor
+ * Set stroke line width for descriptor.
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this stroke width.
  * @param dsc              pointer to a vector graphic descriptor
  * @param width            the stroke line width
  */
-void lv_vector_dsc_set_stroke_width(lv_vector_dsc_t * dsc, float width);
+void lv_draw_vector_dsc_set_stroke_width(lv_draw_vector_dsc_t * dsc, float width);
 
 /**
  * Set stroke line dash pattern for descriptor
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this dash.
  * @param dsc              pointer to a vector graphic descriptor
  * @param dash_pattern     an array of values that specify the segments of dash line
  * @param dash_count       the length of dash pattern array
  */
-void lv_vector_dsc_set_stroke_dash(lv_vector_dsc_t * dsc, float * dash_pattern, uint16_t dash_count);
+void lv_draw_vector_dsc_set_stroke_dash(lv_draw_vector_dsc_t * dsc, float * dash_pattern, uint16_t dash_count);
 
 /**
  * Set stroke line cap style for descriptor
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this line cap.
  * @param dsc              pointer to a vector graphic descriptor
  * @param cap              the line cap to be set in lv_vector_stroke_cap_t format
  */
-void lv_vector_dsc_set_stroke_cap(lv_vector_dsc_t * dsc, lv_vector_stroke_cap_t cap);
+void lv_draw_vector_dsc_set_stroke_cap(lv_draw_vector_dsc_t * dsc, lv_vector_stroke_cap_t cap);
 
 /**
  * Set stroke line join style for descriptor
  * @param dsc              pointer to a vector graphic descriptor
  * @param join             the line join to be set in lv_vector_stroke_join_t format
  */
-void lv_vector_dsc_set_stroke_join(lv_vector_dsc_t * dsc, lv_vector_stroke_join_t join);
+void lv_draw_vector_dsc_set_stroke_join(lv_draw_vector_dsc_t * dsc, lv_vector_stroke_join_t join);
 
 /**
  * Set stroke miter limit for descriptor
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this miter limit.
  * @param dsc              pointer to a vector graphic descriptor
  * @param miter_limit      the stroke miter_limit
  */
-void lv_vector_dsc_set_stroke_miter_limit(lv_vector_dsc_t * dsc, uint16_t miter_limit);
+void lv_draw_vector_dsc_set_stroke_miter_limit(lv_draw_vector_dsc_t * dsc, uint16_t miter_limit);
 
 /**
  * Set stroke linear gradient for descriptor
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this gradient.
  * @param dsc              pointer to a vector graphic descriptor
  * @param x1               the x for start point
  * @param y1               the y for start point
  * @param x2               the x for end point
  * @param y2               the y for end point
  */
-void lv_vector_dsc_set_stroke_linear_gradient(lv_vector_dsc_t * dsc, float x1, float y1, float x2, float y2);
+void lv_draw_vector_dsc_set_stroke_linear_gradient(lv_draw_vector_dsc_t * dsc, float x1, float y1, float x2, float y2);
 /**
  * Set stroke radial gradient for descriptor
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this gradient.
  * @param dsc              pointer to a vector graphic descriptor
  * @param cx               the x for center of the circle
  * @param cy               the y for center of the circle
  * @param radius           the radius for circle
  */
-void lv_vector_dsc_set_stroke_radial_gradient(lv_vector_dsc_t * dsc, float cx, float cy, float radius);
+void lv_draw_vector_dsc_set_stroke_radial_gradient(lv_draw_vector_dsc_t * dsc, float cx, float cy, float radius);
 
 /**
  * Set stroke color stops for descriptor
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this gradient spread.
  * @param dsc              pointer to a vector graphic descriptor
  * @param spread           the gradient spread to be set in lv_vector_gradient_spread_t format
  */
-void lv_vector_dsc_set_stroke_gradient_spread(lv_vector_dsc_t * dsc, lv_vector_gradient_spread_t spread);
+void lv_draw_vector_dsc_set_stroke_gradient_spread(lv_draw_vector_dsc_t * dsc, lv_vector_gradient_spread_t spread);
 
 /**
  * Set stroke color stops for descriptor
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this color stops.
  * @param dsc              pointer to a vector graphic descriptor
  * @param stops            an array of `lv_grad_stop_t` variables
  * @param count            the number of stops in the array
  */
-void lv_vector_dsc_set_stroke_gradient_color_stops(lv_vector_dsc_t * dsc, const lv_grad_stop_t * stops,
-                                                   uint16_t count);
+void lv_draw_vector_dsc_set_stroke_gradient_color_stops(lv_draw_vector_dsc_t * dsc, const lv_grad_stop_t * stops,
+                                                        uint16_t count);
 
 /**
- * Set a matrix to current stroke transformation matrix
+ * Set a matrix to current stroke transformation matrix.
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this matrix.
  * @param dsc              pointer to a vector graphic descriptor
  * @param matrix           pointer to a matrix
  */
-void lv_vector_dsc_set_stroke_transform(lv_vector_dsc_t * dsc, const lv_matrix_t * matrix);
+void lv_draw_vector_dsc_set_stroke_transform(lv_draw_vector_dsc_t * dsc, const lv_matrix_t * matrix);
 
 /**
  * Set current transformation matrix to identity matrix
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this matrix.
  * @param dsc           pointer to a vector graphic descriptor
  */
-void lv_vector_dsc_identity(lv_vector_dsc_t * dsc);
+void lv_draw_vector_dsc_identity(lv_draw_vector_dsc_t * dsc);
 
 /**
  * Change the scale factor of current transformation matrix
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this scale.
  * @param dsc           pointer to a vector graphic descriptor
  * @param scale_x       the scale factor for the X direction
  * @param scale_y       the scale factor for the Y direction
  */
-void lv_vector_dsc_scale(lv_vector_dsc_t * dsc, float scale_x, float scale_y);
+void lv_draw_vector_dsc_scale(lv_draw_vector_dsc_t * dsc, float scale_x, float scale_y);
 
 /**
  * Rotate current transformation matrix with origin
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this rotation.
  * @param dsc           pointer to a vector graphic descriptor
  * @param degree        angle to rotate
  */
-void lv_vector_dsc_rotate(lv_vector_dsc_t * dsc, float degree);
+void lv_draw_vector_dsc_rotate(lv_draw_vector_dsc_t * dsc, float degree);
 
 /**
  * Translate current transformation matrix to new position
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this rotation.
  * @param dsc           pointer to a vector graphic descriptor
  * @param tx            the amount of translate in x direction
- * @param tx            the amount of translate in y direction
+ * @param ty            the amount of translate in y direction
  */
-void lv_vector_dsc_translate(lv_vector_dsc_t * dsc, float tx, float ty);
+void lv_draw_vector_dsc_translate(lv_draw_vector_dsc_t * dsc, float tx, float ty);
 
 /**
  * Change the skew factor of current transformation matrix
+ * The new path shapes added by `lv_draw_vector_dsc_add_path` will use this skew.
  * @param dsc           pointer to a vector graphic descriptor
  * @param skew_x        the skew factor for x direction
  * @param skew_y        the skew factor for y direction
  */
-void lv_vector_dsc_skew(lv_vector_dsc_t * dsc, float skew_x, float skew_y);
+void lv_draw_vector_dsc_skew(lv_draw_vector_dsc_t * dsc, float skew_x, float skew_y);
 
 /**
- * Add a graphic path to the draw list
+ * Add a graphic path to the draw list.
+ * It will use colors, opacity, matrix and other parameters set
+ * by `lv_draw_vector_dsc_set_fill_color()` and similar functions.
  * @param dsc           pointer to a vector graphic descriptor
  * @param path          pointer to a path
  */
-void lv_vector_dsc_add_path(lv_vector_dsc_t * dsc, const lv_vector_path_t * path);
+void lv_draw_vector_dsc_add_path(lv_draw_vector_dsc_t * dsc, const lv_vector_path_t * path);
 
 /**
  * Clear a rectangle area use current fill color
  * @param dsc           pointer to a vector graphic descriptor
  * @param rect          the area to clear in the buffer
  */
-void lv_vector_clear_area(lv_vector_dsc_t * dsc, const lv_area_t * rect);
+void lv_draw_vector_dsc_clear_area(lv_draw_vector_dsc_t * dsc, const lv_area_t * rect);
 
 /**
  * Draw all the vector graphic paths
  * @param dsc           pointer to a vector graphic descriptor
  */
-void lv_draw_vector(lv_vector_dsc_t * dsc);
+void lv_draw_vector(lv_draw_vector_dsc_t * dsc);
+
+/**
+ * Try to get a vector draw descriptor from a draw task.
+ * @param task      draw task
+ * @return          the task's draw descriptor or NULL if the task is not of type LV_DRAW_TASK_TYPE_VECTOR
+ */
+lv_draw_vector_dsc_t * lv_draw_task_get_vector_dsc(lv_draw_task_t * task);
 
 /* Traverser for task list */
-typedef void (*vector_draw_task_cb)(void * ctx, const lv_vector_path_t * path, const lv_vector_draw_dsc_t * dsc);
+typedef void (*vector_draw_task_cb)(void * ctx, const lv_vector_path_t * path, const lv_vector_path_ctx_t * dsc);
 
 #endif /* LV_USE_VECTOR_GRAPHIC */
 
diff --git a/src/draw/lv_draw_vector_private.h b/src/draw/lv_draw_vector_private.h
index 7b2d4e04a8..10639cabb2 100644
--- a/src/draw/lv_draw_vector_private.h
+++ b/src/draw/lv_draw_vector_private.h
@@ -26,6 +26,13 @@ extern "C" {
  *      TYPEDEFS
  **********************/
 
+/**
+ * Stores the shape of the path as arrays of operations and points.
+ * For example move to 10;20 then draw a line to 30;40 and draw an
+ * arc with 30 radius and 70° sweep.
+ *
+ * `lv_vector_path_ctx_t` is also required to describe how to fill and stroke the path.
+ */
 struct _lv_vector_path_t {
     lv_vector_path_quality_t quality;
     lv_array_t ops;
@@ -70,7 +77,10 @@ struct _lv_vector_stroke_dsc_t {
     lv_matrix_t matrix;
 };
 
-struct _lv_vector_draw_dsc_t {
+/**
+ * Stores how to fill, stroke, transform etc a given path
+ */
+struct _lv_vector_path_ctx_t {
     lv_vector_fill_dsc_t fill_dsc;
     lv_vector_stroke_dsc_t stroke_dsc;
     lv_matrix_t matrix;
@@ -78,23 +88,45 @@ struct _lv_vector_draw_dsc_t {
     lv_area_t scissor_area;
 };
 
-struct _lv_draw_vector_task_dsc_t {
+struct _lv_draw_vector_dsc_t {
     lv_draw_dsc_base_t base;
-    lv_ll_t * task_list; /*draw task list.*/
+
+    /** The current colors, opacities, matrix, etc for the next task to be added
+     * by */
+    lv_vector_path_ctx_t * ctx;
+
+    /**
+     * Store path shapes and their attributes
+     * in a list as `lv_draw_vector_subtask_t`. */
+    lv_ll_t * task_list;
 };
 
-struct _lv_vector_dsc_t {
-    lv_layer_t * layer;
-    lv_vector_draw_dsc_t current_dsc;
-    /* private data */
-    lv_draw_vector_task_dsc_t tasks;
-};
+
+/**
+ * Contains a path shape and its attributes together.
+ * It's a task that will be passed to the vector rendering engine.
+ * It's used in the `task_list` of `lv_draw_vector_dsc_t`.
+ */
+typedef struct {
+    lv_vector_path_t * path;
+    lv_vector_path_ctx_t ctx;
+} lv_draw_vector_subtask_t;
+
 
 /**********************
  * GLOBAL PROTOTYPES
  **********************/
 
-void lv_vector_for_each_destroy_tasks(lv_ll_t * task_list, vector_draw_task_cb cb, void * data);
+/**
+ * This is the main function to draw the accumulated vector tasks by passing them
+ * to a vector renderer callback.
+ * When the callback returns the processed vector task will be destroyed.
+ * @param task_list     pointer to the linked list in `lv_draw_vector_dsc_t` that stores
+ *                      the path shapes and their attributes.
+ * @param cb            the callback used to iterate through the task
+ * @param user_data     a custom pointer that will be passed to the callback
+ */
+void lv_vector_for_each_destroy_tasks(lv_ll_t * task_list, vector_draw_task_cb cb, void * used_data);
 
 /**********************
  *      MACROS
diff --git a/src/draw/sw/lv_draw_sw.h b/src/draw/sw/lv_draw_sw.h
index 7695ccd393..aae25c6d18 100644
--- a/src/draw/sw/lv_draw_sw.h
+++ b/src/draw/sw/lv_draw_sw.h
@@ -151,7 +151,7 @@ void lv_draw_sw_transform(const lv_area_t * dest_area, const void * src_buf,
  * @param t             pointer to a draw task
  * @param dsc           the draw descriptor
  */
-void lv_draw_sw_vector(lv_draw_task_t * t, lv_draw_vector_task_dsc_t * dsc);
+void lv_draw_sw_vector(lv_draw_task_t * t, lv_draw_vector_dsc_t * dsc);
 #endif
 
 /**
diff --git a/src/draw/sw/lv_draw_sw_letter.c b/src/draw/sw/lv_draw_sw_letter.c
index cfecd6ba73..c57632b7ac 100644
--- a/src/draw/sw/lv_draw_sw_letter.c
+++ b/src/draw/sw/lv_draw_sw_letter.c
@@ -234,7 +234,7 @@ static void draw_letter_outline(lv_draw_task_t * t, lv_draw_glyph_dsc_t * glyph_
 {
 
     lv_draw_sw_letter_outlines_t * glyph_paths;
-    lv_vector_dsc_t * vector_dsc;
+    lv_draw_vector_dsc_t * vector_dsc;
     lv_draw_buf_t * draw_buf;
     lv_matrix_t matrix;
     lv_layer_t layer;
@@ -274,7 +274,7 @@ static void draw_letter_outline(lv_draw_task_t * t, lv_draw_glyph_dsc_t * glyph_
 
     lv_matrix_identity(&matrix);
 
-    vector_dsc = lv_vector_dsc_create(&layer);
+    vector_dsc = lv_draw_vector_dsc_create(&layer);
 
     int32_t offset_x;
     int32_t offset_y;
@@ -286,20 +286,20 @@ static void draw_letter_outline(lv_draw_task_t * t, lv_draw_glyph_dsc_t * glyph_
     lv_matrix_scale(&matrix, 1, -1);
     lv_matrix_translate(&matrix, -offset_x, -h - offset_y);
     lv_matrix_scale(&matrix, scale, scale);
-    lv_vector_dsc_set_transform(vector_dsc, &matrix);
+    lv_draw_vector_dsc_set_transform(vector_dsc, &matrix);
 
     /*Set attributes color, line width etc*/
     if(cf == LV_COLOR_FORMAT_ARGB8888) {
 
         if(glyph_dsc->outline_stroke_width > 0) {
-            lv_vector_dsc_set_fill_color(vector_dsc, glyph_dsc->outline_stroke_color);
-            lv_vector_dsc_set_fill_opa(vector_dsc, glyph_dsc->outline_stroke_opa);
-            lv_vector_dsc_add_path(vector_dsc, glyph_paths->outside_path);
+            lv_draw_vector_dsc_set_fill_color(vector_dsc, glyph_dsc->outline_stroke_color);
+            lv_draw_vector_dsc_set_fill_opa(vector_dsc, glyph_dsc->outline_stroke_opa);
+            lv_draw_vector_dsc_add_path(vector_dsc, glyph_paths->outside_path);
         }
 
-        lv_vector_dsc_set_fill_color(vector_dsc, glyph_dsc->color);
-        lv_vector_dsc_set_fill_opa(vector_dsc, glyph_dsc->opa);
-        lv_vector_dsc_add_path(vector_dsc, glyph_paths->inside_path);
+        lv_draw_vector_dsc_set_fill_color(vector_dsc, glyph_dsc->color);
+        lv_draw_vector_dsc_set_fill_opa(vector_dsc, glyph_dsc->opa);
+        lv_draw_vector_dsc_add_path(vector_dsc, glyph_paths->inside_path);
 
     }
     else {
@@ -317,16 +317,16 @@ static void draw_letter_outline(lv_draw_task_t * t, lv_draw_glyph_dsc_t * glyph_
     /*Can't call lv_draw_vector() as it would create a new draw task while
      *the main thread also can create draw tasks. So create a dummy draw task
      *manually to draw the outline*/
-    if(vector_dsc->tasks.task_list) {
-        vector_dsc->tasks.base.layer = vector_dsc->layer;
+    if(vector_dsc->task_list) {
+        vector_dsc->base.layer = vector_dsc->base.layer;
         lv_draw_task_t dummy_t;
         lv_memzero(&dummy_t, sizeof(lv_draw_task_t));
-        dummy_t.area = vector_dsc->layer->_clip_area;
-        dummy_t._real_area = vector_dsc->layer->_clip_area;
-        dummy_t.clip_area = vector_dsc->layer->_clip_area;
-        dummy_t.target_layer = vector_dsc->layer;
+        dummy_t.area = vector_dsc->base.layer->_clip_area;
+        dummy_t._real_area = vector_dsc->base.layer->_clip_area;
+        dummy_t.clip_area = vector_dsc->base.layer->_clip_area;
+        dummy_t.target_layer = vector_dsc->base.layer;
         dummy_t.type = LV_DRAW_TASK_TYPE_VECTOR;
-        dummy_t.draw_dsc = &vector_dsc->tasks;
+        dummy_t.draw_dsc = vector_dsc;
         lv_draw_sw_vector(&dummy_t, dummy_t.draw_dsc);
     }
 
@@ -347,7 +347,7 @@ static void draw_letter_outline(lv_draw_task_t * t, lv_draw_glyph_dsc_t * glyph_
     img_dsc.src = draw_buf;
     lv_draw_sw_image(t, &img_dsc, &letter_coords);
 
-    lv_vector_dsc_delete(vector_dsc);
+    lv_draw_vector_dsc_delete(vector_dsc);
     lv_draw_buf_destroy(draw_buf);
 
 }
diff --git a/src/draw/sw/lv_draw_sw_vector.c b/src/draw/sw/lv_draw_sw_vector.c
index b9002975ef..588f5cd14c 100644
--- a/src/draw/sw/lv_draw_sw_vector.c
+++ b/src/draw/sw/lv_draw_sw_vector.c
@@ -429,7 +429,7 @@ static void _blend_draw_buf(lv_draw_buf_t * draw_buf, const lv_area_t * dst_area
     }
 }
 
-static void _task_draw_cb(void * ctx, const lv_vector_path_t * path, const lv_vector_draw_dsc_t * dsc)
+static void _task_draw_cb(void * ctx, const lv_vector_path_t * path, const lv_vector_path_ctx_t * dsc)
 {
     _tvg_draw_state * state = (_tvg_draw_state *)ctx;
     Tvg_Canvas * canvas = (Tvg_Canvas *)state->canvas;
@@ -481,7 +481,7 @@ static void _task_draw_cb(void * ctx, const lv_vector_path_t * path, const lv_ve
  *   GLOBAL FUNCTIONS
  **********************/
 
-void lv_draw_sw_vector(lv_draw_task_t * t, lv_draw_vector_task_dsc_t * dsc)
+void lv_draw_sw_vector(lv_draw_task_t * t, lv_draw_vector_dsc_t * dsc)
 {
     if(dsc->task_list == NULL)
         return;
diff --git a/src/draw/vg_lite/lv_draw_vg_lite.h b/src/draw/vg_lite/lv_draw_vg_lite.h
index 0b873848bd..07a9abceba 100644
--- a/src/draw/vg_lite/lv_draw_vg_lite.h
+++ b/src/draw/vg_lite/lv_draw_vg_lite.h
@@ -79,7 +79,7 @@ void lv_draw_vg_lite_mask_rect(lv_draw_task_t * t, const lv_draw_mask_rect_dsc_t
                                const lv_area_t * coords);
 
 #if LV_USE_VECTOR_GRAPHIC
-void lv_draw_vg_lite_vector(lv_draw_task_t * t, const lv_draw_vector_task_dsc_t * dsc);
+void lv_draw_vg_lite_vector(lv_draw_task_t * t, const lv_draw_vector_dsc_t * dsc);
 #endif
 
 /**********************
diff --git a/src/draw/vg_lite/lv_draw_vg_lite_vector.c b/src/draw/vg_lite/lv_draw_vg_lite_vector.c
index 3e298d1129..09c1f21740 100644
--- a/src/draw/vg_lite/lv_draw_vg_lite_vector.c
+++ b/src/draw/vg_lite/lv_draw_vg_lite_vector.c
@@ -39,7 +39,7 @@ typedef void (*path_drop_func_t)(struct _lv_draw_vg_lite_unit_t *, path_drop_dat
  *  STATIC PROTOTYPES
  **********************/
 
-static void task_draw_cb(void * ctx, const lv_vector_path_t * path, const lv_vector_draw_dsc_t * dsc);
+static void task_draw_cb(void * user_data, const lv_vector_path_t * path, const lv_vector_path_ctx_t * ctx);
 static void lv_path_to_vg(lv_vg_lite_path_t * dest, const lv_vector_path_t * src, lv_fpoint_t * offset,
                           float expand_bound);
 static vg_lite_blend_t lv_blend_to_vg(lv_vector_blend_t blend);
@@ -57,7 +57,7 @@ static vg_lite_fill_t lv_fill_to_vg(lv_vector_fill_t fill_rule);
  *   GLOBAL FUNCTIONS
  **********************/
 
-void lv_draw_vg_lite_vector(lv_draw_task_t * t, const lv_draw_vector_task_dsc_t * dsc)
+void lv_draw_vg_lite_vector(lv_draw_task_t * t, const lv_draw_vector_dsc_t * dsc)
 {
     if(dsc->task_list == NULL)
         return;
@@ -90,16 +90,16 @@ static vg_lite_color_t lv_color32_to_vg(lv_color32_t color, lv_opa_t opa)
 
 static void draw_fill(lv_draw_vg_lite_unit_t * u,
                       lv_vg_lite_path_t * lv_vg_path,
-                      const lv_vector_draw_dsc_t * dsc,
+                      const lv_vector_path_ctx_t * ctx,
                       vg_lite_matrix_t * matrix,
                       const lv_fpoint_t * offset,
                       const lv_opa_t opa)
 {
     LV_PROFILER_DRAW_BEGIN;
 
-    const vg_lite_color_t vg_color = lv_color32_to_vg(dsc->fill_dsc.color, OPA_MIX(dsc->fill_dsc.opa, opa));
-    const vg_lite_blend_t blend = lv_blend_to_vg(dsc->blend_mode);
-    const vg_lite_fill_t fill = lv_fill_to_vg(dsc->fill_dsc.fill_rule);
+    const vg_lite_color_t vg_color = lv_color32_to_vg(ctx->fill_dsc.color, OPA_MIX(ctx->fill_dsc.opa, opa));
+    const vg_lite_blend_t blend = lv_blend_to_vg(ctx->blend_mode);
+    const vg_lite_fill_t fill = lv_fill_to_vg(ctx->fill_dsc.fill_rule);
 
     /* If it is fill mode, the end op code should be added */
     lv_vg_lite_path_end(lv_vg_path);
@@ -107,7 +107,7 @@ static void draw_fill(lv_draw_vg_lite_unit_t * u,
     vg_lite_path_t * vg_path = lv_vg_lite_path_get_path(lv_vg_path);
     LV_VG_LITE_ASSERT_PATH(vg_path);
 
-    switch(dsc->fill_dsc.style) {
+    switch(ctx->fill_dsc.style) {
         case LV_VECTOR_DRAW_STYLE_SOLID: {
                 /* normal draw shape */
                 lv_vg_lite_draw(
@@ -123,23 +123,23 @@ static void draw_fill(lv_draw_vg_lite_unit_t * u,
                 /* draw image */
                 vg_lite_buffer_t image_buffer;
                 lv_image_decoder_dsc_t decoder_dsc;
-                if(lv_vg_lite_buffer_open_image(&image_buffer, &decoder_dsc, dsc->fill_dsc.img_dsc.src, false, true)) {
+                if(lv_vg_lite_buffer_open_image(&image_buffer, &decoder_dsc, ctx->fill_dsc.img_dsc.src, false, true)) {
                     /* Calculate pattern matrix. Should start from path bond box, and also apply fill matrix. */
                     vg_lite_matrix_t pattern_matrix = *matrix;
 
-                    if(dsc->fill_dsc.fill_units == LV_VECTOR_FILL_UNITS_OBJECT_BOUNDING_BOX) {
+                    if(ctx->fill_dsc.fill_units == LV_VECTOR_FILL_UNITS_OBJECT_BOUNDING_BOX) {
                         /* Convert to object bounding box coordinates */
                         vg_lite_translate(offset->x, offset->y, &pattern_matrix);
                     }
 
                     vg_lite_matrix_t fill_matrix;
-                    lv_vg_lite_matrix(&fill_matrix, &dsc->fill_dsc.matrix);
+                    lv_vg_lite_matrix(&fill_matrix, &ctx->fill_dsc.matrix);
                     lv_vg_lite_matrix_multiply(&pattern_matrix, &fill_matrix);
 
-                    const lv_draw_image_dsc_t * img_dsc = &dsc->fill_dsc.img_dsc;
+                    const lv_draw_image_dsc_t * img_dsc = &ctx->fill_dsc.img_dsc;
                     lv_draw_image_dsc_t tmp_dsc;
                     if(opa < LV_OPA_COVER) {
-                        tmp_dsc = dsc->fill_dsc.img_dsc;
+                        tmp_dsc = ctx->fill_dsc.img_dsc;
                         tmp_dsc.opa = OPA_MIX(tmp_dsc.opa, opa);
                         img_dsc = &tmp_dsc;
                     }
@@ -166,13 +166,13 @@ static void draw_fill(lv_draw_vg_lite_unit_t * u,
         case LV_VECTOR_DRAW_STYLE_GRADIENT: {
                 vg_lite_matrix_t grad_matrix = *matrix;
                 vg_lite_matrix_t fill_matrix;
-                lv_vg_lite_matrix(&fill_matrix, &dsc->fill_dsc.matrix);
+                lv_vg_lite_matrix(&fill_matrix, &ctx->fill_dsc.matrix);
                 lv_vg_lite_matrix_multiply(&grad_matrix, &fill_matrix);
 
-                const lv_vector_gradient_t * gradient = &dsc->fill_dsc.gradient;
+                const lv_vector_gradient_t * gradient = &ctx->fill_dsc.gradient;
                 lv_vector_gradient_t tmp_gradient;
                 if(opa < LV_OPA_COVER) {
-                    tmp_gradient = dsc->fill_dsc.gradient;
+                    tmp_gradient = ctx->fill_dsc.gradient;
                     for(uint16_t i = 0; i < tmp_gradient.stops_count; i++) {
                         tmp_gradient.stops[i].opa = OPA_MIX(tmp_gradient.stops[i].opa, opa);
                     }
@@ -192,7 +192,7 @@ static void draw_fill(lv_draw_vg_lite_unit_t * u,
             }
             break;
         default:
-            LV_LOG_WARN("unsupported style: %d", dsc->fill_dsc.style);
+            LV_LOG_WARN("unsupported style: %d", ctx->fill_dsc.style);
             break;
     }
 
@@ -202,7 +202,7 @@ static void draw_fill(lv_draw_vg_lite_unit_t * u,
 static void draw_stroke(lv_draw_vg_lite_unit_t * u,
                         const lv_vector_path_t * path,
                         lv_vg_lite_path_t * lv_vg_path,
-                        const lv_vector_draw_dsc_t * dsc,
+                        const lv_vector_path_ctx_t * ctx,
                         vg_lite_matrix_t * matrix,
                         const lv_opa_t opa)
 {
@@ -211,7 +211,7 @@ static void draw_stroke(lv_draw_vg_lite_unit_t * u,
     vg_lite_path_t * vg_path = lv_vg_lite_path_get_path(lv_vg_path);
 
     LV_UNUSED(path);
-    lv_cache_entry_t * stroke_cache_entey = lv_vg_lite_stroke_get(u, lv_vg_path, &dsc->stroke_dsc);
+    lv_cache_entry_t * stroke_cache_entey = lv_vg_lite_stroke_get(u, lv_vg_path, &ctx->stroke_dsc);
     if(!stroke_cache_entey) {
         LV_LOG_ERROR("convert stroke failed");
         LV_PROFILER_DRAW_END;
@@ -222,16 +222,16 @@ static void draw_stroke(lv_draw_vg_lite_unit_t * u,
 
     /* set stroke params */
     vg_stroke_path->quality = vg_path->quality;
-    vg_stroke_path->stroke_color = lv_color32_to_vg(dsc->stroke_dsc.color, OPA_MIX(dsc->stroke_dsc.opa, opa));
+    vg_stroke_path->stroke_color = lv_color32_to_vg(ctx->stroke_dsc.color, OPA_MIX(ctx->stroke_dsc.opa, opa));
     const vg_lite_color_t vg_color = 0;
 
     /* set stroke path bounding box */
     lv_memcpy(vg_stroke_path->bounding_box, vg_path->bounding_box, sizeof(vg_path->bounding_box));
     LV_VG_LITE_ASSERT_PATH(vg_stroke_path);
 
-    const vg_lite_blend_t blend = lv_blend_to_vg(dsc->blend_mode);
+    const vg_lite_blend_t blend = lv_blend_to_vg(ctx->blend_mode);
 
-    switch(dsc->stroke_dsc.style) {
+    switch(ctx->stroke_dsc.style) {
         case LV_VECTOR_DRAW_STYLE_SOLID: {
                 /* normal draw shape */
                 lv_vg_lite_draw(
@@ -244,7 +244,7 @@ static void draw_stroke(lv_draw_vg_lite_unit_t * u,
             }
             break;
         default:
-            LV_LOG_WARN("unsupported style: %d", dsc->stroke_dsc.style);
+            LV_LOG_WARN("unsupported style: %d", ctx->stroke_dsc.style);
             break;
     }
 
@@ -252,27 +252,27 @@ static void draw_stroke(lv_draw_vg_lite_unit_t * u,
     LV_PROFILER_DRAW_END;
 }
 
-static void task_draw_cb(void * ctx, const lv_vector_path_t * path, const lv_vector_draw_dsc_t * dsc)
+static void task_draw_cb(void * user_data, const lv_vector_path_t * path, const lv_vector_path_ctx_t * ctx)
 {
     LV_PROFILER_DRAW_BEGIN;
-    lv_draw_vg_lite_unit_t * u = ctx;
+    lv_draw_vg_lite_unit_t * u = user_data;
     LV_VG_LITE_ASSERT_DEST_BUFFER(&u->target_buffer);
 
     vg_lite_matrix_t matrix = u->global_matrix;
 
     const lv_area_t scissor_area = lv_matrix_is_identity((lv_matrix_t *)&matrix)
-                                   ? dsc->scissor_area
-                                   : lv_matrix_transform_area((lv_matrix_t *)&matrix, &dsc->scissor_area);
+                                   ? ctx->scissor_area
+                                   : lv_matrix_transform_area((lv_matrix_t *)&matrix, &ctx->scissor_area);
 
     /* clear area */
     if(!path) {
-        vg_lite_color_t c = lv_color32_to_vg(dsc->fill_dsc.color, OPA_MIX(dsc->fill_dsc.opa, u->task_act->opa));
+        vg_lite_color_t c = lv_color32_to_vg(ctx->fill_dsc.color, OPA_MIX(ctx->fill_dsc.opa, u->task_act->opa));
         lv_vg_lite_clear(&u->target_buffer, &scissor_area, c);
         LV_PROFILER_DRAW_END;
         return;
     }
 
-    if(dsc->fill_dsc.opa == LV_OPA_TRANSP && dsc->stroke_dsc.opa == LV_OPA_TRANSP) {
+    if(ctx->fill_dsc.opa == LV_OPA_TRANSP && ctx->stroke_dsc.opa == LV_OPA_TRANSP) {
         LV_LOG_TRACE("Full transparent, no need to draw");
         LV_PROFILER_DRAW_END;
         return;
@@ -280,7 +280,7 @@ static void task_draw_cb(void * ctx, const lv_vector_path_t * path, const lv_vec
 
     /* transform matrix */
     vg_lite_matrix_t dsc_matrix;
-    lv_vg_lite_matrix(&dsc_matrix, &dsc->matrix);
+    lv_vg_lite_matrix(&dsc_matrix, &ctx->matrix);
     lv_vg_lite_matrix_multiply(&matrix, &dsc_matrix);
     LV_VG_LITE_ASSERT_MATRIX(&matrix);
 
@@ -288,7 +288,7 @@ static void task_draw_cb(void * ctx, const lv_vector_path_t * path, const lv_vec
     lv_vg_lite_path_t * lv_vg_path = lv_vg_lite_path_get(u, VG_LITE_FP32);
 
     lv_fpoint_t offset = {0, 0};
-    lv_path_to_vg(lv_vg_path, path, &offset, dsc->stroke_dsc.opa ? dsc->stroke_dsc.width : 0);
+    lv_path_to_vg(lv_vg_path, path, &offset, ctx->stroke_dsc.opa ? ctx->stroke_dsc.width : 0);
 
     if(vg_lite_query_feature(gcFEATURE_BIT_VG_SCISSOR)) {
         /* set scissor area */
@@ -320,12 +320,12 @@ static void task_draw_cb(void * ctx, const lv_vector_path_t * path, const lv_vec
 
     const lv_opa_t layer_opa = u->task_act->opa;
 
-    if(dsc->fill_dsc.opa) {
-        draw_fill(u, lv_vg_path, dsc, &matrix, &offset, layer_opa);
+    if(ctx->fill_dsc.opa) {
+        draw_fill(u, lv_vg_path, ctx, &matrix, &offset, layer_opa);
     }
 
-    if(dsc->stroke_dsc.opa) {
-        draw_stroke(u, path, lv_vg_path, dsc, &matrix, layer_opa);
+    if(ctx->stroke_dsc.opa) {
+        draw_stroke(u, path, lv_vg_path, ctx, &matrix, layer_opa);
     }
 
     /* drop path */
diff --git a/src/libs/svg/lv_svg_decoder.c b/src/libs/svg/lv_svg_decoder.c
index 833d01dbb6..011e63f818 100644
--- a/src/libs/svg/lv_svg_decoder.c
+++ b/src/libs/svg/lv_svg_decoder.c
@@ -343,19 +343,23 @@ static void svg_draw_buf_free(void * svg_buf)
     lv_svg_render_delete(draw_list);
 }
 
-static void svg_draw(lv_layer_t * layer, const lv_image_decoder_dsc_t * dsc, const lv_area_t * coords,
+static void svg_draw(lv_layer_t * layer, const lv_image_decoder_dsc_t * decoder_dsc, const lv_area_t * coords,
                      const lv_draw_image_dsc_t * image_dsc, const lv_area_t * clip_area)
 {
-    const lv_draw_buf_t * draw_buf = dsc->decoded;
+    const lv_draw_buf_t * draw_buf = decoder_dsc->decoded;
     const lv_svg_render_obj_t * list = draw_buf->unaligned_data;
 
     LV_PROFILER_DRAW_BEGIN;
 
-    lv_vector_dsc_t * ctx = lv_vector_dsc_create(layer);
+    lv_draw_vector_dsc_t * dsc = lv_draw_vector_dsc_create(layer);
+
+    /*Save the widget so that `LV_EVENT_DRAW_TASK_ADDED` can be sent to it in `lv_draw_vector`*/
+    dsc->base.obj = image_dsc->base.obj;
+
     lv_matrix_t matrix;
     lv_matrix_identity(&matrix);
     lv_matrix_translate(&matrix, coords->x1, coords->y1);
-    ctx->current_dsc.scissor_area = *clip_area;
+    dsc->ctx->scissor_area = *clip_area;
     if(image_dsc) {
         int32_t off_x = (lv_area_get_width(coords) - image_dsc->header.w - 1) / 2;
         int32_t off_y = (lv_area_get_height(coords) - image_dsc->header.h - 1) / 2;
@@ -368,10 +372,10 @@ static void svg_draw(lv_layer_t * layer, const lv_image_decoder_dsc_t * dsc, con
         lv_matrix_scale(&matrix, image_dsc->scale_x / 256.0f, image_dsc->scale_y / 256.0f);
         lv_matrix_translate(&matrix, -image_dsc->pivot.x, -image_dsc->pivot.y);
     }
-    lv_vector_dsc_set_transform(ctx, &matrix);
-    lv_draw_svg_render(ctx, list);
-    lv_draw_vector(ctx);
-    lv_vector_dsc_delete(ctx);
+    lv_draw_vector_dsc_set_transform(dsc, &matrix);
+    lv_draw_svg_render(dsc, list);
+    lv_draw_vector(dsc);
+    lv_draw_vector_dsc_delete(dsc);
 
     LV_PROFILER_DRAW_END;
 }
diff --git a/src/libs/svg/lv_svg_render.c b/src/libs/svg/lv_svg_render.c
index 0b740095bf..2107ee7d56 100644
--- a/src/libs/svg/lv_svg_render.c
+++ b/src/libs/svg/lv_svg_render.c
@@ -62,12 +62,12 @@ enum {
 /**********************
 *      TYPEDEFS
 **********************/
-static void _set_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * dsc, const lv_svg_attr_t * attr);
-static void _init_draw_dsc(lv_vector_draw_dsc_t * dsc);
-static void _deinit_draw_dsc(lv_vector_draw_dsc_t * dsc);
-static void _copy_draw_dsc(lv_vector_draw_dsc_t * dst, const lv_vector_draw_dsc_t * src);
-static void _prepare_render(const lv_svg_render_obj_t * obj, lv_vector_dsc_t * dsc);
-static void _special_render(const lv_svg_render_obj_t * obj, lv_vector_dsc_t * dsc);
+static void _set_attr(lv_svg_render_obj_t * obj, lv_vector_path_ctx_t * dsc, const lv_svg_attr_t * attr);
+static void _init_draw_dsc(lv_vector_path_ctx_t * dsc);
+static void _deinit_draw_dsc(lv_vector_path_ctx_t * dsc);
+static void _copy_draw_dsc(lv_vector_path_ctx_t * dst, const lv_vector_path_ctx_t * src);
+static void _prepare_render(const lv_svg_render_obj_t * obj, lv_draw_vector_dsc_t * dsc);
+static void _special_render(const lv_svg_render_obj_t * obj, lv_draw_vector_dsc_t * dsc);
 #if LV_USE_FREETYPE
     static void _freetype_outline_cb(lv_event_t * e);
 #endif
@@ -169,7 +169,7 @@ typedef struct {
 typedef struct _lv_svg_render_content {
     lv_svg_render_obj_t base;
     void (*render_content)(const struct _lv_svg_render_content * content,
-                           lv_vector_dsc_t * dsc, lv_matrix_t * matrix);
+                           lv_draw_vector_dsc_t * dsc, lv_matrix_t * matrix);
     uint32_t * letters;
     uint32_t count;
 } lv_svg_render_content_t;
@@ -187,7 +187,7 @@ typedef struct {
 
 struct _lv_svg_draw_dsc {
     struct _lv_svg_draw_dsc * next;
-    lv_vector_draw_dsc_t dsc;
+    lv_vector_path_ctx_t dsc;
     const char * fill_ref;
     const char * stroke_ref;
 };
@@ -261,7 +261,7 @@ static struct _lv_svg_draw_dsc * _lv_svg_draw_dsc_pop(struct _lv_svg_draw_dsc *
     return cur;
 }
 
-static void _set_viewport_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * dsc, const lv_svg_attr_t * attr)
+static void _set_viewport_attr(lv_svg_render_obj_t * obj, lv_vector_path_ctx_t * dsc, const lv_svg_attr_t * attr)
 {
     lv_svg_render_viewport_t * view = (lv_svg_render_viewport_t *)obj;
     switch(attr->id) {
@@ -313,7 +313,7 @@ static void _set_viewport_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t *
     }
 }
 
-static void _set_use_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * dsc, const lv_svg_attr_t * attr)
+static void _set_use_attr(lv_svg_render_obj_t * obj, lv_vector_path_ctx_t * dsc, const lv_svg_attr_t * attr)
 {
     _set_attr(obj, dsc, attr);
     lv_svg_render_use_t * use = (lv_svg_render_use_t *)obj;
@@ -332,7 +332,7 @@ static void _set_use_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * dsc,
     }
 }
 
-static void _set_solid_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * dsc, const lv_svg_attr_t * attr)
+static void _set_solid_attr(lv_svg_render_obj_t * obj, lv_vector_path_ctx_t * dsc, const lv_svg_attr_t * attr)
 {
     LV_UNUSED(dsc);
     lv_svg_render_solid_t * solid = (lv_svg_render_solid_t *)obj;
@@ -346,7 +346,7 @@ static void _set_solid_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * ds
     }
 }
 
-static void _set_gradient_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * dsc, const lv_svg_attr_t * attr)
+static void _set_gradient_attr(lv_svg_render_obj_t * obj, lv_vector_path_ctx_t * dsc, const lv_svg_attr_t * attr)
 {
     LV_UNUSED(dsc);
     lv_svg_render_gradient_t * grad = (lv_svg_render_gradient_t *)obj;
@@ -378,7 +378,7 @@ static void _set_gradient_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t *
     }
 }
 
-static void _set_rect_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * dsc, const lv_svg_attr_t * attr)
+static void _set_rect_attr(lv_svg_render_obj_t * obj, lv_vector_path_ctx_t * dsc, const lv_svg_attr_t * attr)
 {
     _set_attr(obj, dsc, attr);
     lv_svg_render_rect_t * rect = (lv_svg_render_rect_t *)obj;
@@ -404,7 +404,7 @@ static void _set_rect_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * dsc
     }
 }
 
-static void _set_circle_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * dsc, const lv_svg_attr_t * attr)
+static void _set_circle_attr(lv_svg_render_obj_t * obj, lv_vector_path_ctx_t * dsc, const lv_svg_attr_t * attr)
 {
     _set_attr(obj, dsc, attr);
     lv_svg_render_circle_t * circle = (lv_svg_render_circle_t *)obj;
@@ -421,7 +421,7 @@ static void _set_circle_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * d
     }
 }
 
-static void _set_ellipse_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * dsc, const lv_svg_attr_t * attr)
+static void _set_ellipse_attr(lv_svg_render_obj_t * obj, lv_vector_path_ctx_t * dsc, const lv_svg_attr_t * attr)
 {
     _set_attr(obj, dsc, attr);
     lv_svg_render_ellipse_t * ellipse = (lv_svg_render_ellipse_t *)obj;
@@ -441,7 +441,7 @@ static void _set_ellipse_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t *
     }
 }
 
-static void _set_line_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * dsc, const lv_svg_attr_t * attr)
+static void _set_line_attr(lv_svg_render_obj_t * obj, lv_vector_path_ctx_t * dsc, const lv_svg_attr_t * attr)
 {
     _set_attr(obj, dsc, attr);
     lv_svg_render_line_t * line = (lv_svg_render_line_t *)obj;
@@ -461,7 +461,7 @@ static void _set_line_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * dsc
     }
 }
 
-static void _set_polyline_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * dsc, const lv_svg_attr_t * attr)
+static void _set_polyline_attr(lv_svg_render_obj_t * obj, lv_vector_path_ctx_t * dsc, const lv_svg_attr_t * attr)
 {
     _set_attr(obj, dsc, attr);
     lv_svg_render_poly_t * poly = (lv_svg_render_poly_t *)obj;
@@ -483,7 +483,7 @@ static void _set_polyline_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t *
     }
 }
 
-static void _set_polygon_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * dsc, const lv_svg_attr_t * attr)
+static void _set_polygon_attr(lv_svg_render_obj_t * obj, lv_vector_path_ctx_t * dsc, const lv_svg_attr_t * attr)
 {
     _set_polyline_attr(obj, dsc, attr);
     lv_svg_render_poly_t * poly = (lv_svg_render_poly_t *)obj;
@@ -510,7 +510,7 @@ static size_t _get_path_seg_size(uint32_t cmd)
     }
 }
 
-static void _set_path_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * dsc, const lv_svg_attr_t * attr)
+static void _set_path_attr(lv_svg_render_obj_t * obj, lv_vector_path_ctx_t * dsc, const lv_svg_attr_t * attr)
 {
     _set_attr(obj, dsc, attr);
     lv_svg_render_poly_t * poly = (lv_svg_render_poly_t *)obj;
@@ -654,7 +654,7 @@ static void _set_path_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * dsc
         } \
     } while(0)
 
-static void _set_tspan_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * dsc, const lv_svg_attr_t * attr)
+static void _set_tspan_attr(lv_svg_render_obj_t * obj, lv_vector_path_ctx_t * dsc, const lv_svg_attr_t * attr)
 {
     _set_attr(obj, dsc, attr);
     lv_svg_render_tspan_t * tspan = (lv_svg_render_tspan_t *)obj;
@@ -662,7 +662,7 @@ static void _set_tspan_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * ds
     SET_FONT_ATTRS(tspan, attr);
 }
 
-static void _set_text_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * dsc, const lv_svg_attr_t * attr)
+static void _set_text_attr(lv_svg_render_obj_t * obj, lv_vector_path_ctx_t * dsc, const lv_svg_attr_t * attr)
 {
     _set_attr(obj, dsc, attr);
     lv_svg_render_text_t * text = (lv_svg_render_text_t *)obj;
@@ -680,7 +680,7 @@ static void _set_text_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * dsc
 }
 #endif
 
-static void _set_image_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * dsc, const lv_svg_attr_t * attr)
+static void _set_image_attr(lv_svg_render_obj_t * obj, lv_vector_path_ctx_t * dsc, const lv_svg_attr_t * attr)
 {
     _set_attr(obj, dsc, attr);
     lv_svg_render_image_t * image = (lv_svg_render_image_t *)obj;
@@ -716,7 +716,7 @@ static void _set_image_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * ds
     }
 }
 
-static void _set_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * dsc, const lv_svg_attr_t * attr)
+static void _set_attr(lv_svg_render_obj_t * obj, lv_vector_path_ctx_t * dsc, const lv_svg_attr_t * attr)
 {
     LV_UNUSED(obj);
     switch(attr->id) {
@@ -892,7 +892,7 @@ static void _set_attr(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * dsc, con
     }
 }
 
-static void _set_solid_ref(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * dsc,
+static void _set_solid_ref(lv_svg_render_obj_t * obj, lv_vector_path_ctx_t * dsc,
                            const lv_svg_render_obj_t * target_obj, bool fill)
 {
     LV_UNUSED(target_obj);
@@ -909,7 +909,7 @@ static void _set_solid_ref(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * dsc
     }
 }
 
-static void _set_gradient_ref(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t * dsc,
+static void _set_gradient_ref(lv_svg_render_obj_t * obj, lv_vector_path_ctx_t * dsc,
                               const lv_svg_render_obj_t * target_obj, bool fill)
 {
     if(!target_obj->clz->get_bounds) {
@@ -968,7 +968,7 @@ static void _set_gradient_ref(lv_svg_render_obj_t * obj, lv_vector_draw_dsc_t *
     }
 }
 
-static void _init_draw_dsc(lv_vector_draw_dsc_t * dsc)
+static void _init_draw_dsc(lv_vector_path_ctx_t * dsc)
 {
     lv_vector_fill_dsc_t * fill_dsc = &(dsc->fill_dsc);
     fill_dsc->style = LV_VECTOR_DRAW_STYLE_SOLID;
@@ -991,12 +991,12 @@ static void _init_draw_dsc(lv_vector_draw_dsc_t * dsc)
     lv_matrix_identity(&(dsc->matrix));
 }
 
-static void _deinit_draw_dsc(lv_vector_draw_dsc_t * dsc)
+static void _deinit_draw_dsc(lv_vector_path_ctx_t * dsc)
 {
     lv_array_deinit(&(dsc->stroke_dsc.dash_pattern));
 }
 
-static void _copy_draw_dsc(lv_vector_draw_dsc_t * dst, const lv_vector_draw_dsc_t * src)
+static void _copy_draw_dsc(lv_vector_path_ctx_t * dst, const lv_vector_path_ctx_t * src)
 {
     lv_memcpy(&dst->fill_dsc, &src->fill_dsc, sizeof(lv_vector_fill_dsc_t));
 
@@ -1015,9 +1015,9 @@ static void _copy_draw_dsc(lv_vector_draw_dsc_t * dst, const lv_vector_draw_dsc_
     dst->blend_mode = src->blend_mode;
 }
 
-static void _copy_draw_dsc_from_ref(lv_vector_dsc_t * dsc, const lv_svg_render_obj_t * obj)
+static void _copy_draw_dsc_from_ref(lv_draw_vector_dsc_t * dsc, const lv_svg_render_obj_t * obj)
 {
-    lv_vector_draw_dsc_t * dst = &(dsc->current_dsc);
+    lv_vector_path_ctx_t * dst = dsc->ctx;
     if(obj->fill_ref) {
         lv_svg_render_obj_t * list = obj->head;
         while(list) {
@@ -1228,26 +1228,26 @@ static void _init_gradient(lv_svg_render_obj_t * obj, const lv_svg_node_t * node
     grad->dsc.stops_count = stop_count;
 }
 
-static void _setup_matrix(lv_matrix_t * matrix, lv_vector_dsc_t * dsc, const lv_svg_render_obj_t * obj)
+static void _setup_matrix(lv_matrix_t * matrix, lv_draw_vector_dsc_t * dsc, const lv_svg_render_obj_t * obj)
 {
-    lv_memcpy(matrix, &dsc->current_dsc.matrix, sizeof(lv_matrix_t));
-    lv_matrix_multiply(&dsc->current_dsc.matrix, &obj->matrix);
+    lv_memcpy(matrix, &dsc->ctx->matrix, sizeof(lv_matrix_t));
+    lv_matrix_multiply(&dsc->ctx->matrix, &obj->matrix);
 }
 
-static void _restore_matrix(lv_matrix_t * matrix, lv_vector_dsc_t * dsc)
+static void _restore_matrix(lv_matrix_t * matrix, lv_draw_vector_dsc_t * dsc)
 {
-    lv_memcpy(&dsc->current_dsc.matrix, matrix, sizeof(lv_matrix_t));
+    lv_memcpy(&dsc->ctx->matrix, matrix, sizeof(lv_matrix_t));
 }
 
-static void _prepare_render(const lv_svg_render_obj_t * obj, lv_vector_dsc_t * dsc)
+static void _prepare_render(const lv_svg_render_obj_t * obj, lv_draw_vector_dsc_t * dsc)
 {
-    _copy_draw_dsc(&(dsc->current_dsc), &(obj->dsc));
+    _copy_draw_dsc(dsc->ctx, &(obj->dsc));
 }
 
-static void _special_render(const lv_svg_render_obj_t * obj, lv_vector_dsc_t * dsc)
+static void _special_render(const lv_svg_render_obj_t * obj, lv_draw_vector_dsc_t * dsc)
 {
-    const lv_vector_draw_dsc_t * src = &(obj->dsc);
-    lv_vector_draw_dsc_t * dst = &(dsc->current_dsc);
+    const lv_vector_path_ctx_t * src = &(obj->dsc);
+    lv_vector_path_ctx_t * dst = dsc->ctx;
 
     if(obj->flags & _RENDER_ATTR_FILL) {
         lv_memcpy(&(dst->fill_dsc), &(src->fill_dsc), sizeof(lv_vector_fill_dsc_t));
@@ -1293,28 +1293,28 @@ static void _special_render(const lv_svg_render_obj_t * obj, lv_vector_dsc_t * d
 }
 
 /* render functions */
-static void _render_viewport(const lv_svg_render_obj_t * obj, lv_vector_dsc_t * dsc, const lv_matrix_t * matrix)
+static void _render_viewport(const lv_svg_render_obj_t * obj, lv_draw_vector_dsc_t * dsc, const lv_matrix_t * matrix)
 {
     LV_UNUSED(matrix);
 
     lv_svg_render_viewport_t * view = (lv_svg_render_viewport_t *)obj;
-    lv_matrix_multiply(&dsc->current_dsc.matrix, &obj->matrix);
+    lv_matrix_multiply(&dsc->ctx->matrix, &obj->matrix);
     if(view->viewport_fill) {
         lv_area_t rc = {0, 0, (int32_t)view->width, (int32_t)view->height};
         lv_vector_path_t * path = lv_vector_path_create(LV_VECTOR_PATH_QUALITY_MEDIUM);
         lv_vector_path_append_rect(path, &rc, 0, 0);
-        lv_vector_dsc_add_path(dsc, path);
+        lv_draw_vector_dsc_add_path(dsc, path);
         lv_vector_path_delete(path);
     }
 }
 
-static void _render_rect(const lv_svg_render_obj_t * obj, lv_vector_dsc_t * dsc, const lv_matrix_t * matrix)
+static void _render_rect(const lv_svg_render_obj_t * obj, lv_draw_vector_dsc_t * dsc, const lv_matrix_t * matrix)
 {
     lv_matrix_t mtx;
     _setup_matrix(&mtx, dsc, obj);
 
     if(matrix) {
-        lv_matrix_multiply(&dsc->current_dsc.matrix, matrix);
+        lv_matrix_multiply(&dsc->ctx->matrix, matrix);
     }
 
     lv_svg_render_rect_t * rect = (lv_svg_render_rect_t *)obj;
@@ -1327,19 +1327,19 @@ static void _render_rect(const lv_svg_render_obj_t * obj, lv_vector_dsc_t * dsc,
     lv_vector_path_append_rect(path, &rc, rect->rx, rect->ry);
 
     _copy_draw_dsc_from_ref(dsc, obj);
-    lv_vector_dsc_add_path(dsc, path);
+    lv_draw_vector_dsc_add_path(dsc, path);
     lv_vector_path_delete(path);
 
     _restore_matrix(&mtx, dsc);
 }
 
-static void _render_circle(const lv_svg_render_obj_t * obj, lv_vector_dsc_t * dsc, const lv_matrix_t * matrix)
+static void _render_circle(const lv_svg_render_obj_t * obj, lv_draw_vector_dsc_t * dsc, const lv_matrix_t * matrix)
 {
     lv_matrix_t mtx;
     _setup_matrix(&mtx, dsc, obj);
 
     if(matrix) {
-        lv_matrix_multiply(&dsc->current_dsc.matrix, matrix);
+        lv_matrix_multiply(&dsc->ctx->matrix, matrix);
     }
 
     lv_svg_render_circle_t * circle = (lv_svg_render_circle_t *)obj;
@@ -1348,19 +1348,19 @@ static void _render_circle(const lv_svg_render_obj_t * obj, lv_vector_dsc_t * ds
     lv_vector_path_append_circle(path, &cp, circle->r, circle->r);
 
     _copy_draw_dsc_from_ref(dsc, obj);
-    lv_vector_dsc_add_path(dsc, path);
+    lv_draw_vector_dsc_add_path(dsc, path);
     lv_vector_path_delete(path);
 
     _restore_matrix(&mtx, dsc);
 }
 
-static void _render_ellipse(const lv_svg_render_obj_t * obj, lv_vector_dsc_t * dsc, const lv_matrix_t * matrix)
+static void _render_ellipse(const lv_svg_render_obj_t * obj, lv_draw_vector_dsc_t * dsc, const lv_matrix_t * matrix)
 {
     lv_matrix_t mtx;
     _setup_matrix(&mtx, dsc, obj);
 
     if(matrix) {
-        lv_matrix_multiply(&dsc->current_dsc.matrix, matrix);
+        lv_matrix_multiply(&dsc->ctx->matrix, matrix);
     }
 
     lv_svg_render_ellipse_t * ellipse = (lv_svg_render_ellipse_t *)obj;
@@ -1369,19 +1369,19 @@ static void _render_ellipse(const lv_svg_render_obj_t * obj, lv_vector_dsc_t * d
     lv_vector_path_append_circle(path, &cp, ellipse->rx, ellipse->ry);
 
     _copy_draw_dsc_from_ref(dsc, obj);
-    lv_vector_dsc_add_path(dsc, path);
+    lv_draw_vector_dsc_add_path(dsc, path);
     lv_vector_path_delete(path);
 
     _restore_matrix(&mtx, dsc);
 }
 
-static void _render_line(const lv_svg_render_obj_t * obj, lv_vector_dsc_t * dsc, const lv_matrix_t * matrix)
+static void _render_line(const lv_svg_render_obj_t * obj, lv_draw_vector_dsc_t * dsc, const lv_matrix_t * matrix)
 {
     lv_matrix_t mtx;
     _setup_matrix(&mtx, dsc, obj);
 
     if(matrix) {
-        lv_matrix_multiply(&dsc->current_dsc.matrix, matrix);
+        lv_matrix_multiply(&dsc->ctx->matrix, matrix);
     }
 
     lv_svg_render_line_t * line = (lv_svg_render_line_t *)obj;
@@ -1392,30 +1392,30 @@ static void _render_line(const lv_svg_render_obj_t * obj, lv_vector_dsc_t * dsc,
     lv_vector_path_line_to(path, &ep);
 
     _copy_draw_dsc_from_ref(dsc, obj);
-    lv_vector_dsc_add_path(dsc, path);
+    lv_draw_vector_dsc_add_path(dsc, path);
     lv_vector_path_delete(path);
 
     _restore_matrix(&mtx, dsc);
 }
 
-static void _render_poly(const lv_svg_render_obj_t * obj, lv_vector_dsc_t * dsc, const lv_matrix_t * matrix)
+static void _render_poly(const lv_svg_render_obj_t * obj, lv_draw_vector_dsc_t * dsc, const lv_matrix_t * matrix)
 {
     lv_matrix_t mtx;
     _setup_matrix(&mtx, dsc, obj);
 
     if(matrix) {
-        lv_matrix_multiply(&dsc->current_dsc.matrix, matrix);
+        lv_matrix_multiply(&dsc->ctx->matrix, matrix);
     }
 
     lv_svg_render_poly_t * poly = (lv_svg_render_poly_t *)obj;
 
     _copy_draw_dsc_from_ref(dsc, obj);
-    lv_vector_dsc_add_path(dsc, poly->path);
+    lv_draw_vector_dsc_add_path(dsc, poly->path);
 
     _restore_matrix(&mtx, dsc);
 }
 
-static void _render_group(const lv_svg_render_obj_t * obj, lv_vector_dsc_t * dsc, const lv_matrix_t * matrix)
+static void _render_group(const lv_svg_render_obj_t * obj, lv_draw_vector_dsc_t * dsc, const lv_matrix_t * matrix)
 {
     lv_svg_render_group_t * group = (lv_svg_render_group_t *)obj;
     lv_matrix_t mtx;
@@ -1428,23 +1428,23 @@ static void _render_group(const lv_svg_render_obj_t * obj, lv_vector_dsc_t * dsc
         lv_svg_render_obj_t * list = *((lv_svg_render_obj_t **)lv_array_at(&group->items, i));
 
         if(list->clz->render && (list->flags & _RENDER_IN_GROUP)) {
-            _copy_draw_dsc(&(save_dsc.dsc), &(dsc->current_dsc));
+            _copy_draw_dsc(&(save_dsc.dsc), dsc->ctx);
             _special_render(list, dsc);
             list->clz->render(list, dsc, matrix);
-            _copy_draw_dsc(&(dsc->current_dsc), &(save_dsc.dsc));
+            _copy_draw_dsc(dsc->ctx, &(save_dsc.dsc));
         }
     }
 
     _restore_matrix(&mtx, dsc);
 }
 
-static void _render_image(const lv_svg_render_obj_t * obj, lv_vector_dsc_t * dsc, const lv_matrix_t * matrix)
+static void _render_image(const lv_svg_render_obj_t * obj, lv_draw_vector_dsc_t * dsc, const lv_matrix_t * matrix)
 {
     lv_matrix_t imtx;
     _setup_matrix(&imtx, dsc, obj);
 
     if(matrix) {
-        lv_matrix_multiply(&dsc->current_dsc.matrix, matrix);
+        lv_matrix_multiply(&dsc->ctx->matrix, matrix);
     }
 
     lv_svg_render_image_t * image = (lv_svg_render_image_t *)obj;
@@ -1535,17 +1535,17 @@ static void _render_image(const lv_svg_render_obj_t * obj, lv_vector_dsc_t * dsc
             break;
     }
 
-    lv_vector_dsc_set_fill_transform(dsc, &mtx);
-    lv_vector_dsc_set_fill_image(dsc, &image->img_dsc);
+    lv_draw_vector_dsc_set_fill_transform(dsc, &mtx);
+    lv_draw_vector_dsc_set_fill_image(dsc, &image->img_dsc);
 
     _copy_draw_dsc_from_ref(dsc, obj);
-    lv_vector_dsc_add_path(dsc, path);
+    lv_draw_vector_dsc_add_path(dsc, path);
     lv_vector_path_delete(path);
 
     _restore_matrix(&imtx, dsc);
 }
 
-static void _render_use(const lv_svg_render_obj_t * obj, lv_vector_dsc_t * dsc, const lv_matrix_t * matrix)
+static void _render_use(const lv_svg_render_obj_t * obj, lv_draw_vector_dsc_t * dsc, const lv_matrix_t * matrix)
 {
     LV_UNUSED(matrix);
     lv_matrix_t imtx;
@@ -1582,7 +1582,7 @@ static bool _is_control_character(uint32_t ch)
     return ch == '\n' || ch == '\t' || ch == '\r';
 }
 
-static void _render_text(const lv_svg_render_obj_t * obj, lv_vector_dsc_t * dsc, const lv_matrix_t * matrix)
+static void _render_text(const lv_svg_render_obj_t * obj, lv_draw_vector_dsc_t * dsc, const lv_matrix_t * matrix)
 {
     lv_svg_render_text_t * text = (lv_svg_render_text_t *)obj;
     if(!text->font) {
@@ -1606,7 +1606,7 @@ static void _render_text(const lv_svg_render_obj_t * obj, lv_vector_dsc_t * dsc,
     _setup_matrix(&tmtx, dsc, obj);
 
     if(matrix) {
-        lv_matrix_multiply(&dsc->current_dsc.matrix, matrix);
+        lv_matrix_multiply(&dsc->ctx->matrix, matrix);
     }
 
     bool build_path = false;
@@ -1660,12 +1660,12 @@ static void _render_text(const lv_svg_render_obj_t * obj, lv_vector_dsc_t * dsc,
     }
 
     _copy_draw_dsc_from_ref(dsc, obj);
-    lv_vector_dsc_add_path(dsc, text->path);
+    lv_draw_vector_dsc_add_path(dsc, text->path);
 
     _restore_matrix(&tmtx, dsc);
 }
 
-static void _render_span(const lv_svg_render_content_t * content, lv_vector_dsc_t * dsc, lv_matrix_t * matrix)
+static void _render_span(const lv_svg_render_content_t * content, lv_draw_vector_dsc_t * dsc, lv_matrix_t * matrix)
 {
     lv_svg_render_obj_t * obj = (lv_svg_render_obj_t *)content;
 
@@ -1689,9 +1689,9 @@ static void _render_span(const lv_svg_render_content_t * content, lv_vector_dsc_
 
     struct _lv_svg_draw_dsc save_dsc;
     lv_memzero(&save_dsc, sizeof(struct _lv_svg_draw_dsc));
-    _copy_draw_dsc(&(save_dsc.dsc), &(dsc->current_dsc));
+    _copy_draw_dsc(&(save_dsc.dsc), dsc->ctx);
 
-    _copy_draw_dsc(&(dsc->current_dsc), &(obj->dsc));
+    _copy_draw_dsc(dsc->ctx, &(obj->dsc));
 
     if(lv_array_size(&span->path->ops) == 0) { /* empty path */
         lv_vector_path_t * glyph_path = lv_vector_path_create(LV_VECTOR_PATH_QUALITY_MEDIUM);
@@ -1725,9 +1725,9 @@ static void _render_span(const lv_svg_render_content_t * content, lv_vector_dsc_
         lv_vector_path_get_bounding(span->path, &span->bounds);
     }
     _copy_draw_dsc_from_ref(dsc, obj);
-    lv_vector_dsc_add_path(dsc, span->path);
+    lv_draw_vector_dsc_add_path(dsc, span->path);
 
-    _copy_draw_dsc(&(dsc->current_dsc), &(save_dsc.dsc));
+    _copy_draw_dsc(dsc->ctx, &(save_dsc.dsc));
 }
 #endif
 
@@ -2554,7 +2554,7 @@ lv_result_t lv_svg_render_get_viewport_size(const lv_svg_render_obj_t * render,
     return LV_RESULT_OK;
 }
 
-void lv_draw_svg_render(lv_vector_dsc_t * dsc, const lv_svg_render_obj_t * render)
+void lv_draw_svg_render(lv_draw_vector_dsc_t * dsc, const lv_svg_render_obj_t * render)
 {
     if(!render || !dsc) {
         return;
@@ -2576,12 +2576,12 @@ void lv_draw_svg(lv_layer_t * layer, const lv_svg_node_t * svg_doc)
         return;
     }
 
-    lv_vector_dsc_t * dsc = lv_vector_dsc_create(layer);
+    lv_draw_vector_dsc_t * dsc = lv_draw_vector_dsc_create(layer);
     lv_svg_render_obj_t * list = lv_svg_render_create(svg_doc);
     lv_draw_svg_render(dsc, list);
     lv_draw_vector(dsc);
     lv_svg_render_delete(list);
-    lv_vector_dsc_delete(dsc);
+    lv_draw_vector_dsc_delete(dsc);
 }
 
 /**********************
diff --git a/src/libs/svg/lv_svg_render.h b/src/libs/svg/lv_svg_render.h
index d2e87860c0..e2578bf54f 100644
--- a/src/libs/svg/lv_svg_render.h
+++ b/src/libs/svg/lv_svg_render.h
@@ -36,7 +36,7 @@ typedef struct _lv_svg_render_obj {
     lv_svg_tag_t tag;
     uint32_t flags;
     char * id;
-    lv_vector_draw_dsc_t dsc;
+    lv_vector_path_ctx_t dsc;
     lv_matrix_t matrix;
 
     /* for url(XXX) reference */
@@ -47,12 +47,12 @@ typedef struct _lv_svg_render_obj {
 } lv_svg_render_obj_t;
 
 typedef struct _lv_svg_render_class {
-    void (*set_paint_ref)(struct _lv_svg_render_obj * obj, lv_vector_draw_dsc_t * dsc,
+    void (*set_paint_ref)(struct _lv_svg_render_obj * obj, lv_vector_path_ctx_t * dsc,
                           const struct _lv_svg_render_obj * target_obj, bool fill);
 
     void (*init)(struct _lv_svg_render_obj * obj, const lv_svg_node_t * node);
-    void (*render)(const struct _lv_svg_render_obj * obj, lv_vector_dsc_t * dsc, const lv_matrix_t * matrix);
-    void (*set_attr)(struct _lv_svg_render_obj * obj, lv_vector_draw_dsc_t * dsc, const lv_svg_attr_t * attr);
+    void (*render)(const struct _lv_svg_render_obj * obj, lv_draw_vector_dsc_t * dsc, const lv_matrix_t * matrix);
+    void (*set_attr)(struct _lv_svg_render_obj * obj, lv_vector_path_ctx_t * dsc, const lv_svg_attr_t * attr);
     void (*get_bounds)(const struct _lv_svg_render_obj * obj, lv_area_t * area);
     void (*get_size)(const struct _lv_svg_render_obj * obj, uint32_t * size);
     void (*destroy)(struct _lv_svg_render_obj * obj);
@@ -107,7 +107,7 @@ lv_result_t lv_svg_render_get_viewport_size(const lv_svg_render_obj_t * render,
  * @param dsc pointer to the vector graphics descriptor
  * @param render pointer to the SVG render object to render
  */
-void lv_draw_svg_render(lv_vector_dsc_t * dsc, const lv_svg_render_obj_t * render);
+void lv_draw_svg_render(lv_draw_vector_dsc_t * dsc, const lv_svg_render_obj_t * render);
 
 /**
  * @brief Draw an SVG document to a layer
diff --git a/src/lv_api_map_v9_3.h b/src/lv_api_map_v9_3.h
index 834cc8dd6a..d6ec98d6c8 100644
--- a/src/lv_api_map_v9_3.h
+++ b/src/lv_api_map_v9_3.h
@@ -53,6 +53,42 @@ extern "C" {
 #define lv_glfw_texture_get_mouse_indev  lv_opengles_window_texture_get_mouse_indev
 #define lv_glfw_window_get_glfw_window   lv_opengles_glfw_window_get_glfw_window
 
+#define lv_vector_dsc_create                        lv_draw_vector_dsc_create
+#define lv_vector_dsc_delete                        lv_draw_vector_dsc_delete
+#define lv_vector_dsc_set_transform                 lv_draw_vector_dsc_set_transform
+#define lv_vector_dsc_set_blend_mode                lv_draw_vector_dsc_set_blend_mode
+#define lv_vector_dsc_set_fill_color32              lv_draw_vector_dsc_set_fill_color32
+#define lv_vector_dsc_set_fill_color                lv_draw_vector_dsc_set_fill_color
+#define lv_vector_dsc_set_fill_opa                  lv_draw_vector_dsc_set_fill_opa
+#define lv_vector_dsc_set_fill_rule                 lv_draw_vector_dsc_set_fill_rule
+#define lv_vector_dsc_set_fill_units                lv_draw_vector_dsc_set_fill_units
+#define lv_vector_dsc_set_fill_image                lv_draw_vector_dsc_set_fill_image
+#define lv_vector_dsc_set_fill_linear_gradient      lv_draw_vector_dsc_set_fill_linear_gradient
+#define lv_vector_dsc_set_fill_radial_gradient      lv_draw_vector_dsc_set_fill_radial_gradient
+#define lv_vector_dsc_set_fill_gradient_spread      lv_draw_vector_dsc_set_fill_gradient_spread
+#define lv_vector_dsc_set_fill_gradient_color_stops lv_draw_vector_dsc_set_fill_gradient_color_stops
+#define lv_vector_dsc_set_fill_transform            lv_draw_vector_dsc_set_fill_transform
+#define lv_vector_dsc_set_stroke_color32            lv_draw_vector_dsc_set_stroke_color32
+#define lv_vector_dsc_set_stroke_color              lv_draw_vector_dsc_set_stroke_color
+#define lv_vector_dsc_set_stroke_opa                lv_draw_vector_dsc_set_stroke_opa
+#define lv_vector_dsc_set_stroke_width              lv_draw_vector_dsc_set_stroke_width
+#define lv_vector_dsc_set_stroke_dash               lv_draw_vector_dsc_set_stroke_dash
+#define lv_vector_dsc_set_stroke_cap                lv_draw_vector_dsc_set_stroke_cap
+#define lv_vector_dsc_set_stroke_join               lv_draw_vector_dsc_set_stroke_join
+#define lv_vector_dsc_set_stroke_miter_limit        lv_draw_vector_dsc_set_stroke_miter_limit
+#define lv_vector_dsc_set_stroke_linear_gradient    lv_draw_vector_dsc_set_stroke_linear_gradient
+#define lv_vector_dsc_set_stroke_radial_gradient    lv_draw_vector_dsc_set_stroke_radial_gradient
+#define lv_vector_dsc_set_stroke_gradient_spread    lv_draw_vector_dsc_set_stroke_gradient_spread
+#define lv_vector_dsc_set_stroke_gradient_color_stops lv_draw_vector_dsc_set_stroke_gradient_color_stops
+#define lv_vector_dsc_set_stroke_transform          lv_draw_vector_dsc_set_stroke_transform
+#define lv_vector_dsc_identity                      lv_draw_vector_dsc_identity
+#define lv_vector_dsc_scale                         lv_draw_vector_dsc_scale
+#define lv_vector_dsc_rotate                        lv_draw_vector_dsc_rotate
+#define lv_vector_dsc_translate                     lv_draw_vector_dsc_translate
+#define lv_vector_dsc_skew                          lv_draw_vector_dsc_skew
+#define lv_vector_dsc_add_path                      lv_draw_vector_dsc_add_path
+#define lv_vector_dsc_clear_area                    lv_draw_vector_dsc_clear_area
+
 
 #ifdef __cplusplus
 } /*extern "C"*/
diff --git a/src/misc/lv_types.h b/src/misc/lv_types.h
index 5cf65cf2ab..914a007e94 100644
--- a/src/misc/lv_types.h
+++ b/src/misc/lv_types.h
@@ -308,11 +308,9 @@ typedef struct _lv_vector_fill_dsc_t lv_vector_fill_dsc_t;
 
 typedef struct _lv_vector_stroke_dsc_t lv_vector_stroke_dsc_t;
 
-typedef struct _lv_vector_draw_dsc_t lv_vector_draw_dsc_t;
+typedef struct _lv_vector_path_ctx_t lv_vector_path_ctx_t;
 
-typedef struct _lv_draw_vector_task_dsc_t lv_draw_vector_task_dsc_t;
-
-typedef struct _lv_vector_dsc_t lv_vector_dsc_t;
+typedef struct _lv_draw_vector_dsc_t lv_draw_vector_dsc_t;
 
 typedef struct _lv_xkb_t lv_xkb_t;
 
diff --git a/tests/src/test_cases/draw/test_draw_vector.c b/tests/src/test_cases/draw/test_draw_vector.c
index 1a42eb6f8f..e3e410751d 100644
--- a/tests/src/test_cases/draw/test_draw_vector.c
+++ b/tests/src/test_cases/draw/test_draw_vector.c
@@ -34,38 +34,38 @@ void tearDown(void)
 
 static void draw_shapes(lv_layer_t * layer, const lv_matrix_t * transform)
 {
-    lv_vector_dsc_t * ctx = lv_vector_dsc_create(layer);
-    lv_vector_dsc_set_transform(ctx, transform);
+    lv_draw_vector_dsc_t * ctx = lv_draw_vector_dsc_create(layer);
+    lv_draw_vector_dsc_set_transform(ctx, transform);
 
     lv_area_t rect = {0, 0, 640, 480};
-    lv_vector_dsc_set_fill_color(ctx, lv_color_white());
+    lv_draw_vector_dsc_set_fill_color(ctx, lv_color_white());
     rect = lv_matrix_transform_area(transform, &rect);
-    lv_vector_clear_area(ctx, &rect);
+    lv_draw_vector_dsc_clear_area(ctx, &rect);
 
     lv_vector_path_t * path = lv_vector_path_create(LV_VECTOR_PATH_QUALITY_MEDIUM);
 
     lv_area_t rect1 = {50, 50, 150, 150};
-    lv_vector_dsc_set_transform(ctx, transform);
+    lv_draw_vector_dsc_set_transform(ctx, transform);
     lv_vector_path_clear(path);
     lv_vector_path_append_rect(path, &rect1, 0, 0);
-    lv_vector_dsc_set_fill_color(ctx, lv_color_make(0xff, 0x00, 0x00));
-    lv_vector_dsc_add_path(ctx, path);
+    lv_draw_vector_dsc_set_fill_color(ctx, lv_color_make(0xff, 0x00, 0x00));
+    lv_draw_vector_dsc_add_path(ctx, path);
 
     lv_vector_path_clear(path);
     lv_vector_path_append_rect(path, &rect1, 20, 20);
-    lv_vector_dsc_translate(ctx, 150, 0);
-    lv_vector_dsc_set_fill_color(ctx, lv_color_make(0x00, 0x00, 0xff));
-    lv_vector_dsc_add_path(ctx, path);
+    lv_draw_vector_dsc_translate(ctx, 150, 0);
+    lv_draw_vector_dsc_set_fill_color(ctx, lv_color_make(0x00, 0x00, 0xff));
+    lv_draw_vector_dsc_add_path(ctx, path);
 
     lv_fpoint_t pc = {100, 100};
     lv_vector_path_clear(path);
     lv_vector_path_append_circle(path, &pc, 50, 50);
-    lv_vector_dsc_translate(ctx, 150, 0);
-    lv_vector_dsc_set_fill_color32(ctx, lv_color_to_32(lv_color_make(0x00, 0xff, 0x00), 0x80));
-    lv_vector_dsc_add_path(ctx, path);
+    lv_draw_vector_dsc_translate(ctx, 150, 0);
+    lv_draw_vector_dsc_set_fill_color32(ctx, lv_color_to_32(lv_color_make(0x00, 0xff, 0x00), 0x80));
+    lv_draw_vector_dsc_add_path(ctx, path);
 
-    lv_vector_dsc_set_transform(ctx, transform);
-    lv_vector_dsc_translate(ctx, 0, 150);
+    lv_draw_vector_dsc_set_transform(ctx, transform);
+    lv_draw_vector_dsc_translate(ctx, 0, 150);
 
     lv_grad_stop_t stops[2];
     lv_memzero(stops, sizeof(stops));
@@ -78,60 +78,60 @@ static void draw_shapes(lv_layer_t * layer, const lv_matrix_t * transform)
 
     lv_matrix_t mt;
     lv_matrix_identity(&mt);
-    lv_vector_dsc_set_fill_transform(ctx, &mt);
-    lv_vector_dsc_set_fill_radial_gradient(ctx, 100, 100, 50);
-    lv_vector_dsc_set_fill_gradient_color_stops(ctx, stops, 2);
-    lv_vector_dsc_set_fill_gradient_spread(ctx, LV_VECTOR_GRADIENT_SPREAD_PAD);
-    lv_vector_dsc_add_path(ctx, path);
+    lv_draw_vector_dsc_set_fill_transform(ctx, &mt);
+    lv_draw_vector_dsc_set_fill_radial_gradient(ctx, 100, 100, 50);
+    lv_draw_vector_dsc_set_fill_gradient_color_stops(ctx, stops, 2);
+    lv_draw_vector_dsc_set_fill_gradient_spread(ctx, LV_VECTOR_GRADIENT_SPREAD_PAD);
+    lv_draw_vector_dsc_add_path(ctx, path);
 
-    lv_vector_dsc_set_transform(ctx, transform);
-    lv_vector_dsc_translate(ctx, 150, 150);
+    lv_draw_vector_dsc_set_transform(ctx, transform);
+    lv_draw_vector_dsc_translate(ctx, 150, 150);
     lv_draw_image_dsc_t img_dsc;
     lv_draw_image_dsc_init(&img_dsc);
     LV_IMAGE_DECLARE(test_image_cogwheel_argb8888);
     img_dsc.header = test_image_cogwheel_argb8888.header;
     img_dsc.src = &test_image_cogwheel_argb8888;
-    lv_vector_dsc_set_fill_image(ctx, &img_dsc);
+    lv_draw_vector_dsc_set_fill_image(ctx, &img_dsc);
     lv_matrix_identity(&mt);
     lv_matrix_translate(&mt, 50, 50);
     //lv_matrix_rotate(&mt, 45);
     //lv_matrix_scale(&mt, 1.5f, 1.5f);
     lv_matrix_translate(&mt, -50, -50);
-    lv_vector_dsc_set_fill_transform(ctx, &mt);
-    lv_vector_dsc_add_path(ctx, path);
+    lv_draw_vector_dsc_set_fill_transform(ctx, &mt);
+    lv_draw_vector_dsc_add_path(ctx, path);
 
-    lv_vector_dsc_set_transform(ctx, transform);
-    lv_vector_dsc_translate(ctx, 300, 150);
-    lv_vector_dsc_set_fill_color(ctx, lv_color_make(0xff, 0x00, 0x00));
-    lv_vector_dsc_add_path(ctx, path);
+    lv_draw_vector_dsc_set_transform(ctx, transform);
+    lv_draw_vector_dsc_translate(ctx, 300, 150);
+    lv_draw_vector_dsc_set_fill_color(ctx, lv_color_make(0xff, 0x00, 0x00));
+    lv_draw_vector_dsc_add_path(ctx, path);
 
     lv_vector_path_clear(path);
     lv_vector_path_append_rect(path, &rect1, 20, 20);
     lv_area_t rect2 = {80, 80, 120, 120};
     lv_vector_path_append_rect(path, &rect2, 15, 15);
-    lv_vector_dsc_translate(ctx, 50, 0);
-    lv_vector_dsc_set_fill_color(ctx, lv_color_make(0x00, 0x80, 0xff));
-    lv_vector_dsc_set_blend_mode(ctx, LV_VECTOR_BLEND_MULTIPLY);
-    lv_vector_dsc_set_fill_rule(ctx, LV_VECTOR_FILL_EVENODD);
-    lv_vector_dsc_add_path(ctx, path);
+    lv_draw_vector_dsc_translate(ctx, 50, 0);
+    lv_draw_vector_dsc_set_fill_color(ctx, lv_color_make(0x00, 0x80, 0xff));
+    lv_draw_vector_dsc_set_blend_mode(ctx, LV_VECTOR_BLEND_MULTIPLY);
+    lv_draw_vector_dsc_set_fill_rule(ctx, LV_VECTOR_FILL_EVENODD);
+    lv_draw_vector_dsc_add_path(ctx, path);
 
     lv_vector_path_clear(path);
-    lv_vector_dsc_set_transform(ctx, transform);
-    lv_vector_dsc_set_blend_mode(ctx, LV_VECTOR_BLEND_SRC_OVER);
+    lv_draw_vector_dsc_set_transform(ctx, transform);
+    lv_draw_vector_dsc_set_blend_mode(ctx, LV_VECTOR_BLEND_SRC_OVER);
 
     rect = (lv_area_t) {
         500, 50, 550, 100
     };
-    lv_vector_dsc_set_fill_color(ctx, lv_color_lighten(lv_color_black(), 50));
+    lv_draw_vector_dsc_set_fill_color(ctx, lv_color_lighten(lv_color_black(), 50));
     rect = lv_matrix_transform_area(transform, &rect);
-    lv_vector_clear_area(ctx, &rect); // clear screen
+    lv_draw_vector_dsc_clear_area(ctx, &rect); // clear screen
 
     lv_fpoint_t p = {500, 100}; /* Center */
-    lv_vector_dsc_set_stroke_color(ctx, lv_color_make(0x00, 0xff, 0xff));
-    lv_vector_dsc_set_stroke_opa(ctx, LV_OPA_COVER);
-    lv_vector_dsc_set_stroke_width(ctx, 2.0f);
-    lv_vector_dsc_set_stroke_dash(ctx, NULL, 0);
-    lv_vector_dsc_set_fill_opa(ctx, LV_OPA_TRANSP);
+    lv_draw_vector_dsc_set_stroke_color(ctx, lv_color_make(0x00, 0xff, 0xff));
+    lv_draw_vector_dsc_set_stroke_opa(ctx, LV_OPA_COVER);
+    lv_draw_vector_dsc_set_stroke_width(ctx, 2.0f);
+    lv_draw_vector_dsc_set_stroke_dash(ctx, NULL, 0);
+    lv_draw_vector_dsc_set_fill_opa(ctx, LV_OPA_TRANSP);
     lv_vector_path_move_to(path, &p);
     lv_fpoint_t temp = {p.x + 50, p.y};
     lv_vector_path_line_to(path, &temp);
@@ -139,30 +139,30 @@ static void draw_shapes(lv_layer_t * layer, const lv_matrix_t * transform)
     lv_vector_path_line_to(path, &p);
     lv_vector_path_close(path);
 
-    lv_vector_dsc_add_path(ctx, path);
+    lv_draw_vector_dsc_add_path(ctx, path);
 
     /* Below code has same effect as above one but with solid fill */
-    lv_vector_dsc_set_fill_color(ctx, lv_color_make(0xFF, 0x00, 0x00));
-    lv_vector_dsc_set_fill_opa(ctx, LV_OPA_COVER);
+    lv_draw_vector_dsc_set_fill_color(ctx, lv_color_make(0xFF, 0x00, 0x00));
+    lv_draw_vector_dsc_set_fill_opa(ctx, LV_OPA_COVER);
     lv_vector_path_clear(path);
     lv_vector_path_append_arc(path, &p, 50, 45, 45, true);
-    lv_vector_dsc_add_path(ctx, path); // draw a path
+    lv_draw_vector_dsc_add_path(ctx, path); // draw a path
 
     /* Test image filling with absolute coordinates */
-    lv_vector_dsc_set_transform(ctx, transform);
-    lv_vector_dsc_set_fill_units(ctx, LV_VECTOR_FILL_UNITS_USER_SPACE_ON_USE);
-    lv_vector_dsc_set_fill_image(ctx, &img_dsc);
-    lv_vector_dsc_set_fill_opa(ctx, LV_OPA_50);
-    lv_vector_dsc_set_stroke_opa(ctx, LV_OPA_TRANSP);
+    lv_draw_vector_dsc_set_transform(ctx, transform);
+    lv_draw_vector_dsc_set_fill_units(ctx, LV_VECTOR_FILL_UNITS_USER_SPACE_ON_USE);
+    lv_draw_vector_dsc_set_fill_image(ctx, &img_dsc);
+    lv_draw_vector_dsc_set_fill_opa(ctx, LV_OPA_50);
+    lv_draw_vector_dsc_set_stroke_opa(ctx, LV_OPA_TRANSP);
     lv_matrix_identity(&mt);
     lv_matrix_translate(&mt, 50, 350);
-    lv_vector_dsc_set_fill_transform(ctx, &mt);
+    lv_draw_vector_dsc_set_fill_transform(ctx, &mt);
 
     lv_vector_path_clear(path);
     /* Aligned with translate. Image resolution is 100x100, cropped to 50% of width and height */
     lv_area_t img_area = {50, 350, 50 + 50, 350 + 50};
     lv_vector_path_append_rect(path, &img_area, 0, 0);
-    lv_vector_dsc_add_path(ctx, path);
+    lv_draw_vector_dsc_add_path(ctx, path);
 
     /* Test PNG image file */
     lv_vector_path_clear(path);
@@ -173,96 +173,96 @@ static void draw_shapes(lv_layer_t * layer, const lv_matrix_t * transform)
 
     lv_draw_image_dsc_init(&img_dsc);
     img_dsc.src = "A:src/test_assets/test_img_lvgl_logo.png";
-    lv_vector_dsc_set_transform(ctx, transform);
-    lv_vector_dsc_set_fill_units(ctx, LV_VECTOR_FILL_UNITS_OBJECT_BOUNDING_BOX);
-    lv_vector_dsc_set_fill_image(ctx, &img_dsc);
-    lv_vector_dsc_set_fill_opa(ctx, LV_OPA_COVER);
+    lv_draw_vector_dsc_set_transform(ctx, transform);
+    lv_draw_vector_dsc_set_fill_units(ctx, LV_VECTOR_FILL_UNITS_OBJECT_BOUNDING_BOX);
+    lv_draw_vector_dsc_set_fill_image(ctx, &img_dsc);
+    lv_draw_vector_dsc_set_fill_opa(ctx, LV_OPA_COVER);
 
     lv_matrix_identity(&mt);
-    lv_vector_dsc_set_fill_transform(ctx, &mt);
-    lv_vector_dsc_add_path(ctx, path);
+    lv_draw_vector_dsc_set_fill_transform(ctx, &mt);
+    lv_draw_vector_dsc_add_path(ctx, path);
 
     lv_draw_vector(ctx);
     lv_vector_path_delete(path);
-    lv_vector_dsc_delete(ctx);
+    lv_draw_vector_dsc_delete(ctx);
 }
 
 static void draw_lines(lv_layer_t * layer, const lv_matrix_t * transform)
 {
-    lv_vector_dsc_t * ctx = lv_vector_dsc_create(layer);
-    lv_vector_dsc_set_transform(ctx, transform);
+    lv_draw_vector_dsc_t * ctx = lv_draw_vector_dsc_create(layer);
+    lv_draw_vector_dsc_set_transform(ctx, transform);
 
     lv_area_t rect = {0, 0, 640, 480};
-    lv_vector_dsc_set_fill_color(ctx, lv_color_white());
+    lv_draw_vector_dsc_set_fill_color(ctx, lv_color_white());
     rect = lv_matrix_transform_area(transform, &rect);
-    lv_vector_clear_area(ctx, &rect);
+    lv_draw_vector_dsc_clear_area(ctx, &rect);
 
     lv_vector_path_t * path = lv_vector_path_create(LV_VECTOR_PATH_QUALITY_MEDIUM);
 
-    lv_vector_dsc_set_stroke_opa(ctx, LV_OPA_COVER);
-    lv_vector_dsc_set_fill_opa(ctx, LV_OPA_0);
+    lv_draw_vector_dsc_set_stroke_opa(ctx, LV_OPA_COVER);
+    lv_draw_vector_dsc_set_fill_opa(ctx, LV_OPA_0);
 
     lv_fpoint_t pts1[] = {{50, 50}, {400, 50}};
     lv_vector_path_clear(path);
     lv_vector_path_move_to(path, &pts1[0]);
     lv_vector_path_line_to(path, &pts1[1]);
-    lv_vector_dsc_add_path(ctx, path);
+    lv_draw_vector_dsc_add_path(ctx, path);
 
     lv_fpoint_t pts2[] = {{50, 80}, {400, 80}};
     lv_vector_path_clear(path);
     lv_vector_path_move_to(path, &pts2[0]);
     lv_vector_path_line_to(path, &pts2[1]);
-    lv_vector_dsc_set_stroke_color(ctx, lv_color_make(0xff, 0x00, 0x00));
-    lv_vector_dsc_set_stroke_width(ctx, 3.0f);
-    lv_vector_dsc_add_path(ctx, path);
+    lv_draw_vector_dsc_set_stroke_color(ctx, lv_color_make(0xff, 0x00, 0x00));
+    lv_draw_vector_dsc_set_stroke_width(ctx, 3.0f);
+    lv_draw_vector_dsc_add_path(ctx, path);
 
     lv_fpoint_t pts3[] = {{50, 120}, {400, 120}};
     lv_vector_path_clear(path);
     lv_vector_path_move_to(path, &pts3[0]);
     lv_vector_path_line_to(path, &pts3[1]);
-    lv_vector_dsc_set_stroke_color(ctx, lv_color_make(0x00, 0xff, 0x00));
-    lv_vector_dsc_set_stroke_width(ctx, 5.0f);
+    lv_draw_vector_dsc_set_stroke_color(ctx, lv_color_make(0x00, 0xff, 0x00));
+    lv_draw_vector_dsc_set_stroke_width(ctx, 5.0f);
     float dashes[] = {10, 15, 20, 12};
-    lv_vector_dsc_set_stroke_dash(ctx, dashes, 4);
-    lv_vector_dsc_add_path(ctx, path);
+    lv_draw_vector_dsc_set_stroke_dash(ctx, dashes, 4);
+    lv_draw_vector_dsc_add_path(ctx, path);
 
     lv_fpoint_t pts4[] = {{100, 150}, {50, 250}, {150, 250}};
     lv_vector_path_clear(path);
     lv_vector_path_move_to(path, &pts4[0]);
     lv_vector_path_line_to(path, &pts4[1]);
     lv_vector_path_line_to(path, &pts4[2]);
-    lv_vector_dsc_set_stroke_color(ctx, lv_color_make(0x00, 0x00, 0x00));
-    lv_vector_dsc_set_stroke_width(ctx, 10.0f);
-    lv_vector_dsc_set_stroke_dash(ctx, NULL, 0);
-    lv_vector_dsc_set_stroke_join(ctx, LV_VECTOR_STROKE_JOIN_MITER);
-    lv_vector_dsc_add_path(ctx, path);
+    lv_draw_vector_dsc_set_stroke_color(ctx, lv_color_make(0x00, 0x00, 0x00));
+    lv_draw_vector_dsc_set_stroke_width(ctx, 10.0f);
+    lv_draw_vector_dsc_set_stroke_dash(ctx, NULL, 0);
+    lv_draw_vector_dsc_set_stroke_join(ctx, LV_VECTOR_STROKE_JOIN_MITER);
+    lv_draw_vector_dsc_add_path(ctx, path);
 
-    lv_vector_dsc_translate(ctx, 150, 0);
-    lv_vector_dsc_set_stroke_join(ctx, LV_VECTOR_STROKE_JOIN_BEVEL);
-    lv_vector_dsc_add_path(ctx, path);
+    lv_draw_vector_dsc_translate(ctx, 150, 0);
+    lv_draw_vector_dsc_set_stroke_join(ctx, LV_VECTOR_STROKE_JOIN_BEVEL);
+    lv_draw_vector_dsc_add_path(ctx, path);
 
-    lv_vector_dsc_translate(ctx, 150, 0);
-    lv_vector_dsc_set_stroke_join(ctx, LV_VECTOR_STROKE_JOIN_ROUND);
-    lv_vector_dsc_add_path(ctx, path);
+    lv_draw_vector_dsc_translate(ctx, 150, 0);
+    lv_draw_vector_dsc_set_stroke_join(ctx, LV_VECTOR_STROKE_JOIN_ROUND);
+    lv_draw_vector_dsc_add_path(ctx, path);
 
     lv_fpoint_t pts5[] = {{50, 300}, {150, 300}};
-    lv_vector_dsc_set_transform(ctx, transform);
+    lv_draw_vector_dsc_set_transform(ctx, transform);
     lv_vector_path_clear(path);
     lv_vector_path_move_to(path, &pts5[0]);
     lv_vector_path_line_to(path, &pts5[1]);
-    lv_vector_dsc_set_stroke_cap(ctx, LV_VECTOR_STROKE_CAP_BUTT);
-    lv_vector_dsc_add_path(ctx, path);
+    lv_draw_vector_dsc_set_stroke_cap(ctx, LV_VECTOR_STROKE_CAP_BUTT);
+    lv_draw_vector_dsc_add_path(ctx, path);
 
-    lv_vector_dsc_translate(ctx, 0, 40);
-    lv_vector_dsc_set_stroke_cap(ctx, LV_VECTOR_STROKE_CAP_SQUARE);
-    lv_vector_dsc_add_path(ctx, path);
+    lv_draw_vector_dsc_translate(ctx, 0, 40);
+    lv_draw_vector_dsc_set_stroke_cap(ctx, LV_VECTOR_STROKE_CAP_SQUARE);
+    lv_draw_vector_dsc_add_path(ctx, path);
 
-    lv_vector_dsc_translate(ctx, 0, 40);
-    lv_vector_dsc_set_stroke_cap(ctx, LV_VECTOR_STROKE_CAP_ROUND);
-    lv_vector_dsc_add_path(ctx, path);
+    lv_draw_vector_dsc_translate(ctx, 0, 40);
+    lv_draw_vector_dsc_set_stroke_cap(ctx, LV_VECTOR_STROKE_CAP_ROUND);
+    lv_draw_vector_dsc_add_path(ctx, path);
 
     lv_area_t rect1 = {250, 300, 350, 400};
-    lv_vector_dsc_set_transform(ctx, transform);
+    lv_draw_vector_dsc_set_transform(ctx, transform);
     lv_vector_path_clear(path);
     lv_vector_path_append_rect(path, &rect1, 0, 0);
 
@@ -279,16 +279,16 @@ static void draw_lines(lv_layer_t * layer, const lv_matrix_t * transform)
     lv_matrix_identity(&mt);
     lv_matrix_rotate(&mt, 5);
     lv_matrix_translate(&mt, 20, 20);
-    lv_vector_dsc_set_stroke_transform(ctx, &mt);
-    lv_vector_dsc_set_stroke_join(ctx, LV_VECTOR_STROKE_JOIN_MITER);
-    lv_vector_dsc_set_stroke_linear_gradient(ctx, 250, 300, 350, 300);
-    lv_vector_dsc_set_stroke_gradient_color_stops(ctx, stops, 2);
-    lv_vector_dsc_set_stroke_gradient_spread(ctx, LV_VECTOR_GRADIENT_SPREAD_REFLECT);
-    lv_vector_dsc_add_path(ctx, path); // draw a path
+    lv_draw_vector_dsc_set_stroke_transform(ctx, &mt);
+    lv_draw_vector_dsc_set_stroke_join(ctx, LV_VECTOR_STROKE_JOIN_MITER);
+    lv_draw_vector_dsc_set_stroke_linear_gradient(ctx, 250, 300, 350, 300);
+    lv_draw_vector_dsc_set_stroke_gradient_color_stops(ctx, stops, 2);
+    lv_draw_vector_dsc_set_stroke_gradient_spread(ctx, LV_VECTOR_GRADIENT_SPREAD_REFLECT);
+    lv_draw_vector_dsc_add_path(ctx, path); // draw a path
 
     lv_draw_vector(ctx);
     lv_vector_path_delete(path);
-    lv_vector_dsc_delete(ctx);
+    lv_draw_vector_dsc_delete(ctx);
 }
 
 static void canvas_draw(const char * name, draw_cb_t draw_cb)