diff --git a/src/draw/lv_draw.c b/src/draw/lv_draw.c
index 3d237e4cb1..b24dda671b 100644
--- a/src/draw/lv_draw.c
+++ b/src/draw/lv_draw.c
@@ -13,6 +13,8 @@
 #include "../misc/lv_area_private.h"
 #include "../misc/lv_assert.h"
 #include "lv_draw_private.h"
+#include "lv_draw_mask_private.h"
+#include "lv_draw_vector_private.h"
 #include "sw/lv_draw_sw.h"
 #include "../display/lv_display_private.h"
 #include "../core/lv_global.h"
@@ -33,6 +35,7 @@
  **********************/
 static bool is_independent(lv_layer_t * layer, lv_draw_task_t * t_check);
 static void cleanup_task(lv_draw_task_t * t, lv_display_t * disp);
+static inline size_t get_draw_dsc_size(lv_draw_task_type_t type);
 static lv_draw_task_t * get_first_available_task(lv_layer_t * layer);
 
 #if LV_LOG_LEVEL <= LV_LOG_LEVEL_INFO
@@ -92,10 +95,12 @@ void * lv_draw_create_unit(size_t size)
     return new_unit;
 }
 
-lv_draw_task_t * lv_draw_add_task(lv_layer_t * layer, const lv_area_t * coords)
+lv_draw_task_t * lv_draw_add_task(lv_layer_t * layer, const lv_area_t * coords, lv_draw_task_type_t type)
 {
     LV_PROFILER_DRAW_BEGIN;
-    lv_draw_task_t * new_task = lv_malloc_zeroed(sizeof(lv_draw_task_t));
+    size_t dsc_size = get_draw_dsc_size(type);
+    LV_ASSERT_FORMAT_MSG(dsc_size > 0, "Draw task size is 0 for type %d", type);
+    lv_draw_task_t * new_task = lv_malloc_zeroed(LV_ALIGN_UP(sizeof(lv_draw_task_t), 8) + dsc_size);
     LV_ASSERT_MALLOC(new_task);
     new_task->area = *coords;
     new_task->_real_area = *coords;
@@ -104,6 +109,8 @@ lv_draw_task_t * lv_draw_add_task(lv_layer_t * layer, const lv_area_t * coords)
 #if LV_DRAW_TRANSFORM_USE_MATRIX
     new_task->matrix = layer->matrix;
 #endif
+    new_task->type = type;
+    new_task->draw_dsc = (uint8_t *)new_task + LV_ALIGN_UP(sizeof(lv_draw_task_t), 8);
     new_task->state = LV_DRAW_TASK_STATE_QUEUED;
 
     /*Find the tail*/
@@ -326,7 +333,6 @@ lv_draw_task_t * lv_draw_get_next_available_task(lv_layer_t * layer, lv_draw_tas
 {
     LV_PROFILER_DRAW_BEGIN;
 
-
     /*If the first task is screen sized, there cannot be independent areas*/
     if(layer->draw_task_head) {
         int32_t hor_res = lv_display_get_horizontal_resolution(lv_refr_get_disp_refreshing());
@@ -443,7 +449,6 @@ void lv_draw_layer_init(lv_layer_t * layer, lv_layer_t * parent_layer, lv_color_
     LV_PROFILER_DRAW_END;
 }
 
-
 void * lv_draw_layer_alloc_buf(lv_layer_t * layer)
 {
     LV_PROFILER_DRAW_BEGIN;
@@ -537,6 +542,54 @@ static bool is_independent(lv_layer_t * layer, lv_draw_task_t * t_check)
     return true;
 }
 
+/**
+ * Get the size of the draw descriptor of a draw task
+ * @param type      type of the draw task
+ * @return          size of the draw descriptor in bytes
+ */
+static inline size_t get_draw_dsc_size(lv_draw_task_type_t type)
+{
+    switch(type) {
+        case LV_DRAW_TASK_TYPE_NONE:
+            return 0;
+        case LV_DRAW_TASK_TYPE_FILL:
+            return sizeof(lv_draw_fill_dsc_t);
+        case LV_DRAW_TASK_TYPE_BORDER:
+            return sizeof(lv_draw_border_dsc_t);
+        case LV_DRAW_TASK_TYPE_BOX_SHADOW:
+            return sizeof(lv_draw_box_shadow_dsc_t);
+        case LV_DRAW_TASK_TYPE_LETTER:
+            return sizeof(lv_draw_letter_dsc_t);
+        case LV_DRAW_TASK_TYPE_LABEL:
+            return sizeof(lv_draw_label_dsc_t);
+        case LV_DRAW_TASK_TYPE_IMAGE:
+            return sizeof(lv_draw_image_dsc_t);
+        case LV_DRAW_TASK_TYPE_LAYER:
+            return sizeof(lv_draw_image_dsc_t);
+        case LV_DRAW_TASK_TYPE_LINE:
+            return sizeof(lv_draw_line_dsc_t);
+        case LV_DRAW_TASK_TYPE_ARC:
+            return sizeof(lv_draw_arc_dsc_t);
+        case LV_DRAW_TASK_TYPE_TRIANGLE:
+            return sizeof(lv_draw_triangle_dsc_t);
+        case LV_DRAW_TASK_TYPE_MASK_RECTANGLE:
+            return sizeof(lv_draw_mask_rect_dsc_t);
+
+        /* no struct match for LV_DRAW_TASK_TYPE_MASK_BITMAP, set it to zero now */
+        case LV_DRAW_TASK_TYPE_MASK_BITMAP:
+            return 0;
+#if LV_USE_VECTOR_GRAPHIC
+        case LV_DRAW_TASK_TYPE_VECTOR:
+            return sizeof(lv_draw_vector_task_dsc_t);
+#endif
+            /* Note that default is not added here because when adding new draw task type,
+             * if forget to add case, the compiler will automatically report a warning.
+             */
+    }
+
+    return 0;
+}
+
 /**
  * Clean-up resources allocated by a finished task
  * @param t         pointer to a draw task
@@ -591,7 +644,6 @@ static void cleanup_task(lv_draw_task_t * t, lv_display_t * disp)
         draw_label_dsc->text = NULL;
     }
 
-    lv_free(t->draw_dsc);
     lv_free(t);
     LV_PROFILER_DRAW_END;
 }
diff --git a/src/draw/lv_draw.h b/src/draw/lv_draw.h
index 44b2c7e8dd..b35cb52f82 100644
--- a/src/draw/lv_draw.h
+++ b/src/draw/lv_draw.h
@@ -57,7 +57,9 @@ typedef enum {
     LV_DRAW_TASK_TYPE_TRIANGLE,
     LV_DRAW_TASK_TYPE_MASK_RECTANGLE,
     LV_DRAW_TASK_TYPE_MASK_BITMAP,
+#if LV_USE_VECTOR_GRAPHIC
     LV_DRAW_TASK_TYPE_VECTOR,
+#endif
 } lv_draw_task_type_t;
 
 typedef enum {
@@ -167,7 +169,7 @@ void * lv_draw_create_unit(size_t size);
  * @return          the created draw task which needs to be
  *                  further configured e.g. by added a draw descriptor
  */
-lv_draw_task_t * lv_draw_add_task(lv_layer_t * layer, const lv_area_t * coords);
+lv_draw_task_t * lv_draw_add_task(lv_layer_t * layer, const lv_area_t * coords, lv_draw_task_type_t type);
 
 /**
  * Needs to be called when a draw task is created and configured.
diff --git a/src/draw/lv_draw_arc.c b/src/draw/lv_draw_arc.c
index ed89532828..4f3a5473d7 100644
--- a/src/draw/lv_draw_arc.c
+++ b/src/draw/lv_draw_arc.c
@@ -62,12 +62,9 @@ void lv_draw_arc(lv_layer_t * layer, const lv_draw_arc_dsc_t * dsc)
     a.y1 = dsc->center.y - dsc->radius;
     a.x2 = dsc->center.x + dsc->radius - 1;
     a.y2 = dsc->center.y + dsc->radius - 1;
-    lv_draw_task_t * t = lv_draw_add_task(layer, &a);
+    lv_draw_task_t * t = lv_draw_add_task(layer, &a, LV_DRAW_TASK_TYPE_ARC);
 
-    t->draw_dsc = lv_malloc(sizeof(*dsc));
-    LV_ASSERT_MALLOC(t->draw_dsc);
     lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
-    t->type = LV_DRAW_TASK_TYPE_ARC;
 
     lv_draw_finalize_task_creation(layer, t);
 
diff --git a/src/draw/lv_draw_image.c b/src/draw/lv_draw_image.c
index c8f787bd99..ee29d6b7a0 100644
--- a/src/draw/lv_draw_image.c
+++ b/src/draw/lv_draw_image.c
@@ -73,13 +73,9 @@ void lv_draw_layer(lv_layer_t * layer, const lv_draw_image_dsc_t * dsc, const lv
 
     LV_PROFILER_DRAW_BEGIN;
 
-    lv_draw_task_t * t = lv_draw_add_task(layer, coords);
-
-    lv_draw_image_dsc_t * new_image_dsc = lv_malloc(sizeof(*dsc));
-    LV_ASSERT_MALLOC(new_image_dsc);
-    t->draw_dsc = new_image_dsc;
-    lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
-    t->type = LV_DRAW_TASK_TYPE_LAYER;
+    lv_draw_task_t * t = lv_draw_add_task(layer, coords, LV_DRAW_TASK_TYPE_LAYER);
+    lv_draw_image_dsc_t * new_image_dsc = t->draw_dsc;
+    lv_memcpy(new_image_dsc, dsc, sizeof(*dsc));
     t->state = LV_DRAW_TASK_STATE_WAITING;
 
     lv_image_buf_get_transformed_area(&t->_real_area, lv_area_get_width(coords), lv_area_get_height(coords),
@@ -114,27 +110,24 @@ void lv_draw_image(lv_layer_t * layer, const lv_draw_image_dsc_t * dsc, const lv
 
     LV_PROFILER_DRAW_BEGIN;
 
-    lv_draw_image_dsc_t * new_image_dsc = lv_malloc(sizeof(*dsc));
-    LV_ASSERT_MALLOC(new_image_dsc);
-    lv_memcpy(new_image_dsc, dsc, sizeof(*dsc));
-    lv_result_t res = lv_image_decoder_get_info(new_image_dsc->src, &new_image_dsc->header);
+    lv_draw_image_dsc_t new_image_dsc;
+    lv_memcpy(&new_image_dsc, dsc, sizeof(*dsc));
+    lv_result_t res = lv_image_decoder_get_info(new_image_dsc.src, &new_image_dsc.header);
     if(res != LV_RESULT_OK) {
         LV_LOG_WARN("Couldn't get info about the image");
-        lv_free(new_image_dsc);
         LV_PROFILER_DRAW_END;
         return;
     }
 
     /*If the image_area is not set assume that it's the same as the rendering area */
-    if(new_image_dsc->image_area.x2 == LV_COORD_MIN) {
-        new_image_dsc->image_area = *image_coords;
+    if(new_image_dsc.image_area.x2 == LV_COORD_MIN) {
+        new_image_dsc.image_area = *image_coords;
     }
 
     /*Typical case, draw the image as bitmap*/
-    if(!(new_image_dsc->header.flags & LV_IMAGE_FLAGS_CUSTOM_DRAW)) {
-        lv_draw_task_t * t = lv_draw_add_task(layer, image_coords);
-        t->draw_dsc = new_image_dsc;
-        t->type = LV_DRAW_TASK_TYPE_IMAGE;
+    if(!(new_image_dsc.header.flags & LV_IMAGE_FLAGS_CUSTOM_DRAW)) {
+        lv_draw_task_t * t = lv_draw_add_task(layer, image_coords, LV_DRAW_TASK_TYPE_IMAGE);
+        lv_memcpy(t->draw_dsc, &new_image_dsc, sizeof(lv_draw_image_dsc_t));
 
         lv_image_buf_get_transformed_area(&t->_real_area, lv_area_get_width(image_coords), lv_area_get_height(image_coords),
                                           dsc->rotation, dsc->scale_x, dsc->scale_y, &dsc->pivot);
@@ -146,7 +139,7 @@ void lv_draw_image(lv_layer_t * layer, const lv_draw_image_dsc_t * dsc, const lv
     else {
 
         lv_image_decoder_dsc_t decoder_dsc;
-        res = lv_image_decoder_open(&decoder_dsc, new_image_dsc->src, NULL);
+        res = lv_image_decoder_open(&decoder_dsc, new_image_dsc.src, NULL);
         if(res != LV_RESULT_OK) {
             LV_LOG_ERROR("Failed to open image");
             LV_PROFILER_DRAW_END;
@@ -165,7 +158,7 @@ void lv_draw_image(lv_layer_t * layer, const lv_draw_image_dsc_t * dsc, const lv
 
                     lv_area_move(&coords_area, -(image_coords->x1 - xpos), -(image_coords->y1 - ypos));
                     layer->_clip_area = coords_area;
-                    decoder_dsc.decoder->custom_draw_cb(layer, &decoder_dsc, &coords_area, new_image_dsc, &coords_area);
+                    decoder_dsc.decoder->custom_draw_cb(layer, &decoder_dsc, &coords_area, &new_image_dsc, &coords_area);
                 }
             }
             else {
@@ -181,13 +174,12 @@ void lv_draw_image(lv_layer_t * layer, const lv_draw_image_dsc_t * dsc, const lv
                     lv_area_move(&clip_area, image_coords->x1, image_coords->y1);
 
                     if(lv_area_intersect(&clip_area, &clip_area, &obj_area)) {
-                        decoder_dsc.decoder->custom_draw_cb(layer, &decoder_dsc, &coords_area, new_image_dsc, &clip_area);
+                        decoder_dsc.decoder->custom_draw_cb(layer, &decoder_dsc, &coords_area, &new_image_dsc, &clip_area);
                     }
                 }
             }
 
         }
-        lv_free(new_image_dsc);
     }
 
     LV_PROFILER_DRAW_END;
diff --git a/src/draw/lv_draw_label.c b/src/draw/lv_draw_label.c
index 7375d06f85..02c4e7c393 100644
--- a/src/draw/lv_draw_label.c
+++ b/src/draw/lv_draw_label.c
@@ -108,12 +108,9 @@ void LV_ATTRIBUTE_FAST_MEM lv_draw_label(lv_layer_t * layer, const lv_draw_label
     }
 
     LV_PROFILER_DRAW_BEGIN;
-    lv_draw_task_t * t = lv_draw_add_task(layer, coords);
+    lv_draw_task_t * t = lv_draw_add_task(layer, coords, LV_DRAW_TASK_TYPE_LABEL);
 
-    t->draw_dsc = lv_malloc(sizeof(*dsc));
-    LV_ASSERT_MALLOC(t->draw_dsc);
     lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
-    t->type = LV_DRAW_TASK_TYPE_LABEL;
 
     /*The text is stored in a local variable so malloc memory for it*/
     if(dsc->text_local) {
@@ -191,12 +188,9 @@ void LV_ATTRIBUTE_FAST_MEM lv_draw_letter(lv_layer_t * layer, lv_draw_letter_dsc
     dsc->pivot.x = g.adv_w / 2 ;
     dsc->pivot.y = font->line_height - font->base_line;
 
-    lv_draw_task_t * t = lv_draw_add_task(layer, &a);
+    lv_draw_task_t * t = lv_draw_add_task(layer, &a, LV_DRAW_TASK_TYPE_LETTER);
 
-    t->draw_dsc = lv_malloc(sizeof(*dsc));
-    LV_ASSERT_MALLOC(t->draw_dsc);
     lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
-    t->type = LV_DRAW_TASK_TYPE_LETTER;
 
     lv_draw_finalize_task_creation(layer, t);
     LV_PROFILER_DRAW_END;
diff --git a/src/draw/lv_draw_line.c b/src/draw/lv_draw_line.c
index 582fd4fbc5..283d4bf89e 100644
--- a/src/draw/lv_draw_line.c
+++ b/src/draw/lv_draw_line.c
@@ -63,12 +63,9 @@ void LV_ATTRIBUTE_FAST_MEM lv_draw_line(lv_layer_t * layer, const lv_draw_line_d
     a.y1 = (int32_t)LV_MIN(dsc->p1.y, dsc->p2.y) - dsc->width;
     a.y2 = (int32_t)LV_MAX(dsc->p1.y, dsc->p2.y) + dsc->width;
 
-    lv_draw_task_t * t = lv_draw_add_task(layer, &a);
+    lv_draw_task_t * t = lv_draw_add_task(layer, &a, LV_DRAW_TASK_TYPE_LINE);
 
-    t->draw_dsc = lv_malloc(sizeof(*dsc));
-    LV_ASSERT_MALLOC(t->draw_dsc);
     lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
-    t->type = LV_DRAW_TASK_TYPE_LINE;
 
     lv_draw_finalize_task_creation(layer, t);
     LV_PROFILER_DRAW_END;
diff --git a/src/draw/lv_draw_mask.c b/src/draw/lv_draw_mask.c
index 83f2120e60..3feea1773f 100644
--- a/src/draw/lv_draw_mask.c
+++ b/src/draw/lv_draw_mask.c
@@ -55,12 +55,9 @@ void LV_ATTRIBUTE_FAST_MEM lv_draw_mask_rect(lv_layer_t * layer, const lv_draw_m
     }
     LV_PROFILER_DRAW_BEGIN;
 
-    lv_draw_task_t * t = lv_draw_add_task(layer, &layer->buf_area);
+    lv_draw_task_t * t = lv_draw_add_task(layer, &layer->buf_area, LV_DRAW_TASK_TYPE_MASK_RECTANGLE);
 
-    t->draw_dsc = lv_malloc(sizeof(*dsc));
-    LV_ASSERT_MALLOC(t->draw_dsc);
     lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
-    t->type = LV_DRAW_TASK_TYPE_MASK_RECTANGLE;
 
     lv_draw_dsc_base_t * base_dsc = t->draw_dsc;
     base_dsc->layer = layer;
diff --git a/src/draw/lv_draw_rect.c b/src/draw/lv_draw_rect.c
index dd47f13d5b..3ee299ac56 100644
--- a/src/draw/lv_draw_rect.c
+++ b/src/draw/lv_draw_rect.c
@@ -63,8 +63,6 @@ void lv_draw_fill_dsc_init(lv_draw_fill_dsc_t * dsc)
     dsc->base.dsc_size = sizeof(lv_draw_fill_dsc_t);
 }
 
-
-
 lv_draw_fill_dsc_t * lv_draw_task_get_fill_dsc(lv_draw_task_t * task)
 {
     return task->type == LV_DRAW_TASK_TYPE_FILL ? (lv_draw_fill_dsc_t *)task->draw_dsc : NULL;
@@ -75,12 +73,9 @@ void lv_draw_fill(lv_layer_t * layer, const lv_draw_fill_dsc_t * dsc, const lv_a
     if(dsc->opa <= LV_OPA_MIN) return;
 
     LV_PROFILER_DRAW_BEGIN;
-    lv_draw_task_t * t = lv_draw_add_task(layer, coords);
+    lv_draw_task_t * t = lv_draw_add_task(layer, coords, LV_DRAW_TASK_TYPE_FILL);
 
-    t->draw_dsc = lv_malloc(sizeof(*dsc));
-    LV_ASSERT_MALLOC(t->draw_dsc);
     lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
-    t->type = LV_DRAW_TASK_TYPE_FILL;
 
     lv_draw_finalize_task_creation(layer, t);
     LV_PROFILER_DRAW_END;
@@ -104,12 +99,9 @@ void lv_draw_border(lv_layer_t * layer, const lv_draw_border_dsc_t * dsc, const
     if(dsc->opa <= LV_OPA_MIN) return;
 
     LV_PROFILER_DRAW_BEGIN;
-    lv_draw_task_t * t = lv_draw_add_task(layer, coords);
+    lv_draw_task_t * t = lv_draw_add_task(layer, coords, LV_DRAW_TASK_TYPE_BORDER);
 
-    t->draw_dsc = lv_malloc(sizeof(*dsc));
-    LV_ASSERT_MALLOC(t->draw_dsc);
     lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
-    t->type = LV_DRAW_TASK_TYPE_BORDER;
 
     lv_draw_finalize_task_creation(layer, t);
     LV_PROFILER_DRAW_END;
@@ -132,12 +124,9 @@ void lv_draw_box_shadow(lv_layer_t * layer, const lv_draw_box_shadow_dsc_t * dsc
     if(dsc->opa <= LV_OPA_MIN) return;
 
     LV_PROFILER_DRAW_BEGIN;
-    lv_draw_task_t * t = lv_draw_add_task(layer, coords);
+    lv_draw_task_t * t = lv_draw_add_task(layer, coords, LV_DRAW_TASK_TYPE_BOX_SHADOW);
 
-    t->draw_dsc = lv_malloc(sizeof(*dsc));
-    LV_ASSERT_MALLOC(t->draw_dsc);
     lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
-    t->type = LV_DRAW_TASK_TYPE_BOX_SHADOW;
 
     lv_draw_finalize_task_creation(layer, t);
     LV_PROFILER_DRAW_END;
@@ -195,10 +184,9 @@ void lv_draw_rect(lv_layer_t * layer, const lv_draw_rect_dsc_t * dsc, const lv_a
     /*Shadow*/
     if(has_shadow) {
         /*Check whether the shadow is visible*/
-        t = lv_draw_add_task(layer, coords);
-        lv_draw_box_shadow_dsc_t * shadow_dsc = lv_malloc(sizeof(lv_draw_box_shadow_dsc_t));
-        LV_ASSERT_MALLOC(shadow_dsc);
-        t->draw_dsc = shadow_dsc;
+        t = lv_draw_add_task(layer, coords, LV_DRAW_TASK_TYPE_BOX_SHADOW);
+        lv_draw_box_shadow_dsc_t * shadow_dsc = t->draw_dsc;
+
         lv_area_increase(&t->_real_area, dsc->shadow_spread, dsc->shadow_spread);
         lv_area_increase(&t->_real_area, dsc->shadow_width, dsc->shadow_width);
         lv_area_move(&t->_real_area, dsc->shadow_offset_x, dsc->shadow_offset_y);
@@ -212,7 +200,6 @@ void lv_draw_rect(lv_layer_t * layer, const lv_draw_rect_dsc_t * dsc, const lv_a
         shadow_dsc->ofs_x = dsc->shadow_offset_x;
         shadow_dsc->ofs_y = dsc->shadow_offset_y;
         shadow_dsc->bg_cover = bg_cover;
-        t->type = LV_DRAW_TASK_TYPE_BOX_SHADOW;
         lv_draw_finalize_task_creation(layer, t);
     }
 
@@ -227,18 +214,16 @@ void lv_draw_rect(lv_layer_t * layer, const lv_draw_rect_dsc_t * dsc, const lv_a
             bg_coords.y2 -= (dsc->border_side & LV_BORDER_SIDE_BOTTOM) ? 1 : 0;
         }
 
-        t = lv_draw_add_task(layer, &bg_coords);
-        lv_draw_fill_dsc_t * bg_dsc = lv_malloc(sizeof(lv_draw_fill_dsc_t));
-        LV_ASSERT_MALLOC(bg_dsc);
+        t = lv_draw_add_task(layer, &bg_coords, LV_DRAW_TASK_TYPE_FILL);
+        lv_draw_fill_dsc_t * bg_dsc = t->draw_dsc;
+
         lv_draw_fill_dsc_init(bg_dsc);
-        t->draw_dsc = bg_dsc;
         bg_dsc->base = dsc->base;
         bg_dsc->base.dsc_size = sizeof(lv_draw_fill_dsc_t);
         bg_dsc->radius = dsc->radius;
         bg_dsc->color = dsc->bg_color;
         bg_dsc->grad = dsc->bg_grad;
         bg_dsc->opa = dsc->bg_opa;
-        t->type = LV_DRAW_TASK_TYPE_FILL;
 
         lv_draw_finalize_task_creation(layer, t);
     }
@@ -263,18 +248,17 @@ void lv_draw_rect(lv_layer_t * layer, const lv_draw_rect_dsc_t * dsc, const lv_a
             if(src_type == LV_IMAGE_SRC_VARIABLE || src_type == LV_IMAGE_SRC_FILE) {
 
                 if(dsc->bg_image_tiled) {
-                    t = lv_draw_add_task(layer, coords);
+                    t = lv_draw_add_task(layer, coords, LV_DRAW_TASK_TYPE_IMAGE);
                 }
                 else {
                     lv_area_t a = {0, 0, header.w - 1, header.h - 1};
                     lv_area_align(coords, &a, LV_ALIGN_CENTER, 0, 0);
-                    t = lv_draw_add_task(layer, &a);
+                    t = lv_draw_add_task(layer, &a, LV_DRAW_TASK_TYPE_IMAGE);
                 }
 
-                lv_draw_image_dsc_t * bg_image_dsc = lv_malloc(sizeof(lv_draw_image_dsc_t));
-                LV_ASSERT_MALLOC(bg_image_dsc);
+                lv_draw_image_dsc_t * bg_image_dsc = t->draw_dsc;
+
                 lv_draw_image_dsc_init(bg_image_dsc);
-                t->draw_dsc = bg_image_dsc;
                 bg_image_dsc->base = dsc->base;
                 bg_image_dsc->base.dsc_size = sizeof(lv_draw_image_dsc_t);
                 bg_image_dsc->src = dsc->bg_image_src;
@@ -285,7 +269,6 @@ void lv_draw_rect(lv_layer_t * layer, const lv_draw_rect_dsc_t * dsc, const lv_a
                 bg_image_dsc->header = header;
                 bg_image_dsc->clip_radius = dsc->radius;
                 bg_image_dsc->image_area = *coords;
-                t->type = LV_DRAW_TASK_TYPE_IMAGE;
                 lv_draw_finalize_task_creation(layer, t);
             }
             else {
@@ -294,12 +277,11 @@ void lv_draw_rect(lv_layer_t * layer, const lv_draw_rect_dsc_t * dsc, const lv_a
 
                 lv_area_t a = {0, 0, s.x - 1, s.y - 1};
                 lv_area_align(coords, &a, LV_ALIGN_CENTER, 0, 0);
-                t = lv_draw_add_task(layer, &a);
+                t = lv_draw_add_task(layer, &a, LV_DRAW_TASK_TYPE_LABEL);
+
+                lv_draw_label_dsc_t * bg_label_dsc = t->draw_dsc;
 
-                lv_draw_label_dsc_t * bg_label_dsc = lv_malloc(sizeof(lv_draw_label_dsc_t));
-                LV_ASSERT_MALLOC(bg_label_dsc);
                 lv_draw_label_dsc_init(bg_label_dsc);
-                t->draw_dsc = bg_label_dsc;
                 bg_label_dsc->base = dsc->base;
                 bg_label_dsc->base.dsc_size = sizeof(lv_draw_label_dsc_t);
                 bg_label_dsc->color = dsc->bg_image_recolor;
@@ -313,10 +295,9 @@ void lv_draw_rect(lv_layer_t * layer, const lv_draw_rect_dsc_t * dsc, const lv_a
 
     /*Border*/
     if(has_border) {
-        t = lv_draw_add_task(layer, coords);
-        lv_draw_border_dsc_t * border_dsc = lv_malloc(sizeof(lv_draw_border_dsc_t));
-        LV_ASSERT_MALLOC(border_dsc);
-        t->draw_dsc = border_dsc;
+        t = lv_draw_add_task(layer, coords, LV_DRAW_TASK_TYPE_BORDER);
+        lv_draw_border_dsc_t * border_dsc = t->draw_dsc;
+
         border_dsc->base = dsc->base;
         border_dsc->base.dsc_size = sizeof(lv_draw_border_dsc_t);
         border_dsc->radius = dsc->radius;
@@ -324,7 +305,6 @@ void lv_draw_rect(lv_layer_t * layer, const lv_draw_rect_dsc_t * dsc, const lv_a
         border_dsc->opa = dsc->border_opa;
         border_dsc->width = dsc->border_width;
         border_dsc->side = dsc->border_side;
-        t->type = LV_DRAW_TASK_TYPE_BORDER;
         lv_draw_finalize_task_creation(layer, t);
     }
 
@@ -332,10 +312,8 @@ void lv_draw_rect(lv_layer_t * layer, const lv_draw_rect_dsc_t * dsc, const lv_a
     if(has_outline) {
         lv_area_t outline_coords = *coords;
         lv_area_increase(&outline_coords, dsc->outline_width + dsc->outline_pad, dsc->outline_width + dsc->outline_pad);
-        t = lv_draw_add_task(layer, &outline_coords);
-        lv_draw_border_dsc_t * outline_dsc = lv_malloc(sizeof(lv_draw_border_dsc_t));
-        LV_ASSERT_MALLOC(outline_dsc);
-        t->draw_dsc = outline_dsc;
+        t = lv_draw_add_task(layer, &outline_coords, LV_DRAW_TASK_TYPE_BORDER);
+        lv_draw_border_dsc_t * outline_dsc = t->draw_dsc;
         lv_area_increase(&t->_real_area, dsc->outline_width, dsc->outline_width);
         lv_area_increase(&t->_real_area, dsc->outline_pad, dsc->outline_pad);
         outline_dsc->base = dsc->base;
@@ -346,7 +324,6 @@ void lv_draw_rect(lv_layer_t * layer, const lv_draw_rect_dsc_t * dsc, const lv_a
         outline_dsc->opa = dsc->outline_opa;
         outline_dsc->width = dsc->outline_width;
         outline_dsc->side = LV_BORDER_SIDE_FULL;
-        t->type = LV_DRAW_TASK_TYPE_BORDER;
         lv_draw_finalize_task_creation(layer, t);
     }
 
diff --git a/src/draw/lv_draw_triangle.c b/src/draw/lv_draw_triangle.c
index 0885d60fc3..f36f828755 100644
--- a/src/draw/lv_draw_triangle.c
+++ b/src/draw/lv_draw_triangle.c
@@ -69,12 +69,9 @@ void lv_draw_triangle(lv_layer_t * layer, const lv_draw_triangle_dsc_t * dsc)
     a.x2 = (int32_t)LV_MAX3(dsc->p[0].x, dsc->p[1].x, dsc->p[2].x);
     a.y2 = (int32_t)LV_MAX3(dsc->p[0].y, dsc->p[1].y, dsc->p[2].y);
 
-    lv_draw_task_t * t = lv_draw_add_task(layer, &a);
+    lv_draw_task_t * t = lv_draw_add_task(layer, &a, LV_DRAW_TASK_TYPE_TRIANGLE);
 
-    t->draw_dsc = lv_malloc(sizeof(*dsc));
-    LV_ASSERT_MALLOC(t->draw_dsc);
     lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
-    t->type = LV_DRAW_TASK_TYPE_TRIANGLE;
 
     lv_draw_finalize_task_creation(layer, t);
     LV_PROFILER_DRAW_END;
diff --git a/src/draw/lv_draw_vector.c b/src/draw/lv_draw_vector.c
index 66b56e7543..a33a6da02d 100644
--- a/src/draw/lv_draw_vector.c
+++ b/src/draw/lv_draw_vector.c
@@ -754,9 +754,7 @@ void lv_draw_vector(lv_vector_dsc_t * dsc)
 
     lv_layer_t * layer = dsc->layer;
 
-    lv_draw_task_t * t = lv_draw_add_task(layer, &(layer->_clip_area));
-    t->type = LV_DRAW_TASK_TYPE_VECTOR;
-    t->draw_dsc = lv_malloc(sizeof(lv_draw_vector_task_dsc_t));
+    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_draw_finalize_task_creation(layer, t);
     dsc->tasks.task_list = NULL;
diff --git a/src/draw/nema_gfx/lv_draw_nema_gfx.c b/src/draw/nema_gfx/lv_draw_nema_gfx.c
index f07a059e59..3a1f77a195 100644
--- a/src/draw/nema_gfx/lv_draw_nema_gfx.c
+++ b/src/draw/nema_gfx/lv_draw_nema_gfx.c
@@ -246,7 +246,9 @@ static int32_t nema_gfx_evaluate(lv_draw_unit_t * draw_unit, lv_draw_task_t * ta
         case LV_DRAW_TASK_TYPE_BOX_SHADOW:
         case LV_DRAW_TASK_TYPE_MASK_RECTANGLE:
         case LV_DRAW_TASK_TYPE_MASK_BITMAP:
+#if LV_USE_VECTOR_GRAPHIC
         case LV_DRAW_TASK_TYPE_VECTOR:
+#endif
         default:
             break;
     }