diff --git a/CMakeLists.txt b/CMakeLists.txt
index ef4085a..35b8621 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -85,9 +85,6 @@
 
 include_directories(${PROJECT_BINARY_DIR}/src ${PROJECT_SOURCE_DIR}/src)
 
-configure_file(${PROJECT_SOURCE_DIR}/src/config.h.in ${PROJECT_BINARY_DIR}/src/config.h @ONLY)
-configure_file(${PROJECT_SOURCE_DIR}/src/version.h.in ${PROJECT_BINARY_DIR}/src/version.h @ONLY)
-
 # type plugins are separate because they have their documentation generated
 set(type_plugins
     src/plugins_types/binary.c
@@ -210,6 +207,10 @@
 option(ENABLE_COVERAGE "Build code coverage report from tests" OFF)
 option(ENABLE_FUZZ_TARGETS "Build target programs suitable for fuzzing with AFL" OFF)
 
+set(LYD_VALUE_SIZE "24" CACHE STRING "Maximum size in bytes of data node values that do not need to be allocated dynamically, minimum is 8")
+if(NOT LYD_VALUE_SIZE GREATER_EQUAL 8)
+    message(FATAL_ERROR "Data node value size \"${LYD_VALUE_SIZE}\" is not valid.")
+endif()
 set(PLUGINS_DIR "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/libyang" CACHE STRING "Directory with libyang plugins (extensions and user types)")
 set(PLUGINS_DIR_EXTENSIONS "${PLUGINS_DIR}/extensions" CACHE STRING "Directory with libyang user extensions plugins")
 set(PLUGINS_DIR_TYPES "${PLUGINS_DIR}/types" CACHE STRING "Directory with libyang user types plugins")
@@ -251,6 +252,10 @@
 # static build requires static libpcre2 library
 option(ENABLE_STATIC "Build static (.a) library" OFF)
 
+# generate files
+configure_file(${PROJECT_SOURCE_DIR}/src/config.h.in ${PROJECT_BINARY_DIR}/src/config.h @ONLY)
+configure_file(${PROJECT_SOURCE_DIR}/src/version.h.in ${PROJECT_BINARY_DIR}/src/version.h @ONLY)
+
 #
 # targets
 #
diff --git a/src/config.h.in b/src/config.h.in
index ab861bd..65c4934 100644
--- a/src/config.h.in
+++ b/src/config.h.in
@@ -15,6 +15,9 @@
 #ifndef LY_CONFIG_H_
 #define LY_CONFIG_H_
 
+/** size of fixed_mem in lyd_value, minimum is 8 (B) */
+#define LYD_VALUE_FIXED_MEM_SIZE @LYD_VALUE_SIZE@
+
 /*
  * Plugins
  */
diff --git a/src/plugins_types.c b/src/plugins_types.c
index 3a1372f..ac23c24 100644
--- a/src/plugins_types.c
+++ b/src/plugins_types.c
@@ -301,7 +301,7 @@
 lyplg_type_dup_simple(const struct ly_ctx *ctx, const struct lyd_value *original, struct lyd_value *dup)
 {
     LY_CHECK_RET(lydict_insert(ctx, original->_canonical, strlen(original->_canonical), &dup->_canonical));
-    dup->ptr = original->ptr;
+    memcpy(dup->fixed_mem, original->fixed_mem, sizeof dup->fixed_mem);
     dup->realtype = original->realtype;
     return LY_SUCCESS;
 }
diff --git a/src/plugins_types.h b/src/plugins_types.h
index 43e567f..dc7ca13 100644
--- a/src/plugins_types.h
+++ b/src/plugins_types.h
@@ -18,6 +18,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include "config.h"
 #include "log.h"
 #include "plugins.h"
 #include "tree.h"
@@ -170,6 +171,38 @@
     const struct lyplg_type_record plugins_types__[]
 
 /**
+ * @brief Check whether specific type value needs to be allocated dynamically.
+ *
+ * @param[in] type_val Pointer to specific type value storage.
+ */
+#define LYPLG_TYPE_VAL_IS_DYN(type_val) \
+    (sizeof *(type_val) > LYD_VALUE_FIXED_MEM_SIZE)
+
+/**
+ * @brief Prepare value memory for storing a specific type value, may be allocated dynamically.
+ *
+ * Must be called for values larger than 8 bytes.
+ * To be used in ::lyplg_type_store_clb.
+ *
+ * @param[in] storage Pointer to the value storage to use (struct ::lyd_value *).
+ * @param[in,out] type_val Pointer to specific type value structure.
+ */
+#define LYPLG_TYPE_VAL_INLINE_PREPARE(storage, type_val) \
+    (LYPLG_TYPE_VAL_IS_DYN(type_val) \
+     ? ((type_val) = ((storage)->dyn_mem = calloc(1, sizeof *(type_val)))) \
+     : ((type_val) = memset((storage)->fixed_mem, 0, sizeof *(type_val))))
+
+/**
+ * @brief Destroy a prepared value.
+ *
+ * Must be called for values prepared with ::LYPLG_TYPE_VAL_INLINE_PREPARE.
+ *
+ * @param[in] type_val Pointer to specific type value structure.
+ */
+#define LYPLG_TYPE_VAL_INLINE_DESTROY(type_val) \
+    do { if (LYPLG_TYPE_VAL_IS_DYN(type_val)) free(type_val); } while(0)
+
+/**
  * @brief Create and fill error structure.
  *
  * Helper function for various plugin functions to generate error information structure.
diff --git a/src/plugins_types/binary.c b/src/plugins_types/binary.c
index aed2c35..7fe387b 100644
--- a/src/plugins_types/binary.c
+++ b/src/plugins_types/binary.c
@@ -215,19 +215,13 @@
     struct lysc_type_bin *type_bin = (struct lysc_type_bin *)type;
     struct lyd_value_binary *val;
 
-    /* clear storage */
+    /* init storage */
     memset(storage, 0, sizeof *storage);
+    LYPLG_TYPE_VAL_INLINE_PREPARE(storage, val);
+    LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
+    storage->realtype = type;
 
     if (format == LY_VALUE_LYB) {
-        /* allocate the value */
-        val = calloc(1, sizeof *val);
-        LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
-
-        /* init storage */
-        storage->_canonical = NULL;
-        storage->bin = val;
-        storage->realtype = type;
-
         /* store value */
         if (options & LYPLG_TYPE_STORE_DYNAMIC) {
             val->data = (void *)value;
@@ -255,15 +249,6 @@
         LY_CHECK_GOTO(ret, cleanup);
     }
 
-    /* allocate the value */
-    val = calloc(1, sizeof *val);
-    LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
-
-    /* init storage */
-    storage->_canonical = NULL;
-    storage->bin = val;
-    storage->realtype = type;
-
     /* get the binary value */
     ret = binary_base64_decode(value, value_len, &val->data, &val->size);
     LY_CHECK_GOTO(ret, cleanup);
@@ -292,12 +277,15 @@
 API LY_ERR
 lyplg_type_compare_binary(const struct lyd_value *val1, const struct lyd_value *val2)
 {
-    struct lyd_value_binary *v1 = val1->bin, *v2 = val2->bin;
+    struct lyd_value_binary *v1, *v2;
 
     if (val1->realtype != val2->realtype) {
         return LY_ENOT;
     }
 
+    LYD_VALUE_GET(val1, v1);
+    LYD_VALUE_GET(val2, v2);
+
     if ((v1->size != v2->size) || memcmp(v1->data, v2->data, v1->size)) {
         return LY_ENOT;
     }
@@ -308,10 +296,12 @@
 lyplg_type_print_binary(const struct ly_ctx *ctx, const struct lyd_value *value, LY_VALUE_FORMAT format,
         void *UNUSED(prefix_data), ly_bool *dynamic, size_t *value_len)
 {
-    struct lyd_value_binary *val = value->bin;
+    struct lyd_value_binary *val;
     char *ret;
     size_t ret_len = 0;
 
+    LYD_VALUE_GET(value, val);
+
     if (format == LY_VALUE_LYB) {
         *dynamic = 0;
         if (value_len) {
@@ -348,27 +338,27 @@
 lyplg_type_dup_binary(const struct ly_ctx *ctx, const struct lyd_value *original, struct lyd_value *dup)
 {
     LY_ERR ret;
-    struct lyd_value_binary *orig_val = original->bin, *dup_val;
+    struct lyd_value_binary *orig_val, *dup_val;
 
     ret = lydict_insert(ctx, original->_canonical, ly_strlen(original->_canonical), &dup->_canonical);
     LY_CHECK_RET(ret);
 
-    dup_val = calloc(1, sizeof *dup_val);
+    LYPLG_TYPE_VAL_INLINE_PREPARE(dup, dup_val);
     if (!dup_val) {
         lydict_remove(ctx, dup->_canonical);
         return LY_EMEM;
     }
 
+    LYD_VALUE_GET(original, orig_val);
     dup_val->data = malloc(orig_val->size);
     if (!dup_val->data) {
         lydict_remove(ctx, dup->_canonical);
-        free(dup_val);
+        LYPLG_TYPE_VAL_INLINE_DESTROY(dup_val);
         return LY_EMEM;
     }
     memcpy(dup_val->data, orig_val->data, orig_val->size);
     dup_val->size = orig_val->size;
 
-    dup->bin = dup_val;
     dup->realtype = original->realtype;
     return LY_SUCCESS;
 }
@@ -376,12 +366,13 @@
 API void
 lyplg_type_free_binary(const struct ly_ctx *ctx, struct lyd_value *value)
 {
-    struct lyd_value_binary *val = value->bin;
+    struct lyd_value_binary *val;
 
     lydict_remove(ctx, value->_canonical);
+    LYD_VALUE_GET(value, val);
     if (val) {
         free(val->data);
-        free(val);
+        LYPLG_TYPE_VAL_INLINE_DESTROY(val);
     }
 }
 
diff --git a/src/plugins_types/bits.c b/src/plugins_types/bits.c
index 481d71b..bd76e4d 100644
--- a/src/plugins_types/bits.c
+++ b/src/plugins_types/bits.c
@@ -297,8 +297,11 @@
     struct lysc_type_bits *type_bits = (struct lysc_type_bits *)type;
     struct lyd_value_bits *val;
 
-    /* clear storage */
+    /* init storage */
     memset(storage, 0, sizeof *storage);
+    LYPLG_TYPE_VAL_INLINE_PREPARE(storage, val);
+    LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
+    storage->realtype = type;
 
     if (format == LY_VALUE_LYB) {
         /* validation */
@@ -308,15 +311,6 @@
             goto cleanup;
         }
 
-        /* allocate the value */
-        val = calloc(1, sizeof *val);
-        LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
-
-        /* init storage */
-        storage->_canonical = NULL;
-        storage->ptr = val;
-        storage->realtype = type;
-
         /* store value (bitmap) */
         if (options & LYPLG_TYPE_STORE_DYNAMIC) {
             val->bitmap = (char *)value;
@@ -339,15 +333,6 @@
     ret = lyplg_type_check_hints(hints, value, value_len, type->basetype, NULL, err);
     LY_CHECK_GOTO(ret, cleanup);
 
-    /* allocate the value */
-    val = calloc(1, sizeof *val);
-    LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
-
-    /* init storage */
-    storage->_canonical = NULL;
-    storage->ptr = val;
-    storage->realtype = type;
-
     /* allocate the bitmap */
     val->bitmap = malloc(lyplg_type_bits_bitmap_size(type_bits));
     LY_CHECK_ERR_GOTO(!val->bitmap, ret = LY_EMEM, cleanup);
@@ -387,13 +372,16 @@
 API LY_ERR
 lyplg_type_compare_bits(const struct lyd_value *val1, const struct lyd_value *val2)
 {
-    struct lyd_value_bits *v1 = val1->ptr, *v2 = val2->ptr;
+    struct lyd_value_bits *v1, *v2;
     struct lysc_type_bits *type_bits = (struct lysc_type_bits *)val1->realtype;
 
     if (val1->realtype != val2->realtype) {
         return LY_ENOT;
     }
 
+    LYD_VALUE_GET(val1, v1);
+    LYD_VALUE_GET(val2, v2);
+
     if (memcmp(v1->bitmap, v2->bitmap, lyplg_type_bits_bitmap_size(type_bits))) {
         return LY_ENOT;
     }
@@ -405,9 +393,11 @@
         void *UNUSED(prefix_data), ly_bool *dynamic, size_t *value_len)
 {
     struct lysc_type_bits *type_bits = (struct lysc_type_bits *)value->realtype;
-    struct lyd_value_bits *val = value->ptr;
+    struct lyd_value_bits *val;
     char *ret;
 
+    LYD_VALUE_GET(value, val);
+
     if (format == LY_VALUE_LYB) {
         *dynamic = 0;
         if (value_len) {
@@ -446,7 +436,7 @@
     LY_ERR ret;
     struct lysc_type_bits *type_bits = (struct lysc_type_bits *)original->realtype;
     LY_ARRAY_COUNT_TYPE u;
-    struct lyd_value_bits *orig_val = original->ptr, *dup_val;
+    struct lyd_value_bits *orig_val, *dup_val;
 
     memset(dup, 0, sizeof *dup);
 
@@ -455,9 +445,10 @@
     LY_CHECK_GOTO(ret, error);
 
     /* allocate value */
-    dup_val = calloc(1, sizeof *dup_val);
+    LYPLG_TYPE_VAL_INLINE_PREPARE(dup, dup_val);
     LY_CHECK_ERR_GOTO(!dup_val, ret = LY_EMEM, error);
-    dup->ptr = dup_val;
+
+    LYD_VALUE_GET(original, orig_val);
 
     /* duplicate bitmap */
     dup_val->bitmap = malloc(lyplg_type_bits_bitmap_size(type_bits));
@@ -471,7 +462,6 @@
         dup_val->items[u] = orig_val->items[u];
     }
 
-    dup->ptr = dup_val;
     dup->realtype = original->realtype;
     return LY_SUCCESS;
 
@@ -483,13 +473,14 @@
 API void
 lyplg_type_free_bits(const struct ly_ctx *ctx, struct lyd_value *value)
 {
-    struct lyd_value_bits *val = value->ptr;
+    struct lyd_value_bits *val;
 
     lydict_remove(ctx, value->_canonical);
+    LYD_VALUE_GET(value, val);
     if (val) {
         free(val->bitmap);
         LY_ARRAY_FREE(val->items);
-        free(val);
+        LYPLG_TYPE_VAL_INLINE_DESTROY(val);
     }
 }
 
diff --git a/src/plugins_types/boolean.c b/src/plugins_types/boolean.c
index 842832f..72358c2 100644
--- a/src/plugins_types/boolean.c
+++ b/src/plugins_types/boolean.c
@@ -44,6 +44,10 @@
     LY_ERR ret = LY_SUCCESS;
     int8_t i;
 
+    /* init storage */
+    memset(storage, 0, sizeof *storage);
+    storage->realtype = type;
+
     if (format == LY_VALUE_LYB) {
         /* validation */
         if (value_len != 1) {
@@ -52,13 +56,9 @@
             goto cleanup;
         }
 
-        /* cast the value */
+        /* store value */
         i = *(int8_t *)value;
-
-        /* init storage and set the value */
-        storage->_canonical = NULL;
         storage->boolean = i ? 1 : 0;
-        storage->realtype = type;
 
         /* store canonical value */
         ret = lydict_insert(ctx, i ? "true" : "false", 0, &storage->_canonical);
@@ -72,7 +72,7 @@
     ret = lyplg_type_check_hints(hints, value, value_len, type->basetype, NULL, err);
     LY_CHECK_GOTO(ret, cleanup);
 
-    /* validate and get the value */
+    /* validate and store the value */
     if ((value_len == ly_strlen_const("true")) && !strncmp(value, "true", ly_strlen_const("true"))) {
         i = 1;
     } else if ((value_len == ly_strlen_const("false")) && !strncmp(value, "false", ly_strlen_const("false"))) {
@@ -82,11 +82,7 @@
                 (char *)value);
         goto cleanup;
     }
-
-    /* init storage and set the value */
-    storage->_canonical = NULL;
     storage->boolean = i;
-    storage->realtype = type;
 
     /* store canonical value, it always is */
     if (options & LYPLG_TYPE_STORE_DYNAMIC) {
diff --git a/src/plugins_types/date_and_time.c b/src/plugins_types/date_and_time.c
index 4554ae2..cbfb809 100644
--- a/src/plugins_types/date_and_time.c
+++ b/src/plugins_types/date_and_time.c
@@ -186,8 +186,11 @@
     uint32_t i;
     char c;
 
-    /* clear storage */
+    /* init storage */
     memset(storage, 0, sizeof *storage);
+    LYPLG_TYPE_VAL_INLINE_PREPARE(storage, val);
+    LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
+    storage->realtype = type;
 
     if (format == LY_VALUE_LYB) {
         /* validation */
@@ -205,15 +208,6 @@
             }
         }
 
-        /* allocate the value */
-        val = calloc(1, sizeof *val);
-        LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
-
-        /* init storage */
-        storage->_canonical = NULL;
-        storage->ptr = val;
-        storage->realtype = type;
-
         /* store timestamp */
         memcpy(&val->time, value, sizeof val->time);
 
@@ -241,15 +235,6 @@
     ret = lyplg_type_validate_patterns(type_dat->patterns, value, value_len, err);
     LY_CHECK_GOTO(ret, cleanup);
 
-    /* allocate the value */
-    val = calloc(1, sizeof *val);
-    LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
-
-    /* init storage */
-    storage->_canonical = NULL;
-    storage->ptr = val;
-    storage->realtype = type;
-
     /* pattern validation succeeded, convert to UNIX time and fractions of second */
     ret = dat_str2time(value, &val->time, &val->fractions_s);
     LY_CHECK_GOTO(ret, cleanup);
@@ -283,12 +268,15 @@
 static LY_ERR
 lyplg_type_compare_date_and_time(const struct lyd_value *val1, const struct lyd_value *val2)
 {
-    struct lyd_value_date_and_time *v1 = val1->ptr, *v2 = val2->ptr;
+    struct lyd_value_date_and_time *v1, *v2;
 
     if (val1->realtype != val2->realtype) {
         return LY_ENOT;
     }
 
+    LYD_VALUE_GET(val1, v1);
+    LYD_VALUE_GET(val2, v2);
+
     /* compare timestamp */
     if (v1->time != v2->time) {
         return LY_ENOT;
@@ -309,9 +297,11 @@
 lyplg_type_print_date_and_time(const struct ly_ctx *ctx, const struct lyd_value *value, LY_VALUE_FORMAT format,
         void *UNUSED(prefix_data), ly_bool *dynamic, size_t *value_len)
 {
-    struct lyd_value_date_and_time *val = value->ptr;
+    struct lyd_value_date_and_time *val;
     char *ret;
 
+    LYD_VALUE_GET(value, val);
+
     if (format == LY_VALUE_LYB) {
         if (val->fractions_s) {
             ret = malloc(8 + strlen(val->fractions_s));
@@ -364,7 +354,7 @@
 lyplg_type_dup_date_and_time(const struct ly_ctx *ctx, const struct lyd_value *original, struct lyd_value *dup)
 {
     LY_ERR ret;
-    struct lyd_value_date_and_time *orig_val = original->ptr, *dup_val;
+    struct lyd_value_date_and_time *orig_val, *dup_val;
 
     memset(dup, 0, sizeof *dup);
 
@@ -373,9 +363,10 @@
     LY_CHECK_GOTO(ret, error);
 
     /* allocate value */
-    dup_val = calloc(1, sizeof *dup_val);
+    LYPLG_TYPE_VAL_INLINE_PREPARE(dup, dup_val);
     LY_CHECK_ERR_GOTO(!dup_val, ret = LY_EMEM, error);
-    dup->ptr = dup_val;
+
+    LYD_VALUE_GET(original, orig_val);
 
     /* copy timestamp */
     dup_val->time = orig_val->time;
@@ -386,7 +377,6 @@
         LY_CHECK_ERR_GOTO(!dup_val->fractions_s, ret = LY_EMEM, error);
     }
 
-    dup->ptr = dup_val;
     dup->realtype = original->realtype;
     return LY_SUCCESS;
 
@@ -401,12 +391,13 @@
 static void
 lyplg_type_free_date_and_time(const struct ly_ctx *ctx, struct lyd_value *value)
 {
-    struct lyd_value_date_and_time *val = value->ptr;
+    struct lyd_value_date_and_time *val;
 
     lydict_remove(ctx, value->_canonical);
+    LYD_VALUE_GET(value, val);
     if (val) {
         free(val->fractions_s);
-        free(val);
+        LYPLG_TYPE_VAL_INLINE_DESTROY(val);
     }
 }
 
diff --git a/src/plugins_types/decimal64.c b/src/plugins_types/decimal64.c
index 4df6bb9..7c8a6b9 100644
--- a/src/plugins_types/decimal64.c
+++ b/src/plugins_types/decimal64.c
@@ -93,8 +93,9 @@
     int64_t num;
     char *canon;
 
-    /* clear storage */
+    /* init storage */
     memset(storage, 0, sizeof *storage);
+    storage->realtype = type;
 
     if (format == LY_VALUE_LYB) {
         /* validation */
@@ -116,12 +117,10 @@
         LY_CHECK_GOTO(ret, cleanup);
     }
 
-    /* init storage */
-    storage->_canonical = NULL;
+    /* store value */
     storage->dec64 = num;
-    storage->realtype = type;
 
-    /* we need canonical value for hash */
+    /* we need canonical value for the range check */
     if (format == LY_VALUE_CANON) {
         /* store canonical value */
         if (options & LYPLG_TYPE_STORE_DYNAMIC) {
diff --git a/src/plugins_types/empty.c b/src/plugins_types/empty.c
index c7aa6db..3753923 100644
--- a/src/plugins_types/empty.c
+++ b/src/plugins_types/empty.c
@@ -42,8 +42,9 @@
 {
     LY_ERR ret = LY_SUCCESS;
 
-    /* clear storage */
+    /* init storage */
     memset(storage, 0, sizeof *storage);
+    storage->realtype = type;
 
     /* check hints */
     ret = lyplg_type_check_hints(hints, value, value_len, type->basetype, NULL, err);
@@ -55,11 +56,6 @@
         goto cleanup;
     }
 
-    /* init storage */
-    storage->_canonical = NULL;
-    storage->ptr = NULL;
-    storage->realtype = type;
-
     /* store canonical value */
     if (options & LYPLG_TYPE_STORE_DYNAMIC) {
         ret = lydict_insert_zc(ctx, (char *)value, &storage->_canonical);
diff --git a/src/plugins_types/enumeration.c b/src/plugins_types/enumeration.c
index e233943..092bd57 100644
--- a/src/plugins_types/enumeration.c
+++ b/src/plugins_types/enumeration.c
@@ -45,8 +45,9 @@
     LY_ARRAY_COUNT_TYPE u;
     ly_bool found = 0;
 
-    /* clear storage */
+    /* init storage */
     memset(storage, 0, sizeof *storage);
+    storage->realtype = type;
 
     if (format == LY_VALUE_LYB) {
         /* validation */
@@ -91,10 +92,8 @@
         }
     }
 
-    /* init storage */
-    storage->_canonical = NULL;
+    /* store value */
     storage->enum_item = &type_enum->enums[u];
-    storage->realtype = type;
 
     /* store canonical value */
     if (options & LYPLG_TYPE_STORE_DYNAMIC) {
diff --git a/src/plugins_types/identityref.c b/src/plugins_types/identityref.c
index e06fce9..c8e655a 100644
--- a/src/plugins_types/identityref.c
+++ b/src/plugins_types/identityref.c
@@ -194,8 +194,9 @@
     char *canon;
     struct lysc_ident *ident;
 
-    /* clear storage */
+    /* init storage */
     memset(storage, 0, sizeof *storage);
+    storage->realtype = type;
 
     /* check hints */
     ret = lyplg_type_check_hints(hints, value, value_len, type->basetype, NULL, err);
@@ -222,10 +223,8 @@
     ret = identityref_check_base(ident, type_ident, value, value_len, err);
     LY_CHECK_GOTO(ret, cleanup);
 
-    /* init storage */
-    storage->_canonical = NULL;
+    /* store value */
     storage->ident = ident;
-    storage->realtype = type;
 
     /* store canonical value */
     if (format == LY_VALUE_CANON) {
diff --git a/src/plugins_types/instanceid.c b/src/plugins_types/instanceid.c
index c8c52f5..7559f8e 100644
--- a/src/plugins_types/instanceid.c
+++ b/src/plugins_types/instanceid.c
@@ -154,8 +154,9 @@
     struct ly_path *path;
     char *canon;
 
-    /* clear storage */
+    /* init storage */
     memset(storage, 0, sizeof *storage);
+    storage->realtype = type;
 
     /* check hints */
     ret = lyplg_type_check_hints(hints, value, value_len, type->basetype, NULL, err);
@@ -166,10 +167,8 @@
             unres, &path, err);
     LY_CHECK_GOTO(ret, cleanup);
 
-    /* init storage */
-    storage->_canonical = NULL;
+    /* store value */
     storage->target = path;
-    storage->realtype = type;
 
     /* store canonical value */
     if (format == LY_VALUE_CANON) {
diff --git a/src/plugins_types/integer.c b/src/plugins_types/integer.c
index 451d3d9..2e63a4e 100644
--- a/src/plugins_types/integer.c
+++ b/src/plugins_types/integer.c
@@ -58,8 +58,9 @@
     char *canon;
     struct lysc_type_num *type_num = (struct lysc_type_num *)type;
 
-    /* clear storage */
+    /* init storage */
     memset(storage, 0, sizeof *storage);
+    storage->realtype = type;
 
     if (format == LY_VALUE_LYB) {
         /* validation */
@@ -115,9 +116,7 @@
         LY_CHECK_GOTO(ret, cleanup);
     }
 
-    /* init storage */
-    storage->_canonical = NULL;
-    /* matters for big-endian */
+    /* set the value, matters for big-endian */
     switch (type->basetype) {
     case LY_TYPE_INT8:
         storage->int8 = num;
@@ -134,7 +133,6 @@
     default:
         break;
     }
-    storage->realtype = type;
 
     if (format == LY_VALUE_CANON) {
         /* store canonical value */
@@ -253,8 +251,9 @@
     char *canon;
     struct lysc_type_num *type_num = (struct lysc_type_num *)type;
 
-    /* clear storage */
+    /* init storage */
     memset(storage, 0, sizeof *storage);
+    storage->realtype = type;
 
     if (format == LY_VALUE_LYB) {
         /* validation */
@@ -309,9 +308,7 @@
         LY_CHECK_GOTO(ret, cleanup);
     }
 
-    /* init storage */
-    storage->_canonical = NULL;
-    /* matters for big-endian */
+    /* store value, matters for big-endian */
     switch (type->basetype) {
     case LY_TYPE_UINT8:
         storage->uint8 = num;
@@ -328,7 +325,6 @@
     default:
         break;
     }
-    storage->realtype = type;
 
     if (format == LY_VALUE_CANON) {
         /* store canonical value */
diff --git a/src/plugins_types/ipv4_address.c b/src/plugins_types/ipv4_address.c
index ff7d752..96af2d2 100644
--- a/src/plugins_types/ipv4_address.c
+++ b/src/plugins_types/ipv4_address.c
@@ -135,8 +135,11 @@
     struct lyd_value_ipv4_address *val;
     size_t i;
 
-    /* zero storage so we can always free it */
+    /* init storage */
     memset(storage, 0, sizeof *storage);
+    LYPLG_TYPE_VAL_INLINE_PREPARE(storage, val);
+    LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
+    storage->realtype = type;
 
     if (format == LY_VALUE_LYB) {
         /* validation */
@@ -153,15 +156,6 @@
             }
         }
 
-        /* allocate the value */
-        val = calloc(1, sizeof *val);
-        LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
-
-        /* init storage */
-        storage->_canonical = NULL;
-        storage->ptr = val;
-        storage->realtype = type;
-
         /* store IP address */
         memcpy(&val->addr, value, sizeof val->addr);
 
@@ -192,15 +186,6 @@
     ret = lyplg_type_validate_patterns(type_str->patterns, value, value_len, err);
     LY_CHECK_GOTO(ret, cleanup);
 
-    /* allocate the value */
-    val = calloc(1, sizeof *val);
-    LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
-
-    /* init storage */
-    storage->_canonical = NULL;
-    storage->ptr = val;
-    storage->realtype = type;
-
     /* get the network-byte order address */
     ret = ipv4address_str2ip(value, value_len, options, ctx, &val->addr, &val->zone, err);
     LY_CHECK_GOTO(ret, cleanup);
@@ -232,12 +217,15 @@
 static LY_ERR
 lyplg_type_compare_ipv4_address(const struct lyd_value *val1, const struct lyd_value *val2)
 {
-    struct lyd_value_ipv4_address *v1 = val1->ptr, *v2 = val2->ptr;
+    struct lyd_value_ipv4_address *v1, *v2;
 
     if (val1->realtype != val2->realtype) {
         return LY_ENOT;
     }
 
+    LYD_VALUE_GET(val1, v1);
+    LYD_VALUE_GET(val2, v2);
+
     /* zones are NULL or in the dictionary */
     if (memcmp(&v1->addr, &v2->addr, sizeof v1->addr) || (v1->zone != v2->zone)) {
         return LY_ENOT;
@@ -252,10 +240,12 @@
 lyplg_type_print_ipv4_address(const struct ly_ctx *ctx, const struct lyd_value *value, LY_VALUE_FORMAT format,
         void *UNUSED(prefix_data), ly_bool *dynamic, size_t *value_len)
 {
-    struct lyd_value_ipv4_address *val = value->ptr;
+    struct lyd_value_ipv4_address *val;
     size_t zone_len;
     char *ret;
 
+    LYD_VALUE_GET(value, val);
+
     if (format == LY_VALUE_LYB) {
         if (!val->zone) {
             /* address-only, const */
@@ -324,25 +314,26 @@
 lyplg_type_dup_ipv4_address(const struct ly_ctx *ctx, const struct lyd_value *original, struct lyd_value *dup)
 {
     LY_ERR ret;
-    struct lyd_value_ipv4_address *orig_val = original->ptr, *dup_val;
+    struct lyd_value_ipv4_address *orig_val, *dup_val;
 
     ret = lydict_insert(ctx, original->_canonical, ly_strlen(original->_canonical), &dup->_canonical);
     LY_CHECK_RET(ret);
 
-    dup_val = calloc(1, sizeof *dup_val);
+    LYPLG_TYPE_VAL_INLINE_PREPARE(dup, dup_val);
     if (!dup_val) {
         lydict_remove(ctx, dup->_canonical);
         return LY_EMEM;
     }
+
+    LYD_VALUE_GET(original, orig_val);
     memcpy(&dup_val->addr, &orig_val->addr, sizeof orig_val->addr);
     ret = lydict_insert(ctx, orig_val->zone, 0, &dup_val->zone);
     if (ret) {
         lydict_remove(ctx, dup->_canonical);
-        free(dup_val);
+        LYPLG_TYPE_VAL_INLINE_DESTROY(dup_val);
         return ret;
     }
 
-    dup->ptr = dup_val;
     dup->realtype = original->realtype;
     return LY_SUCCESS;
 }
@@ -353,12 +344,13 @@
 static void
 lyplg_type_free_ipv4_address(const struct ly_ctx *ctx, struct lyd_value *value)
 {
-    struct lyd_value_ipv4_address *val = value->ptr;
+    struct lyd_value_ipv4_address *val;
 
     lydict_remove(ctx, value->_canonical);
+    LYD_VALUE_GET(value, val);
     if (val) {
         lydict_remove(ctx, val->zone);
-        free(val);
+        LYPLG_TYPE_VAL_INLINE_DESTROY(val);
     }
 }
 
diff --git a/src/plugins_types/ipv4_address_no_zone.c b/src/plugins_types/ipv4_address_no_zone.c
index 94330e8..0c99351 100644
--- a/src/plugins_types/ipv4_address_no_zone.c
+++ b/src/plugins_types/ipv4_address_no_zone.c
@@ -61,9 +61,13 @@
 {
     LY_ERR ret = LY_SUCCESS;
     struct lysc_type_str *type_str = (struct lysc_type_str *)type;
+    struct lyd_value_ipv4_address_no_zone *val;
 
-    /* zero storage so we can always free it */
+    /* init storage */
     memset(storage, 0, sizeof *storage);
+    LYPLG_TYPE_VAL_INLINE_PREPARE(storage, val);
+    LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
+    storage->realtype = type;
 
     if (format == LY_VALUE_LYB) {
         /* validation */
@@ -73,13 +77,8 @@
             goto cleanup;
         }
 
-        /* init storage */
-        storage->_canonical = NULL;
-        storage->ptr = NULL;
-        storage->realtype = type;
-
-        /* store IP address as uint32_t value */
-        memcpy(&storage->uint32, value, 4);
+        /* store IP address */
+        memcpy(&val->addr, value, 4);
 
         /* success */
         goto cleanup;
@@ -100,11 +99,6 @@
     ret = lyplg_type_validate_patterns(type_str->patterns, value, value_len, err);
     LY_CHECK_GOTO(ret, cleanup);
 
-    /* init storage */
-    storage->_canonical = NULL;
-    storage->ptr = NULL;
-    storage->realtype = type;
-
     /* we always need a dynamic value */
     if (!(options & LYPLG_TYPE_STORE_DYNAMIC)) {
         value = strndup(value, value_len);
@@ -114,7 +108,7 @@
     }
 
     /* get the network-byte order address */
-    if (!inet_pton(AF_INET, value, &storage->uint32)) {
+    if (!inet_pton(AF_INET, value, &val->addr)) {
         ret = ly_err_new(err, LY_EVALID, LYVE_DATA, NULL, NULL, "Failed to convert IPv4 address \"%s\".", (char *)value);
         goto cleanup;
     }
@@ -141,11 +135,16 @@
 static LY_ERR
 lyplg_type_compare_ipv4_address_no_zone(const struct lyd_value *val1, const struct lyd_value *val2)
 {
+    struct lyd_value_ipv4_address_no_zone *v1, *v2;
+
     if (val1->realtype != val2->realtype) {
         return LY_ENOT;
     }
 
-    if (val1->uint32 != val2->uint32) {
+    LYD_VALUE_GET(val1, v1);
+    LYD_VALUE_GET(val2, v2);
+
+    if (memcmp(&v1->addr, &v2->addr, sizeof v1->addr)) {
         return LY_ENOT;
     }
     return LY_SUCCESS;
@@ -158,14 +157,17 @@
 lyplg_type_print_ipv4_address_no_zone(const struct ly_ctx *ctx, const struct lyd_value *value, LY_VALUE_FORMAT format,
         void *UNUSED(prefix_data), ly_bool *dynamic, size_t *value_len)
 {
+    struct lyd_value_ipv4_address_no_zone *val;
     char *ret;
 
+    LYD_VALUE_GET(value, val);
+
     if (format == LY_VALUE_LYB) {
         *dynamic = 0;
         if (value_len) {
             *value_len = 4;
         }
-        return &value->uint32;
+        return &val->addr;
     }
 
     /* generate canonical value if not already (loaded from LYB) */
@@ -174,7 +176,7 @@
         LY_CHECK_RET(!ret, NULL);
 
         /* get the address in string */
-        if (!inet_ntop(AF_INET, &value->uint32, ret, INET_ADDRSTRLEN)) {
+        if (!inet_ntop(AF_INET, &val->addr, ret, INET_ADDRSTRLEN)) {
             free(ret);
             LOGERR(ctx, LY_EVALID, "Failed to get IPv4 address in string (%s).", strerror(errno));
             return NULL;
diff --git a/src/plugins_types/ipv4_prefix.c b/src/plugins_types/ipv4_prefix.c
index 85dff33..2d66b00 100644
--- a/src/plugins_types/ipv4_prefix.c
+++ b/src/plugins_types/ipv4_prefix.c
@@ -125,8 +125,11 @@
     struct lysc_type_str *type_str = (struct lysc_type_str *)type;
     struct lyd_value_ipv4_prefix *val;
 
-    /* clear storage */
+    /* init storage */
     memset(storage, 0, sizeof *storage);
+    LYPLG_TYPE_VAL_INLINE_PREPARE(storage, val);
+    LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
+    storage->realtype = type;
 
     if (format == LY_VALUE_LYB) {
         /* validation */
@@ -141,20 +144,8 @@
             goto cleanup;
         }
 
-        /* store/allocate value */
-        if (options & LYPLG_TYPE_STORE_DYNAMIC) {
-            val = (void *)value;
-            options &= ~LYPLG_TYPE_STORE_DYNAMIC;
-        } else {
-            val = calloc(1, sizeof *val);
-            LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
-            memcpy(val, value, value_len);
-        }
-
-        /* init storage */
-        storage->_canonical = NULL;
-        storage->ptr = val;
-        storage->realtype = type;
+        /* store addr + prefix */
+        memcpy(val, value, value_len);
 
         /* zero host */
         ipv4prefix_zero_host(&val->addr, val->prefix);
@@ -178,15 +169,6 @@
     ret = lyplg_type_validate_patterns(type_str->patterns, value, value_len, err);
     LY_CHECK_GOTO(ret, cleanup);
 
-    /* allocate the value */
-    val = calloc(1, sizeof *val);
-    LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
-
-    /* init storage */
-    storage->_canonical = NULL;
-    storage->ptr = val;
-    storage->realtype = type;
-
     /* get the mask in network-byte order */
     ret = ipv4prefix_str2ip(value, value_len, &val->addr, &val->prefix, err);
     LY_CHECK_GOTO(ret, cleanup);
@@ -223,12 +205,15 @@
 static LY_ERR
 lyplg_type_compare_ipv4_prefix(const struct lyd_value *val1, const struct lyd_value *val2)
 {
-    struct lyd_value_ipv4_prefix *v1 = val1->ptr, *v2 = val2->ptr;
+    struct lyd_value_ipv4_prefix *v1, *v2;
 
     if (val1->realtype != val2->realtype) {
         return LY_ENOT;
     }
 
+    LYD_VALUE_GET(val1, v1);
+    LYD_VALUE_GET(val2, v2);
+
     if (memcmp(v1, v2, sizeof *v1)) {
         return LY_ENOT;
     }
@@ -242,9 +227,11 @@
 lyplg_type_print_ipv4_prefix(const struct ly_ctx *ctx, const struct lyd_value *value, LY_VALUE_FORMAT format,
         void *UNUSED(prefix_data), ly_bool *dynamic, size_t *value_len)
 {
-    struct lyd_value_ipv4_prefix *val = value->ptr;
+    struct lyd_value_ipv4_prefix *val;
     char *ret;
 
+    LYD_VALUE_GET(value, val);
+
     if (format == LY_VALUE_LYB) {
         *dynamic = 0;
         if (value_len) {
@@ -292,19 +279,20 @@
 lyplg_type_dup_ipv4_prefix(const struct ly_ctx *ctx, const struct lyd_value *original, struct lyd_value *dup)
 {
     LY_ERR ret;
-    struct lyd_value_ipv4_prefix *orig_val = original->ptr, *dup_val;
+    struct lyd_value_ipv4_prefix *orig_val, *dup_val;
 
     ret = lydict_insert(ctx, original->_canonical, ly_strlen(original->_canonical), &dup->_canonical);
     LY_CHECK_RET(ret);
 
-    dup_val = calloc(1, sizeof *dup_val);
+    LYPLG_TYPE_VAL_INLINE_PREPARE(dup, dup_val);
     if (!dup_val) {
         lydict_remove(ctx, dup->_canonical);
         return LY_EMEM;
     }
+
+    LYD_VALUE_GET(original, orig_val);
     memcpy(dup_val, orig_val, sizeof *orig_val);
 
-    dup->ptr = dup_val;
     dup->realtype = original->realtype;
     return LY_SUCCESS;
 }
@@ -315,8 +303,11 @@
 static void
 lyplg_type_free_ipv4_prefix(const struct ly_ctx *ctx, struct lyd_value *value)
 {
+    struct lyd_value_ipv4_prefix *val;
+
     lydict_remove(ctx, value->_canonical);
-    free(value->ptr);
+    LYD_VALUE_GET(value, val);
+    LYPLG_TYPE_VAL_INLINE_DESTROY(val);
 }
 
 /**
diff --git a/src/plugins_types/ipv6_address.c b/src/plugins_types/ipv6_address.c
index 2b43d1d..39450f1f 100644
--- a/src/plugins_types/ipv6_address.c
+++ b/src/plugins_types/ipv6_address.c
@@ -135,8 +135,11 @@
     struct lyd_value_ipv6_address *val;
     size_t i;
 
-    /* zero storage so we can always free it */
+    /* init storage */
     memset(storage, 0, sizeof *storage);
+    LYPLG_TYPE_VAL_INLINE_PREPARE(storage, val);
+    LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
+    storage->realtype = type;
 
     if (format == LY_VALUE_LYB) {
         /* validation */
@@ -153,15 +156,6 @@
             }
         }
 
-        /* allocate the value */
-        val = calloc(1, sizeof *val);
-        LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
-
-        /* init storage */
-        storage->_canonical = NULL;
-        storage->ptr = val;
-        storage->realtype = type;
-
         /* store IP address */
         memcpy(&val->addr, value, sizeof val->addr);
 
@@ -192,15 +186,6 @@
     ret = lyplg_type_validate_patterns(type_str->patterns, value, value_len, err);
     LY_CHECK_GOTO(ret, cleanup);
 
-    /* allocate the value */
-    val = calloc(1, sizeof *val);
-    LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
-
-    /* init storage */
-    storage->_canonical = NULL;
-    storage->ptr = val;
-    storage->realtype = type;
-
     /* get the network-byte order address */
     ret = ipv6address_str2ip(value, value_len, options, ctx, &val->addr, &val->zone, err);
     LY_CHECK_GOTO(ret, cleanup);
@@ -234,12 +219,15 @@
 static LY_ERR
 lyplg_type_compare_ipv6_address(const struct lyd_value *val1, const struct lyd_value *val2)
 {
-    struct lyd_value_ipv6_address *v1 = val1->ptr, *v2 = val2->ptr;
+    struct lyd_value_ipv6_address *v1, *v2;
 
     if (val1->realtype != val2->realtype) {
         return LY_ENOT;
     }
 
+    LYD_VALUE_GET(val1, v1);
+    LYD_VALUE_GET(val2, v2);
+
     /* zones are NULL or in the dictionary */
     if (memcmp(&v1->addr, &v2->addr, sizeof v1->addr) || (v1->zone != v2->zone)) {
         return LY_ENOT;
@@ -254,10 +242,12 @@
 lyplg_type_print_ipv6_address(const struct ly_ctx *ctx, const struct lyd_value *value, LY_VALUE_FORMAT format,
         void *UNUSED(prefix_data), ly_bool *dynamic, size_t *value_len)
 {
-    struct lyd_value_ipv6_address *val = value->ptr;
+    struct lyd_value_ipv6_address *val;
     size_t zone_len;
     char *ret;
 
+    LYD_VALUE_GET(value, val);
+
     if (format == LY_VALUE_LYB) {
         if (!val->zone) {
             /* address-only, const */
@@ -326,16 +316,18 @@
 lyplg_type_dup_ipv6_address(const struct ly_ctx *ctx, const struct lyd_value *original, struct lyd_value *dup)
 {
     LY_ERR ret;
-    struct lyd_value_ipv6_address *orig_val = original->ptr, *dup_val;
+    struct lyd_value_ipv6_address *orig_val, *dup_val;
 
     ret = lydict_insert(ctx, original->_canonical, ly_strlen(original->_canonical), &dup->_canonical);
     LY_CHECK_RET(ret);
 
-    dup_val = calloc(1, sizeof *dup_val);
+    LYPLG_TYPE_VAL_INLINE_PREPARE(dup, dup_val);
     if (!dup_val) {
         lydict_remove(ctx, dup->_canonical);
         return LY_EMEM;
     }
+
+    LYD_VALUE_GET(original, orig_val);
     memcpy(&dup_val->addr, &orig_val->addr, sizeof orig_val->addr);
     ret = lydict_insert(ctx, orig_val->zone, 0, &dup_val->zone);
     if (ret) {
@@ -344,7 +336,6 @@
         return ret;
     }
 
-    dup->ptr = dup_val;
     dup->realtype = original->realtype;
     return LY_SUCCESS;
 }
@@ -355,12 +346,13 @@
 static void
 lyplg_type_free_ipv6_address(const struct ly_ctx *ctx, struct lyd_value *value)
 {
-    struct lyd_value_ipv6_address *val = value->ptr;
+    struct lyd_value_ipv6_address *val;
 
     lydict_remove(ctx, value->_canonical);
+    LYD_VALUE_GET(value, val);
     if (val) {
         lydict_remove(ctx, val->zone);
-        free(val);
+        LYPLG_TYPE_VAL_INLINE_DESTROY(val);
     }
 }
 
diff --git a/src/plugins_types/ipv6_address_no_zone.c b/src/plugins_types/ipv6_address_no_zone.c
index bead9ed..409f381 100644
--- a/src/plugins_types/ipv6_address_no_zone.c
+++ b/src/plugins_types/ipv6_address_no_zone.c
@@ -102,8 +102,9 @@
     struct lysc_type_str *type_str = (struct lysc_type_str *)type;
     struct lyd_value_ipv6_address_no_zone *val;
 
-    /* zero storage so we can always free it */
+    /* init storage */
     memset(storage, 0, sizeof *storage);
+    storage->realtype = type;
 
     if (format == LY_VALUE_LYB) {
         /* validation */
@@ -113,20 +114,14 @@
             goto cleanup;
         }
 
-        /* init storage */
-        storage->_canonical = NULL;
-        storage->ptr = NULL;
-        storage->realtype = type;
-
-        if (options & LYPLG_TYPE_STORE_DYNAMIC) {
+        if ((options & LYPLG_TYPE_STORE_DYNAMIC) && LYPLG_TYPE_VAL_IS_DYN(val)) {
             /* use the value directly */
-            storage->ptr = (void *)value;
+            storage->dyn_mem = (void *)value;
             options &= ~LYPLG_TYPE_STORE_DYNAMIC;
         } else {
-            /* allocate the value */
-            val = calloc(1, sizeof *val);
+            /* allocate value */
+            LYPLG_TYPE_VAL_INLINE_PREPARE(storage, val);
             LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
-            storage->ptr = val;
 
             /* store IP address */
             memcpy(&val->addr, value, sizeof val->addr);
@@ -136,6 +131,10 @@
         goto cleanup;
     }
 
+    /* allocate value */
+    LYPLG_TYPE_VAL_INLINE_PREPARE(storage, val);
+    LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
+
     /* check hints */
     ret = lyplg_type_check_hints(hints, value, value_len, type->basetype, NULL, err);
     LY_CHECK_GOTO(ret, cleanup);
@@ -151,15 +150,6 @@
     ret = lyplg_type_validate_patterns(type_str->patterns, value, value_len, err);
     LY_CHECK_GOTO(ret, cleanup);
 
-    /* allocate the value */
-    val = calloc(1, sizeof *val);
-    LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
-
-    /* init storage */
-    storage->_canonical = NULL;
-    storage->ptr = val;
-    storage->realtype = type;
-
     /* get the network-byte order address */
     ret = ipv6addressnozone_str2ip(value, value_len, options, &val->addr, err);
     LY_CHECK_GOTO(ret, cleanup);
@@ -193,12 +183,15 @@
 static LY_ERR
 lyplg_type_compare_ipv6_address_no_zone(const struct lyd_value *val1, const struct lyd_value *val2)
 {
-    struct lyd_value_ipv6_address_no_zone *v1 = val1->ptr, *v2 = val2->ptr;
+    struct lyd_value_ipv6_address_no_zone *v1, *v2;
 
     if (val1->realtype != val2->realtype) {
         return LY_ENOT;
     }
 
+    LYD_VALUE_GET(val1, v1);
+    LYD_VALUE_GET(val2, v2);
+
     if (memcmp(&v1->addr, &v2->addr, sizeof v1->addr)) {
         return LY_ENOT;
     }
@@ -212,9 +205,11 @@
 lyplg_type_print_ipv6_address_no_zone(const struct ly_ctx *ctx, const struct lyd_value *value, LY_VALUE_FORMAT format,
         void *UNUSED(prefix_data), ly_bool *dynamic, size_t *value_len)
 {
-    struct lyd_value_ipv6_address_no_zone *val = value->ptr;
+    struct lyd_value_ipv6_address_no_zone *val;
     char *ret;
 
+    LYD_VALUE_GET(value, val);
+
     if (format == LY_VALUE_LYB) {
         *dynamic = 0;
         if (value_len) {
@@ -260,19 +255,20 @@
 lyplg_type_dup_ipv6_address_no_zone(const struct ly_ctx *ctx, const struct lyd_value *original, struct lyd_value *dup)
 {
     LY_ERR ret;
-    struct lyd_value_ipv6_address_no_zone *orig_val = original->ptr, *dup_val;
+    struct lyd_value_ipv6_address_no_zone *orig_val, *dup_val;
 
     ret = lydict_insert(ctx, original->_canonical, ly_strlen(original->_canonical), &dup->_canonical);
     LY_CHECK_RET(ret);
 
-    dup_val = calloc(1, sizeof *dup_val);
+    LYPLG_TYPE_VAL_INLINE_PREPARE(dup, dup_val);
     if (!dup_val) {
         lydict_remove(ctx, dup->_canonical);
         return LY_EMEM;
     }
+
+    LYD_VALUE_GET(original, orig_val);
     memcpy(&dup_val->addr, &orig_val->addr, sizeof orig_val->addr);
 
-    dup->ptr = dup_val;
     dup->realtype = original->realtype;
     return LY_SUCCESS;
 }
@@ -283,10 +279,11 @@
 static void
 lyplg_type_free_ipv6_address_no_zone(const struct ly_ctx *ctx, struct lyd_value *value)
 {
-    struct lyd_value_ipv6_address *val = value->ptr;
+    struct lyd_value_ipv6_address_no_zone *val;
 
     lydict_remove(ctx, value->_canonical);
-    free(val);
+    LYD_VALUE_GET(value, val);
+    LYPLG_TYPE_VAL_INLINE_DESTROY(val);
 }
 
 /**
diff --git a/src/plugins_types/ipv6_prefix.c b/src/plugins_types/ipv6_prefix.c
index ce7767b..22fa2c6 100644
--- a/src/plugins_types/ipv6_prefix.c
+++ b/src/plugins_types/ipv6_prefix.c
@@ -127,8 +127,9 @@
     struct lysc_type_str *type_str = (struct lysc_type_str *)type;
     struct lyd_value_ipv6_prefix *val;
 
-    /* clear storage */
+    /* init storage */
     memset(storage, 0, sizeof *storage);
+    storage->realtype = type;
 
     if (format == LY_VALUE_LYB) {
         /* validation */
@@ -145,19 +146,15 @@
 
         /* store/allocate value */
         if (options & LYPLG_TYPE_STORE_DYNAMIC) {
-            val = (void *)value;
+            storage->dyn_mem = (void *)value;
             options &= ~LYPLG_TYPE_STORE_DYNAMIC;
         } else {
-            val = calloc(1, sizeof *val);
+            LYPLG_TYPE_VAL_INLINE_PREPARE(storage, val);
             LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
+
             memcpy(val, value, value_len);
         }
 
-        /* init storage */
-        storage->_canonical = NULL;
-        storage->ptr = val;
-        storage->realtype = type;
-
         /* zero host */
         ipv6prefix_zero_host(&val->addr, val->prefix);
 
@@ -165,6 +162,10 @@
         goto cleanup;
     }
 
+    /* allocate value */
+    LYPLG_TYPE_VAL_INLINE_PREPARE(storage, val);
+    LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
+
     /* check hints */
     ret = lyplg_type_check_hints(hints, value, value_len, type->basetype, NULL, err);
     LY_CHECK_GOTO(ret, cleanup);
@@ -180,15 +181,6 @@
     ret = lyplg_type_validate_patterns(type_str->patterns, value, value_len, err);
     LY_CHECK_GOTO(ret, cleanup);
 
-    /* allocate the value */
-    val = calloc(1, sizeof *val);
-    LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
-
-    /* init storage */
-    storage->_canonical = NULL;
-    storage->ptr = val;
-    storage->realtype = type;
-
     /* get the mask in network-byte order */
     ret = ipv6prefix_str2ip(value, value_len, &val->addr, &val->prefix, err);
     LY_CHECK_GOTO(ret, cleanup);
@@ -225,12 +217,15 @@
 static LY_ERR
 lyplg_type_compare_ipv6_prefix(const struct lyd_value *val1, const struct lyd_value *val2)
 {
-    struct lyd_value_ipv6_prefix *v1 = val1->ptr, *v2 = val2->ptr;
+    struct lyd_value_ipv6_prefix *v1, *v2;
 
     if (val1->realtype != val2->realtype) {
         return LY_ENOT;
     }
 
+    LYD_VALUE_GET(val1, v1);
+    LYD_VALUE_GET(val2, v2);
+
     if (memcmp(v1, v2, sizeof *v1)) {
         return LY_ENOT;
     }
@@ -244,9 +239,11 @@
 lyplg_type_print_ipv6_prefix(const struct ly_ctx *ctx, const struct lyd_value *value, LY_VALUE_FORMAT format,
         void *UNUSED(prefix_data), ly_bool *dynamic, size_t *value_len)
 {
-    struct lyd_value_ipv6_prefix *val = value->ptr;
+    struct lyd_value_ipv6_prefix *val;
     char *ret;
 
+    LYD_VALUE_GET(value, val);
+
     if (format == LY_VALUE_LYB) {
         *dynamic = 0;
         if (value_len) {
@@ -294,19 +291,20 @@
 lyplg_type_dup_ipv6_prefix(const struct ly_ctx *ctx, const struct lyd_value *original, struct lyd_value *dup)
 {
     LY_ERR ret;
-    struct lyd_value_ipv6_prefix *orig_val = original->ptr, *dup_val;
+    struct lyd_value_ipv6_prefix *orig_val, *dup_val;
 
     ret = lydict_insert(ctx, original->_canonical, ly_strlen(original->_canonical), &dup->_canonical);
     LY_CHECK_RET(ret);
 
-    dup_val = calloc(1, sizeof *dup_val);
+    LYPLG_TYPE_VAL_INLINE_PREPARE(dup, dup_val);
     if (!dup_val) {
         lydict_remove(ctx, dup->_canonical);
         return LY_EMEM;
     }
+
+    LYD_VALUE_GET(original, orig_val);
     memcpy(dup_val, orig_val, sizeof *orig_val);
 
-    dup->ptr = dup_val;
     dup->realtype = original->realtype;
     return LY_SUCCESS;
 }
@@ -317,8 +315,11 @@
 static void
 lyplg_type_free_ipv6_prefix(const struct ly_ctx *ctx, struct lyd_value *value)
 {
+    struct lyd_value_ipv6_prefix *val;
+
     lydict_remove(ctx, value->_canonical);
-    free(value->ptr);
+    LYD_VALUE_GET(value, val);
+    LYPLG_TYPE_VAL_INLINE_DESTROY(val);
 }
 
 /**
diff --git a/src/plugins_types/string.c b/src/plugins_types/string.c
index 0083da7..eede579 100644
--- a/src/plugins_types/string.c
+++ b/src/plugins_types/string.c
@@ -43,8 +43,9 @@
     LY_ERR ret = LY_SUCCESS;
     struct lysc_type_str *type_str = (struct lysc_type_str *)type;
 
-    /* clear storage */
+    /* init storage */
     memset(storage, 0, sizeof *storage);
+    storage->realtype = type;
 
     /* check hints */
     ret = lyplg_type_check_hints(hints, value, value_len, type->basetype, NULL, err);
@@ -61,11 +62,6 @@
     ret = lyplg_type_validate_patterns(type_str->patterns, value, value_len, err);
     LY_CHECK_GOTO(ret, cleanup);
 
-    /* init storage */
-    storage->_canonical = NULL;
-    storage->ptr = NULL;
-    storage->realtype = type;
-
     /* store canonical value */
     if (options & LYPLG_TYPE_STORE_DYNAMIC) {
         ret = lydict_insert_zc(ctx, (char *)value, &storage->_canonical);
diff --git a/src/plugins_types/union.c b/src/plugins_types/union.c
index 6bfb6df..cda1e1a 100644
--- a/src/plugins_types/union.c
+++ b/src/plugins_types/union.c
@@ -144,13 +144,16 @@
 {
     LY_ERR ret = LY_SUCCESS;
     struct lysc_type_union *type_u = (struct lysc_type_union *)type;
-    struct lyd_value_union *subvalue = NULL;
+    struct lyd_value_union *subvalue;
     uint32_t type_idx;
 
     *err = NULL;
 
-    /* clear storage */
+    /* init storage */
     memset(storage, 0, sizeof *storage);
+    LYPLG_TYPE_VAL_INLINE_PREPARE(storage, subvalue);
+    LY_CHECK_ERR_GOTO(!subvalue, ret = LY_EMEM, cleanup);
+    storage->realtype = type;
 
     if (format == LY_VALUE_LYB) {
         /* basic validation */
@@ -167,18 +170,6 @@
         }
     }
 
-    /* prepare subvalue */
-    subvalue = calloc(1, sizeof *subvalue);
-    if (!subvalue) {
-        ret = ly_err_new(err, LY_EMEM, 0, NULL, NULL, LY_EMEM_MSG);
-        goto cleanup;
-    }
-
-    /* init storage */
-    storage->_canonical = NULL;
-    storage->subvalue = subvalue;
-    storage->realtype = type;
-
     /* remember the original value */
     if (options & LYPLG_TYPE_STORE_DYNAMIC) {
         subvalue->original = (void *)value;
@@ -339,9 +330,10 @@
 API void
 lyplg_type_free_union(const struct ly_ctx *ctx, struct lyd_value *value)
 {
-    struct lyd_value_union *val = value->subvalue;
+    struct lyd_value_union *val;
 
     lydict_remove(ctx, value->_canonical);
+    LYD_VALUE_GET(value, val);
     if (val) {
         if (val->value.realtype) {
             val->value.realtype->plugin->free(ctx, &val->value);
@@ -349,7 +341,7 @@
         lyplg_type_prefix_data_free(val->format, val->prefix_data);
         free(val->original);
 
-        free(val);
+        LYPLG_TYPE_VAL_INLINE_DESTROY(val);
     }
 }
 
diff --git a/src/plugins_types/xpath1.0.c b/src/plugins_types/xpath1.0.c
index a743dd0..29059ba 100644
--- a/src/plugins_types/xpath1.0.c
+++ b/src/plugins_types/xpath1.0.c
@@ -43,8 +43,8 @@
 struct lyd_value_xpath10 {
     struct lyxp_expr *exp;
     const struct ly_ctx *ctx;
-    LY_VALUE_FORMAT format;
     void *prefix_data;
+    LY_VALUE_FORMAT format;
 };
 
 /**
@@ -216,8 +216,11 @@
     struct lyd_value_xpath10 *val;
     char *canon;
 
-    /* clear storage */
+    /* init storage */
     memset(storage, 0, sizeof *storage);
+    LYPLG_TYPE_VAL_INLINE_PREPARE(storage, val);
+    LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
+    storage->realtype = type;
 
     /* check hints */
     ret = lyplg_type_check_hints(hints, value, value_len, type->basetype, NULL, err);
@@ -234,16 +237,6 @@
     ret = lyplg_type_validate_patterns(type_str->patterns, value, value_len, err);
     LY_CHECK_GOTO(ret, cleanup);
 
-    /* init storage */
-    storage->_canonical = NULL;
-    storage->ptr = NULL;
-    storage->realtype = type;
-
-    /* allocate value */
-    val = calloc(1, sizeof *val);
-    LY_CHECK_ERR_GOTO(!val, LOGMEM(ctx); ret = LY_EMEM, cleanup);
-    storage->ptr = val;
-
     /* store format-specific data and context for later prefix resolution */
     ret = lyplg_type_prefix_data_new(ctx, value, value_len, format, prefix_data, &val->format, &val->prefix_data);
     LY_CHECK_GOTO(ret, cleanup);
@@ -287,9 +280,12 @@
 lyplg_type_print_xpath10(const struct ly_ctx *ctx, const struct lyd_value *value, LY_VALUE_FORMAT format,
         void *prefix_data, ly_bool *dynamic, size_t *value_len)
 {
+    struct lyd_value_xpath10 *val;
     char *ret;
     struct ly_err_item *err = NULL;
 
+    LYD_VALUE_GET(value, val);
+
     if ((format == LY_VALUE_CANON) || (format == LY_VALUE_JSON) || (format == LY_VALUE_LYB)) {
         /* canonical */
         if (dynamic) {
@@ -302,7 +298,7 @@
     }
 
     /* print in the specific format */
-    if (xpath10_print_value(value->ptr, format, prefix_data, &ret, &err)) {
+    if (xpath10_print_value(val, format, prefix_data, &ret, &err)) {
         if (err) {
             LOGVAL_ERRITEM(ctx, err);
             ly_err_free(err);
@@ -321,7 +317,7 @@
 lyplg_type_dup_xpath10(const struct ly_ctx *ctx, const struct lyd_value *original, struct lyd_value *dup)
 {
     LY_ERR ret = LY_SUCCESS;
-    struct lyd_value_xpath10 *orig_val = original->ptr, *dup_val;
+    struct lyd_value_xpath10 *orig_val, *dup_val;
 
     /* init dup value */
     memset(dup, 0, sizeof *dup);
@@ -330,17 +326,17 @@
     ret = lydict_insert(ctx, original->_canonical, ly_strlen(original->_canonical), &dup->_canonical);
     LY_CHECK_GOTO(ret, cleanup);
 
-    dup_val = calloc(1, sizeof *dup_val);
+    LYPLG_TYPE_VAL_INLINE_PREPARE(dup, dup_val);
     LY_CHECK_ERR_GOTO(!dup_val, LOGMEM(ctx); ret = LY_EMEM, cleanup);
     dup_val->ctx = ctx;
-    dup->ptr = dup_val;
 
+    LYD_VALUE_GET(original, orig_val);
     ret = lyxp_expr_dup(ctx, orig_val->exp, &dup_val->exp);
     LY_CHECK_GOTO(ret, cleanup);
 
-    dup_val->format = orig_val->format;
     ret = lyplg_type_prefix_data_dup(ctx, orig_val->format, orig_val->prefix_data, &dup_val->prefix_data);
     LY_CHECK_GOTO(ret, cleanup);
+    dup_val->format = orig_val->format;
 
 cleanup:
     if (ret) {
@@ -352,14 +348,15 @@
 API void
 lyplg_type_free_xpath10(const struct ly_ctx *ctx, struct lyd_value *value)
 {
-    struct lyd_value_xpath10 *val = value->ptr;
+    struct lyd_value_xpath10 *val;
 
     lydict_remove(ctx, value->_canonical);
+    LYD_VALUE_GET(value, val);
     if (val) {
         lyxp_expr_free(ctx, val->exp);
         lyplg_type_prefix_data_free(val->format, val->prefix_data);
 
-        free(val);
+        LYPLG_TYPE_VAL_INLINE_DESTROY(val);
     }
 }
 
diff --git a/src/tree_data.h b/src/tree_data.h
index 1fcc38a..0e8ac71 100644
--- a/src/tree_data.h
+++ b/src/tree_data.h
@@ -18,6 +18,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include "config.h"
 #include "log.h"
 #include "tree.h"
 #include "tree_schema.h"
@@ -522,6 +523,13 @@
     const char *_canonical;          /**< Should never be accessed directly, instead ::lyd_get_value() and ::lyd_get_meta_value()
                                           should be used. Serves as a cache for the canonical value or the JSON
                                           representation if no canonical value is defined. */
+    const struct lysc_type *realtype; /**< pointer to the real type of the data stored in the value structure. This type can differ from the type
+                                          in the schema node of the data node since the type's store plugin can use other types/plugins for
+                                          storing data. Speaking about built-in types, this is the case of leafref which stores data as its
+                                          target type. In contrast, union type also uses its subtype's callbacks, but inside an internal data
+                                          stored in subvalue member of ::lyd_value structure, so here is the pointer to the union type.
+                                          In general, this type is used to get free callback for this lyd_value structure, so it must reflect
+                                          the type used to store data directly in the same lyd_value instance. */
 
     union {
         int8_t boolean;              /**< 0 as false, 1 as true */
@@ -535,25 +543,30 @@
         uint32_t uint32;             /**< 32-bit unsigned integer */
         uint64_t uint64;             /**< 64-bit unsigned integer */
         struct lysc_type_bitenum_item *enum_item;  /**< pointer to the definition of the enumeration value */
-        struct lyd_value_bits *bits; /**< bits value */
         struct lysc_ident *ident;    /**< pointer to the schema definition of the identityref value */
         struct ly_path *target;      /**< Instance-identifier target path. */
         struct lyd_value_union *subvalue; /** Union value with some metadata. */
-        struct lyd_value_binary *bin; /** Binary value */
-        void *ptr;                   /**< generic data type structure used to store the data */
+
+        void *dyn_mem;               /**< pointer to generic data type value stored in dynamic memory */
+        uint8_t fixed_mem[LYD_VALUE_FIXED_MEM_SIZE]; /**< fixed-size buffer for a generic data type value */
     };  /**< The union is just a list of shorthands to possible values stored by a type's plugin. libyang itself uses the ::lyd_value.realtype
              plugin's callbacks to work with the data.*/
-
-    const struct lysc_type *realtype; /**< pointer to the real type of the data stored in the value structure. This type can differ from the type
-                                          in the schema node of the data node since the type's store plugin can use other types/plugins for
-                                          storing data. Speaking about built-in types, this is the case of leafref which stores data as its
-                                          target type. In contrast, union type also uses its subtype's callbacks, but inside an internal data
-                                          stored in subvalue member of ::lyd_value structure, so here is the pointer to the union type.
-                                          In general, this type is used to get free callback for this lyd_value structure, so it must reflect
-                                          the type used to store data directly in the same lyd_value instance. */
 };
 
 /**
+ * @brief Get the value in format specific to the type.
+ *
+ * Should be used for any types that do not have their specific representation in the ::lyd_value union.
+ *
+ * @param[in] value Pointer to the value structure to read from (struct ::lyd_value *).
+ * @param[out] type_val Pointer to the type-specific value structure.
+ */
+#define LYD_VALUE_GET(value, type_val) \
+    ((sizeof *(type_val) > LYD_VALUE_FIXED_MEM_SIZE) \
+     ? ((type_val) = (((value)->dyn_mem))) \
+     : ((type_val) = ((void *)((value)->fixed_mem))))
+
+/**
  * @brief Special lyd_value structure for union.
  *
  * Represents data with multiple types (union). The ::lyd_value_union.value contains representation according to
diff --git a/tests/utests/utests.h b/tests/utests/utests.h
index 76f782c..5bea045 100644
--- a/tests/utests/utests.h
+++ b/tests/utests/utests.h
@@ -932,9 +932,11 @@
     { \
         const char *arr[] = { __VA_ARGS__ }; \
         LY_ARRAY_COUNT_TYPE arr_size = sizeof(arr) / sizeof(arr[0]); \
-        assert_int_equal(arr_size, LY_ARRAY_COUNT(((struct lyd_value_bits *)(NODE).ptr)->items)); \
+        struct lyd_value_bits *_val; \
+        LYD_VALUE_GET(&(NODE), _val); \
+        assert_int_equal(arr_size, LY_ARRAY_COUNT(_val->items)); \
         for (LY_ARRAY_COUNT_TYPE it = 0; it < arr_size; it++) { \
-            assert_string_equal(arr[it], ((struct lyd_value_bits *)(NODE).ptr)->items[it]->name); \
+            assert_string_equal(arr[it], _val->items[it]->name); \
         } \
     }
 
@@ -1076,12 +1078,16 @@
  * @param[in] SIZE           expected value data size
 */
 #define CHECK_LYD_VALUE_BINARY(NODE, CANNONICAL_VAL, VALUE, SIZE) \
-    assert_int_equal((NODE).bin->size, SIZE); \
-    assert_int_equal(0, memcmp((NODE).bin->data, VALUE, SIZE)); \
-    assert_non_null((NODE).realtype->plugin->print(UTEST_LYCTX, &(NODE), LY_VALUE_CANON, NULL, NULL, NULL)); \
-    assert_string_equal((NODE)._canonical, CANNONICAL_VAL); \
-    assert_non_null((NODE).realtype); \
-    assert_int_equal(LY_TYPE_BINARY, (NODE).realtype->basetype);
+    { \
+        struct lyd_value_binary *_val; \
+        LYD_VALUE_GET(&(NODE), _val); \
+        assert_int_equal(_val->size, SIZE); \
+        assert_int_equal(0, memcmp(_val->data, VALUE, SIZE)); \
+        assert_non_null((NODE).realtype->plugin->print(UTEST_LYCTX, &(NODE), LY_VALUE_CANON, NULL, NULL, NULL)); \
+        assert_string_equal((NODE)._canonical, CANNONICAL_VAL); \
+        assert_non_null((NODE).realtype); \
+        assert_int_equal(LY_TYPE_BINARY, (NODE).realtype->basetype); \
+    }
 
 /**
  * @brief Internal macro. Assert that lyd_value structure members are correct. Lyd value is type BOOL.