diff --git a/c++/src/H5PredType.cpp b/c++/src/H5PredType.cpp
index 8574f2ea6ea..f8a63b34b2b 100644
--- a/c++/src/H5PredType.cpp
+++ b/c++/src/H5PredType.cpp
@@ -152,6 +152,9 @@ PredType *PredType::IEEE_F32LE_;
 PredType *PredType::IEEE_F64BE_;
 PredType *PredType::IEEE_F64LE_;
 
+PredType *PredType::FLOAT_BFLOAT16BE_;
+PredType *PredType::FLOAT_BFLOAT16LE_;
+
 PredType *PredType::UNIX_D32BE_;
 PredType *PredType::UNIX_D32LE_;
 PredType *PredType::UNIX_D64BE_;
@@ -339,6 +342,9 @@ PredType::makePredTypes()
     IEEE_F64BE_ = new PredType(H5T_IEEE_F64BE);
     IEEE_F64LE_ = new PredType(H5T_IEEE_F64LE);
 
+    FLOAT_BFLOAT16BE_ = new PredType(H5T_FLOAT_BFLOAT16BE);
+    FLOAT_BFLOAT16LE_ = new PredType(H5T_FLOAT_BFLOAT16LE);
+
     UNIX_D32BE_ = new PredType(H5T_UNIX_D32BE);
     UNIX_D32LE_ = new PredType(H5T_UNIX_D32LE);
     UNIX_D64BE_ = new PredType(H5T_UNIX_D64BE);
@@ -492,6 +498,9 @@ PredType::deleteConstants()
     delete IEEE_F64BE_;
     delete IEEE_F64LE_;
 
+    delete FLOAT_BFLOAT16BE_;
+    delete FLOAT_BFLOAT16LE_;
+
     delete UNIX_D32BE_;
     delete UNIX_D32LE_;
     delete UNIX_D64BE_;
@@ -649,6 +658,9 @@ const PredType &PredType::IEEE_F32LE = *IEEE_F32LE_;
 const PredType &PredType::IEEE_F64BE = *IEEE_F64BE_;
 const PredType &PredType::IEEE_F64LE = *IEEE_F64LE_;
 
+const PredType &PredType::FLOAT_BFLOAT16BE = *FLOAT_BFLOAT16BE_;
+const PredType &PredType::FLOAT_BFLOAT16LE = *FLOAT_BFLOAT16LE_;
+
 const PredType &PredType::UNIX_D32BE = *UNIX_D32BE_;
 const PredType &PredType::UNIX_D32LE = *UNIX_D32LE_;
 const PredType &PredType::UNIX_D64BE = *UNIX_D64BE_;
diff --git a/c++/src/H5PredType.h b/c++/src/H5PredType.h
index 21457055815..7668755b6c4 100644
--- a/c++/src/H5PredType.h
+++ b/c++/src/H5PredType.h
@@ -92,6 +92,9 @@ class H5CPP_DLL PredType : public AtomType {
     static const PredType &IEEE_F64BE;
     static const PredType &IEEE_F64LE;
 
+    static const PredType &FLOAT_BFLOAT16BE;
+    static const PredType &FLOAT_BFLOAT16LE;
+
     static const PredType &UNIX_D32BE;
     static const PredType &UNIX_D32LE;
     static const PredType &UNIX_D64BE;
@@ -262,6 +265,9 @@ class H5CPP_DLL PredType : public AtomType {
     static PredType *IEEE_F64BE_;
     static PredType *IEEE_F64LE_;
 
+    static PredType *FLOAT_BFLOAT16BE_;
+    static PredType *FLOAT_BFLOAT16LE_;
+
     static PredType *UNIX_D32BE_;
     static PredType *UNIX_D32LE_;
     static PredType *UNIX_D64BE_;
diff --git a/doxygen/dox/DDLBNF200.dox b/doxygen/dox/DDLBNF200.dox
index 9f4722db6a4..9ea466e25e4 100644
--- a/doxygen/dox/DDLBNF200.dox
+++ b/doxygen/dox/DDLBNF200.dox
@@ -96,11 +96,12 @@ This section contains a brief explanation of the symbols used in the DDL.
               H5T_NATIVE_LONG  | H5T_NATIVE_ULONG  |
               H5T_NATIVE_LLONG | H5T_NATIVE_ULLONG
 
-<float> ::= H5T_IEEE_F16BE     | H5T_IEEE_F16LE     | 
-            H5T_IEEE_F32BE     | H5T_IEEE_F32LE     |
-            H5T_IEEE_F64BE     | H5T_IEEE_F64LE     |
-            H5T_NATIVE_FLOAT16 | H5T_NATIVE_FLOAT   | 
-            H5T_NATIVE_DOUBLE  | H5T_NATIVE_LDOUBLE
+<float> ::= H5T_IEEE_F16BE       | H5T_IEEE_F16LE       |
+            H5T_IEEE_F32BE       | H5T_IEEE_F32LE       |
+            H5T_IEEE_F64BE       | H5T_IEEE_F64LE       |
+            H5T_FLOAT_BFLOAT16BE | H5T_FLOAT_BFLOAT16LE |
+            H5T_NATIVE_FLOAT16   | H5T_NATIVE_FLOAT     |
+            H5T_NATIVE_DOUBLE    | H5T_NATIVE_LDOUBLE
 
 <time> ::= H5T_TIME: not yet implemented
 
diff --git a/doxygen/dox/PredefinedDatatypeTables.dox b/doxygen/dox/PredefinedDatatypeTables.dox
index 7664e8bea04..733593d5145 100644
--- a/doxygen/dox/PredefinedDatatypeTables.dox
+++ b/doxygen/dox/PredefinedDatatypeTables.dox
@@ -11,6 +11,10 @@
  * </div>
  *
  * <div>
+ * \snippet{doc} tables/predefinedDatatypes.dox predefined_alt_float_datatypes_table
+ * </div>
+ *
+ * <div>
  * \snippet{doc} tables/predefinedDatatypes.dox predefined_complex_datatypes_table
  * </div>
  *
diff --git a/doxygen/examples/tables/predefinedDatatypes.dox b/doxygen/examples/tables/predefinedDatatypes.dox
index f73382ab865..ead4daca4f3 100644
--- a/doxygen/examples/tables/predefinedDatatypes.dox
+++ b/doxygen/examples/tables/predefinedDatatypes.dox
@@ -35,6 +35,25 @@
 //! [predefined_ieee_datatypes_table]
  *
  *
+//! [predefined_alt_float_datatypes_table]
+<table>
+<caption>Predefined Alternative Floating Point Datatypes</caption>
+<tr>
+<th>Datatype</th>
+<th>Description</th>
+</tr>
+<tr>
+<td>#H5T_FLOAT_BFLOAT16BE</td>
+<td>16-bit big-endian bfloat16 floating point</td>
+</tr>
+<tr>
+<td>#H5T_FLOAT_BFLOAT16LE</td>
+<td>16-bit little-endian bfloat16 floating point</td>
+</tr>
+</table>
+//! [predefined_alt_float_datatypes_table]
+ *
+ *
 //! [predefined_complex_datatypes_table]
 <table>
 <caption>Predefined Complex Number Datatypes</caption>
diff --git a/fortran/src/H5_f.c b/fortran/src/H5_f.c
index 2b27811ff10..a9300d9c045 100644
--- a/fortran/src/H5_f.c
+++ b/fortran/src/H5_f.c
@@ -245,6 +245,14 @@ h5init_types_c(hid_t_f *types, hid_t_f *floatingtypes, hid_t_f *integertypes)
         return ret_value;
     if ((floatingtypes[3] = (hid_t_f)H5Tcopy(H5T_IEEE_F64LE)) < 0)
         return ret_value;
+    if ((floatingtypes[4] = (hid_t_f)H5Tcopy(H5T_IEEE_F16BE)) < 0)
+        return ret_value;
+    if ((floatingtypes[5] = (hid_t_f)H5Tcopy(H5T_IEEE_F16LE)) < 0)
+        return ret_value;
+    if ((floatingtypes[6] = (hid_t_f)H5Tcopy(H5T_FLOAT_BFLOAT16BE)) < 0)
+        return ret_value;
+    if ((floatingtypes[7] = (hid_t_f)H5Tcopy(H5T_FLOAT_BFLOAT16LE)) < 0)
+        return ret_value;
 
     if ((integertypes[0] = (hid_t_f)H5Tcopy(H5T_STD_I8BE)) < 0)
         return ret_value;
diff --git a/fortran/src/H5_ff.F90 b/fortran/src/H5_ff.F90
index fd871829f4f..33e62b16b62 100644
--- a/fortran/src/H5_ff.F90
+++ b/fortran/src/H5_ff.F90
@@ -287,10 +287,14 @@ CONTAINS
     H5T_NATIVE_B64                = predef_types(18)
     H5T_NATIVE_FLOAT_128          = predef_types(19)
 
-    H5T_IEEE_F32BE = floating_types(1)
-    H5T_IEEE_F32LE = floating_types(2)
-    H5T_IEEE_F64BE = floating_types(3)
-    H5T_IEEE_F64LE = floating_types(4)
+    H5T_IEEE_F32BE       = floating_types(1)
+    H5T_IEEE_F32LE       = floating_types(2)
+    H5T_IEEE_F64BE       = floating_types(3)
+    H5T_IEEE_F64LE       = floating_types(4)
+    H5T_IEEE_F16BE       = floating_types(5)
+    H5T_IEEE_F16LE       = floating_types(6)
+    H5T_FLOAT_BFLOAT16BE = floating_types(7)
+    H5T_FLOAT_BFLOAT16LE = floating_types(8)
 
     H5T_STD_I8BE   = integer_types(1)
     H5T_STD_I8LE   = integer_types(2)
diff --git a/fortran/src/H5f90global.F90 b/fortran/src/H5f90global.F90
index 7e486cffdfe..7e691ee38bf 100644
--- a/fortran/src/H5f90global.F90
+++ b/fortran/src/H5f90global.F90
@@ -63,7 +63,7 @@ MODULE H5GLOBAL
   ! Do not forget to change these values when new predefined
   ! datatypes are added
   INTEGER, PARAMETER :: PREDEF_TYPES_LEN = 19
-  INTEGER, PARAMETER :: FLOATING_TYPES_LEN = 4
+  INTEGER, PARAMETER :: FLOATING_TYPES_LEN = 8
   INTEGER, PARAMETER :: INTEGER_TYPES_LEN = 28
 
   ! These arrays need to be global because they are used in
@@ -87,6 +87,10 @@ MODULE H5GLOBAL
   !DEC$ATTRIBUTES DLLEXPORT :: H5T_IEEE_F32LE
   !DEC$ATTRIBUTES DLLEXPORT :: H5T_IEEE_F64BE
   !DEC$ATTRIBUTES DLLEXPORT :: H5T_IEEE_F64LE
+  !DEC$ATTRIBUTES DLLEXPORT :: H5T_IEEE_F16BE
+  !DEC$ATTRIBUTES DLLEXPORT :: H5T_IEEE_F16LE
+  !DEC$ATTRIBUTES DLLEXPORT :: H5T_FLOAT_BFLOAT16BE
+  !DEC$ATTRIBUTES DLLEXPORT :: H5T_FLOAT_BFLOAT16LE
   !DEC$ATTRIBUTES DLLEXPORT :: H5T_STD_I8BE
   !DEC$ATTRIBUTES DLLEXPORT :: H5T_STD_I8LE
   !DEC$ATTRIBUTES DLLEXPORT :: H5T_STD_I16BE
@@ -137,6 +141,10 @@ MODULE H5GLOBAL
   INTEGER(HID_T) :: H5T_IEEE_F32LE  !< H5T_IEEE_F32LE
   INTEGER(HID_T) :: H5T_IEEE_F64BE  !< H5T_IEEE_F64BE
   INTEGER(HID_T) :: H5T_IEEE_F64LE  !< H5T_IEEE_F64LE
+  INTEGER(HID_T) :: H5T_IEEE_F16BE  !< H5T_IEEE_F16BE
+  INTEGER(HID_T) :: H5T_IEEE_F16LE  !< H5T_IEEE_F16LE
+  INTEGER(HID_T) :: H5T_FLOAT_BFLOAT16BE  !< H5T_FLOAT_BFLOAT16BE
+  INTEGER(HID_T) :: H5T_FLOAT_BFLOAT16LE  !< H5T_FLOAT_BFLOAT16LE
   INTEGER(HID_T) :: H5T_STD_I8BE  !< H5T_STD_I8BE
   INTEGER(HID_T) :: H5T_STD_I8LE  !< H5T_STD_I8LE
   INTEGER(HID_T) :: H5T_STD_I16BE  !< H5T_STD_I16BE
diff --git a/hl/src/H5LT.c b/hl/src/H5LT.c
index 2bde0d7ddee..e737009d99b 100644
--- a/hl/src/H5LT.c
+++ b/hl/src/H5LT.c
@@ -2305,6 +2305,12 @@ H5LT_dtype_to_text(hid_t dtype, char *dt_str, H5LT_lang_t lang, size_t *slen, bo
             else if (H5Tequal(dtype, H5T_IEEE_F64LE)) {
                 snprintf(dt_str, *slen, "H5T_IEEE_F64LE");
             }
+            else if (H5Tequal(dtype, H5T_FLOAT_BFLOAT16BE)) {
+                snprintf(dt_str, *slen, "H5T_FLOAT_BFLOAT16BE");
+            }
+            else if (H5Tequal(dtype, H5T_FLOAT_BFLOAT16LE)) {
+                snprintf(dt_str, *slen, "H5T_FLOAT_BFLOAT16LE");
+            }
 #ifdef H5_HAVE__FLOAT16
             else if (H5Tequal(dtype, H5T_NATIVE_FLOAT16)) {
                 snprintf(dt_str, *slen, "H5T_NATIVE_FLOAT16");
diff --git a/hl/src/H5LTanalyze.c b/hl/src/H5LTanalyze.c
index 5ee4a2c3d47..300332facd5 100644
--- a/hl/src/H5LTanalyze.c
+++ b/hl/src/H5LTanalyze.c
@@ -645,8 +645,8 @@ static void yynoreturn yy_fatal_error ( const char* msg  );
 	(yy_hold_char) = *yy_cp; \
 	*yy_cp = '\0'; \
 	(yy_c_buf_p) = yy_cp;
-#define YY_NUM_RULES 77
-#define YY_END_OF_BUFFER 78
+#define YY_NUM_RULES 79
+#define YY_END_OF_BUFFER 80
 /* This struct is not used in this scanner,
    but its presence is necessary. */
 struct yy_trans_info
@@ -654,45 +654,47 @@ struct yy_trans_info
 	flex_int32_t yy_verify;
 	flex_int32_t yy_nxt;
 	};
-static const flex_int16_t yy_accept[335] =
+static const flex_int16_t yy_accept[352] =
     {   0,
-       76,   76,   78,   77,   76,   77,   68,   74,   75,   77,
-       77,   77,   77,   72,   73,   70,   71,   76,    0,   68,
-        0,    0,    0,    0,    0,   69,    0,    0,    0,    0,
-        0,   50,    0,    0,    0,    0,    0,   51,    0,    0,
+       78,   78,   80,   79,   78,   79,   70,   76,   77,   79,
+       79,   79,   79,   74,   75,   72,   73,   78,    0,   70,
+        0,    0,    0,    0,    0,   71,    0,    0,    0,    0,
+        0,   52,    0,    0,    0,    0,    0,   53,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,    0,    0,   49,    0,    0,    0,    0,
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,   67,   48,    0,    0,    0,   57,   61,    0,    0,
-        0,    0,    0,    0,    0,    0,   63,   66,   62,    0,
-
+        0,    0,    0,    0,    0,    0,   51,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,   69,   50,    0,    0,    0,   59,   63,
         0,    0,    0,    0,    0,    0,    0,    0,    0,   65,
-        0,    0,    0,    0,    0,    0,    0,    0,   47,    0,
-        0,    0,   64,    0,    0,    0,    0,    0,    0,    0,
+
+       68,   64,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,    0,    0,   60,    0,    0,    0,    0,
+        0,    0,    0,    0,   67,    0,    0,    0,    0,    0,
+        0,    0,    0,   49,    0,    0,    0,   66,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,    0,    0,    1,    2,    0,    0,    0,
-        0,    0,    0,    9,   10,    0,    0,   59,    0,    0,
-       56,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,   62,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    1,    2,    0,    0,    0,    0,    0,    0,
+        9,   10,    0,    0,   61,    0,    0,   58,    0,    0,
 
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    3,    4,    5,    6,    7,    8,   11,   12,   13,
-       14,   15,   16,    0,    0,    0,    0,   55,   58,   28,
-       29,   30,   31,   32,   33,    0,    0,    0,   22,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    3,
+        4,    5,    6,    7,    8,   11,   12,   13,   14,   15,
+       16,    0,    0,    0,    0,   57,    0,   60,   28,   29,
+       30,   31,   32,   33,    0,    0,    0,   22,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,   17,    0,    0,    0,    0,   24,    0,
-        0,    0,   23,    0,    0,    0,   53,    0,    0,    0,
-        0,   35,    0,   26,   18,   20,   19,    0,   25,    0,
-       52,   54,    0,   36,    0,    0,    0,   27,   21,    0,
-        0,   34,    0,   37,    0,    0,    0,    0,    0,    0,
+        0,    0,   23,    0,    0,    0,   55,    0,    0,    0,
+        0,    0,   37,    0,   26,   18,   20,   19,    0,   25,
+        0,   54,   56,    0,    0,   38,    0,    0,    0,   27,
 
+       21,    0,    0,    0,   36,    0,   39,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,   34,   35,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,    0,    0,   38,   39,   40,   41,   42,
-       43,    0,    0,    0,    0,    0,    0,    0,   44,    0,
-       45,    0,   46,    0
+        0,    0,   40,   41,   42,   43,   44,   45,    0,    0,
+        0,    0,    0,    0,    0,   46,    0,   47,    0,   48,
+        0
     } ;
 
 static const YY_CHAR yy_ec[256] =
@@ -736,184 +738,190 @@ static const YY_CHAR yy_meta[42] =
         1
     } ;
 
-static const flex_int16_t yy_base[337] =
+static const flex_int16_t yy_base[354] =
     {   0,
-        0,    0,  360,  361,  357,    0,    0,  361,  361,   12,
-      349,  330,  325,  361,  361,  361,  361,  353,  351,    0,
-      335,  317,  320,  322,  320,  361,  317,  320,  307,  306,
-       17,  361,  326,   34,   15,  329,  320,  361,  312,   31,
-      315,  313,  320,  323,  309,  304,   35,  312,  319,  315,
-      295,  301,  305,  310,  297,  294,  296,  306,  292,  308,
-       34,  292,  302,  283,  298,  361,  299,  302,  288,  283,
-      308,  288,  280,  292,  287,  280,  268,   32,  284,  280,
-      286,  361,  361,  268,   39,  263,  361,  361,  272,  261,
-      266,  266,   44,  272,   43,  282,  361,  361,  361,  277,
+        0,    0,  377,  378,  374,    0,    0,  378,  378,   12,
+      366,  347,  342,  378,  378,  378,  378,  370,  368,    0,
+      352,  334,  337,  339,  337,  378,  334,  337,  324,  323,
+       17,  378,  343,   34,   15,  346,  337,  378,  329,   31,
+      332,   28,  338,  341,  327,  322,   35,  330,  337,  333,
+      313,  319,  323,  328,  315,  312,  317,  313,  323,  309,
+      325,   45,  309,  319,  300,  315,  378,  316,  319,  305,
+      300,  325,  305,  314,  296,  308,  303,  296,  284,   33,
+      300,  296,  302,  378,  378,  284,   40,  279,  378,  378,
+      286,  287,  276,  281,  281,   43,  287,   43,  297,  378,
 
-      262,   55,  279,  273,  273,  272,   67,   74,  269,  256,
-      260,  271,  251,  259,  253,  251,  256,   81,  241,  361,
-      269,  272,  269,   60,  266,  269,  266,   67,  361,  250,
-      258,  248,  231,  252,  252,  248,  227,  255,  258,  255,
-       76,   74,   79,   81,  244,  243,   86,   88,   90,  242,
-      241,  235,  241,  238,  233,  361,  232,  242,  222,   92,
-       95,   97,  230,  224,  226,  223,   99,   98,  101,  229,
-      228,  227,  226,  225,  224,  361,  361,  223,  222,  221,
-      220,  219,  218,  361,  361,   99,  217,  361,  216,  211,
-      361,  227,  213,  212,  211,  210,  209,  208,  211,  192,
+      378,  378,  292,  277,   55,  269,  293,  287,  287,  286,
+       71,   78,  283,  270,  274,  285,  265,  273,  267,  265,
+      280,  269,   85,  254,  378,  282,  285,  282,   56,  279,
+      282,  279,   71,  378,  263,  271,  261,  244,  265,  265,
+      261,  260,  239,  267,  270,  267,   80,   78,   83,   85,
+      256,  255,   90,   92,   94,  254,  253,  247,  253,  250,
+      245,  378,  244,  254,  241,  233,   96,   99,  101,  241,
+      235,  237,  234,  103,  102,  105,  240,  239,  238,  237,
+      236,  235,  378,  378,  234,  233,  232,  231,  230,  229,
+      378,  378,   53,  228,  378,  227,  222,  378,  217,  237,
 
-      197,  191,  195,  194,  194,  197,  191,  195,  190,  106,
-      193,  361,  361,  361,  361,  361,  361,  361,  361,  361,
-      361,  361,  361,  199,  194,  184,  192,  361,  361,  361,
-      361,  361,  361,  361,  361,  180,  193,  193,  361,  174,
-      180,  184,  189,  173,  187,  169,  173,  173,  171,  179,
-      166,  180,  175,  361,  169,  160,  175,  169,  361,  159,
-      156,  157,  361,  160,  164,  154,  361,  158,  164,  141,
-      161,   95,  155,  361,  361,  361,  361,  157,  361,  145,
-      361,  361,  156,  135,  163,  156,  153,  361,  361,  128,
-      154,  361,  143,  129,  157,  160,  157,  138,  139,  146,
+      223,  222,  221,  220,  219,  218,  221,  202,  207,  201,
+      205,  204,  204,  207,  201,  205,  200,  107,  203,  378,
+      378,  378,  378,  378,  378,  378,  378,  378,  378,  378,
+      378,  209,  204,  194,  202,  378,  205,  378,  378,  378,
+      378,  378,  378,  378,  189,  202,  202,  378,  183,  189,
+      193,  198,  182,  196,  178,  182,  182,  180,  188,  175,
+      189,  184,  170,  378,  177,  168,  183,  177,  378,  167,
+      164,  165,  378,  168,  172,  162,  378,  166,  172,  149,
+      182,  168,   86,  162,  378,  378,  378,  378,  164,  378,
+      152,  378,  378,  163,  171,  141,  169,  162,  159,  378,
 
-      113,  122,  124,  137,  133,  133,  140,  139,  138,  137,
-      136,  135,  125,  128,  125,  361,  361,  361,  361,  361,
-      361,  123,  126,  116,  124,  107,  117,   93,  361,  103,
-      361,   46,  361,  361,  147,   52
+      378,  127,  116,  160,  378,  149,  135,  163,  166,  163,
+      152,  151,  142,  143,  150,  121,  123,  125,  378,  378,
+      141,  137,  137,  144,  143,  142,  141,  140,  139,  129,
+      132,  130,  378,  378,  378,  378,  378,  378,  130,  134,
+      123,  129,  111,  120,  108,  378,  123,  378,   70,  378,
+      378,  148,   74
     } ;
 
-static const flex_int16_t yy_def[337] =
+static const flex_int16_t yy_def[354] =
     {   0,
-      334,    1,  334,  334,  334,  335,  336,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  335,  336,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
+      351,    1,  351,  351,  351,  352,  353,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  352,  353,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
 
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
 
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
 
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,    0,  334,  334
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+        0,  351,  351
     } ;
 
-static const flex_int16_t yy_nxt[403] =
+static const flex_int16_t yy_nxt[420] =
     {   0,
         4,    5,    6,    7,    7,    7,    7,    7,    7,    7,
         7,    8,    9,    4,    4,   10,    4,    4,    4,    4,
        11,    4,    4,    4,    4,   12,    4,    4,    4,   13,
         4,    4,    4,    4,    4,    4,   14,   15,    4,   16,
-       17,   21,   22,   36,   48,   49,   37,   39,   62,   40,
-       77,   41,   42,   94,   20,   43,   53,   63,   44,   45,
-       54,  100,   78,   46,  101,  107,   47,  110,  115,   55,
-       95,  121,  111,  122,  145,  108,  123,  124,  125,  333,
-      126,  150,  146,  127,  128,  138,  116,  139,  170,  151,
-      140,  163,  164,  172,  165,  174,  171,  166,  167,  285,
+       17,   21,   22,   36,   48,   49,   37,   39,   63,   40,
+       57,   41,   42,   58,   97,   43,   53,   64,   44,   45,
+       54,   79,  103,   46,  111,  104,   47,  114,  119,   55,
+      151,   98,  115,   80,  112,  126,   20,  127,  152,  232,
+      128,  129,  130,  233,  131,  156,  120,  132,  133,  144,
+      297,  145,  177,  157,  146,  170,  171,  179,  172,  181,
 
-      178,  173,  180,  175,  182,  168,  193,  169,  179,  195,
-      181,  197,  183,  206,  194,  203,  208,  196,  207,  198,
-      332,  204,  209,  210,  205,  224,  331,  307,  247,  225,
-      211,  248,  295,  286,  296,  308,  309,  297,  311,  330,
-      329,  328,  327,  326,  310,  325,  312,   19,  324,   19,
-      323,  322,  321,  320,  319,  318,  317,  316,  315,  314,
-      313,  306,  305,  304,  303,  302,  301,  300,  299,  298,
-      294,  293,  292,  291,  290,  289,  288,  287,  284,  283,
-      282,  281,  280,  279,  278,  277,  276,  275,  274,  273,
-      272,  271,  270,  269,  268,  267,  266,  265,  264,  263,
+      178,  173,  174,  350,  185,  180,  187,  182,  189,  175,
+      201,  176,  186,  203,  188,  205,  190,  214,  202,  211,
+      216,  204,  215,  206,  298,  212,  217,  218,  213,  256,
+      311,  308,  257,  309,  219,  324,  310,  326,  312,  328,
+      349,  348,  347,  325,  346,  327,  345,  329,   19,  344,
+       19,  343,  342,  341,  340,  339,  338,  337,  336,  335,
+      334,  333,  332,  331,  330,  323,  322,  321,  320,  319,
+      318,  317,  316,  315,  314,  313,  307,  306,  305,  304,
+      303,  302,  301,  300,  299,  296,  295,  294,  293,  292,
+      291,  290,  289,  288,  287,  286,  285,  284,  283,  282,
 
-      262,  261,  260,  259,  258,  257,  256,  255,  254,  253,
-      252,  251,  250,  249,  246,  245,  244,  243,  242,  241,
-      240,  239,  238,  237,  236,  235,  234,  233,  232,  231,
-      230,  229,  228,  227,  226,  223,  222,  221,  220,  219,
-      218,  217,  216,  215,  214,  213,  212,  202,  201,  200,
-      199,  192,  191,  190,  189,  188,  187,  186,  185,  184,
-      177,  176,  162,  161,  160,  159,  158,  157,  156,  155,
-      154,  153,  152,  149,  148,  147,  144,  143,  142,  141,
-      137,  136,  135,  134,  133,  132,  131,  130,  129,  120,
-      119,  118,  117,  114,  113,  112,  109,  106,  105,  104,
+      281,  280,  279,  278,  277,  276,  275,  274,  273,  272,
+      271,  270,  269,  268,  267,  266,  265,  264,  263,  262,
+      261,  260,  259,  258,  255,  254,  253,  252,  251,  250,
+      249,  248,  247,  246,  245,  244,  243,  242,  241,  240,
+      239,  238,  237,  236,  235,  234,  231,  230,  229,  228,
+      227,  226,  225,  224,  223,  222,  221,  220,  210,  209,
+      208,  207,  200,  199,  198,  197,  196,  195,  194,  193,
+      192,  191,  184,  183,  169,  168,  167,  166,  165,  164,
+      163,  162,  161,  160,  159,  158,  155,  154,  153,  150,
+      149,  148,  147,  143,  142,  141,  140,  139,  138,  137,
 
-      103,  102,   99,   98,   97,   96,   93,   92,   91,   90,
-       89,   88,   87,   86,   85,   84,   83,   82,   81,   80,
-       79,   76,   75,   74,   73,   72,   71,   70,   69,   68,
-       67,   66,   65,   64,   61,   60,   59,   58,   57,   56,
-       52,   51,   50,   38,   35,   34,   33,   32,   31,   30,
-       29,   28,   27,   26,   18,   25,   24,   23,   18,  334,
-        3,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
+      136,  135,  134,  125,  124,  123,  122,  121,  118,  117,
+      116,  113,  110,  109,  108,  107,  106,  105,  102,  101,
+      100,   99,   96,   95,   94,   93,   92,   91,   90,   89,
+       88,   87,   86,   85,   84,   83,   82,   81,   78,   77,
+       76,   75,   74,   73,   72,   71,   70,   69,   68,   67,
+       66,   65,   62,   61,   60,   59,   56,   52,   51,   50,
+       38,   35,   34,   33,   32,   31,   30,   29,   28,   27,
+       26,   18,   25,   24,   23,   18,  351,    3,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
 
-      334,  334
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351
     } ;
 
-static const flex_int16_t yy_chk[403] =
+static const flex_int16_t yy_chk[420] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,   10,   10,   31,   35,   35,   31,   34,   47,   34,
-       61,   34,   34,   78,  336,   34,   40,   47,   34,   34,
-       40,   85,   61,   34,   85,   93,   34,   95,  102,   40,
-       78,  107,   95,  107,  124,   93,  107,  107,  108,  332,
-      108,  128,  124,  108,  108,  118,  102,  118,  142,  128,
-      118,  141,  141,  143,  141,  144,  142,  141,  141,  272,
+       42,   34,   34,   42,   80,   34,   40,   47,   34,   34,
+       40,   62,   87,   34,   96,   87,   34,   98,  105,   40,
+      129,   80,   98,   62,   96,  111,  353,  111,  129,  193,
+      111,  111,  112,  193,  112,  133,  105,  112,  112,  123,
+      283,  123,  148,  133,  123,  147,  147,  149,  147,  150,
 
-      147,  143,  148,  144,  149,  141,  160,  141,  147,  161,
-      148,  162,  149,  168,  160,  167,  169,  161,  168,  162,
-      330,  167,  169,  169,  167,  186,  328,  301,  210,  186,
-      169,  210,  290,  272,  290,  301,  302,  290,  303,  327,
-      326,  325,  324,  323,  302,  322,  303,  335,  315,  335,
-      314,  313,  312,  311,  310,  309,  308,  307,  306,  305,
-      304,  300,  299,  298,  297,  296,  295,  294,  293,  291,
-      287,  286,  285,  284,  283,  280,  278,  273,  271,  270,
-      269,  268,  266,  265,  264,  262,  261,  260,  258,  257,
-      256,  255,  253,  252,  251,  250,  249,  248,  247,  246,
+      148,  147,  147,  349,  153,  149,  154,  150,  155,  147,
+      167,  147,  153,  168,  154,  169,  155,  175,  167,  174,
+      176,  168,  175,  169,  283,  174,  176,  176,  174,  218,
+      303,  302,  218,  302,  176,  316,  302,  317,  303,  318,
+      347,  345,  344,  316,  343,  317,  342,  318,  352,  341,
+      352,  340,  339,  332,  331,  330,  329,  328,  327,  326,
+      325,  324,  323,  322,  321,  315,  314,  313,  312,  311,
+      310,  309,  308,  307,  306,  304,  299,  298,  297,  296,
+      295,  294,  291,  289,  284,  282,  281,  280,  279,  278,
+      276,  275,  274,  272,  271,  270,  268,  267,  266,  265,
 
-      245,  244,  243,  242,  241,  240,  238,  237,  236,  227,
-      226,  225,  224,  211,  209,  208,  207,  206,  205,  204,
-      203,  202,  201,  200,  199,  198,  197,  196,  195,  194,
-      193,  192,  190,  189,  187,  183,  182,  181,  180,  179,
-      178,  175,  174,  173,  172,  171,  170,  166,  165,  164,
-      163,  159,  158,  157,  155,  154,  153,  152,  151,  150,
-      146,  145,  140,  139,  138,  137,  136,  135,  134,  133,
-      132,  131,  130,  127,  126,  125,  123,  122,  121,  119,
-      117,  116,  115,  114,  113,  112,  111,  110,  109,  106,
-      105,  104,  103,  101,  100,   96,   94,   92,   91,   90,
+      263,  262,  261,  260,  259,  258,  257,  256,  255,  254,
+      253,  252,  251,  250,  249,  247,  246,  245,  237,  235,
+      234,  233,  232,  219,  217,  216,  215,  214,  213,  212,
+      211,  210,  209,  208,  207,  206,  205,  204,  203,  202,
+      201,  200,  199,  197,  196,  194,  190,  189,  188,  187,
+      186,  185,  182,  181,  180,  179,  178,  177,  173,  172,
+      171,  170,  166,  165,  164,  163,  161,  160,  159,  158,
+      157,  156,  152,  151,  146,  145,  144,  143,  142,  141,
+      140,  139,  138,  137,  136,  135,  132,  131,  130,  128,
+      127,  126,  124,  122,  121,  120,  119,  118,  117,  116,
 
-       89,   86,   84,   81,   80,   79,   77,   76,   75,   74,
-       73,   72,   71,   70,   69,   68,   67,   65,   64,   63,
-       62,   60,   59,   58,   57,   56,   55,   54,   53,   52,
-       51,   50,   49,   48,   46,   45,   44,   43,   42,   41,
-       39,   37,   36,   33,   30,   29,   28,   27,   25,   24,
-       23,   22,   21,   19,   18,   13,   12,   11,    5,    3,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
-      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
+      115,  114,  113,  110,  109,  108,  107,  106,  104,  103,
+       99,   97,   95,   94,   93,   92,   91,   88,   86,   83,
+       82,   81,   79,   78,   77,   76,   75,   74,   73,   72,
+       71,   70,   69,   68,   66,   65,   64,   63,   61,   60,
+       59,   58,   57,   56,   55,   54,   53,   52,   51,   50,
+       49,   48,   46,   45,   44,   43,   41,   39,   37,   36,
+       33,   30,   29,   28,   27,   25,   24,   23,   22,   21,
+       19,   18,   13,   12,   11,    5,    3,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
 
-      334,  334
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351
     } ;
 
 static yy_state_type yy_last_accepting_state;
@@ -972,8 +980,8 @@ static int my_yyinput(char *, int);
 extern char *myinput;
 extern size_t input_len;
 
-#line 946 "hl/src//H5LTanalyze.c"
-#line 947 "hl/src//H5LTanalyze.c"
+#line 954 "hl/src//H5LTanalyze.c"
+#line 955 "hl/src//H5LTanalyze.c"
 
 #define INITIAL 0
 
@@ -1185,7 +1193,7 @@ YY_DECL
 #line 53 "hl/src//H5LTanalyze.l"
 
 
-#line 1159 "hl/src//H5LTanalyze.c"
+#line 1167 "hl/src//H5LTanalyze.c"
 
 	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
 		{
@@ -1212,13 +1220,13 @@ yy_match:
 			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 				{
 				yy_current_state = (int) yy_def[yy_current_state];
-				if ( yy_current_state >= 335 )
+				if ( yy_current_state >= 352 )
 					yy_c = yy_meta[yy_c];
 				}
 			yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
 			++yy_cp;
 			}
-		while ( yy_base[yy_current_state] != 361 );
+		while ( yy_base[yy_current_state] != 378 );
 
 yy_find_action:
 		yy_act = yy_accept[yy_current_state];
@@ -1410,232 +1418,242 @@ YY_RULE_SETUP
 case 34:
 YY_RULE_SETUP
 #line 91 "hl/src//H5LTanalyze.l"
-{return hid(H5T_NATIVE_FLOAT16_TOKEN);}
+{return hid(H5T_FLOAT_BFLOAT16BE_TOKEN);}
 	YY_BREAK
 case 35:
 YY_RULE_SETUP
 #line 92 "hl/src//H5LTanalyze.l"
-{return hid(H5T_NATIVE_FLOAT_TOKEN);}
+{return hid(H5T_FLOAT_BFLOAT16LE_TOKEN);}
 	YY_BREAK
 case 36:
 YY_RULE_SETUP
 #line 93 "hl/src//H5LTanalyze.l"
-{return hid(H5T_NATIVE_DOUBLE_TOKEN);}
+{return hid(H5T_NATIVE_FLOAT16_TOKEN);}
 	YY_BREAK
 case 37:
 YY_RULE_SETUP
 #line 94 "hl/src//H5LTanalyze.l"
-{return hid(H5T_NATIVE_LDOUBLE_TOKEN);}
+{return hid(H5T_NATIVE_FLOAT_TOKEN);}
 	YY_BREAK
 case 38:
 YY_RULE_SETUP
-#line 96 "hl/src//H5LTanalyze.l"
-{return hid(H5T_COMPLEX_IEEE_F16BE_TOKEN);}
+#line 95 "hl/src//H5LTanalyze.l"
+{return hid(H5T_NATIVE_DOUBLE_TOKEN);}
 	YY_BREAK
 case 39:
 YY_RULE_SETUP
-#line 97 "hl/src//H5LTanalyze.l"
-{return hid(H5T_COMPLEX_IEEE_F16LE_TOKEN);}
+#line 96 "hl/src//H5LTanalyze.l"
+{return hid(H5T_NATIVE_LDOUBLE_TOKEN);}
 	YY_BREAK
 case 40:
 YY_RULE_SETUP
 #line 98 "hl/src//H5LTanalyze.l"
-{return hid(H5T_COMPLEX_IEEE_F32BE_TOKEN);}
+{return hid(H5T_COMPLEX_IEEE_F16BE_TOKEN);}
 	YY_BREAK
 case 41:
 YY_RULE_SETUP
 #line 99 "hl/src//H5LTanalyze.l"
-{return hid(H5T_COMPLEX_IEEE_F32LE_TOKEN);}
+{return hid(H5T_COMPLEX_IEEE_F16LE_TOKEN);}
 	YY_BREAK
 case 42:
 YY_RULE_SETUP
 #line 100 "hl/src//H5LTanalyze.l"
-{return hid(H5T_COMPLEX_IEEE_F64BE_TOKEN);}
+{return hid(H5T_COMPLEX_IEEE_F32BE_TOKEN);}
 	YY_BREAK
 case 43:
 YY_RULE_SETUP
 #line 101 "hl/src//H5LTanalyze.l"
-{return hid(H5T_COMPLEX_IEEE_F64LE_TOKEN);}
+{return hid(H5T_COMPLEX_IEEE_F32LE_TOKEN);}
 	YY_BREAK
 case 44:
 YY_RULE_SETUP
 #line 102 "hl/src//H5LTanalyze.l"
-{return hid(H5T_NATIVE_FLOAT_COMPLEX_TOKEN);}
+{return hid(H5T_COMPLEX_IEEE_F64BE_TOKEN);}
 	YY_BREAK
 case 45:
 YY_RULE_SETUP
 #line 103 "hl/src//H5LTanalyze.l"
-{return hid(H5T_NATIVE_DOUBLE_COMPLEX_TOKEN);}
+{return hid(H5T_COMPLEX_IEEE_F64LE_TOKEN);}
 	YY_BREAK
 case 46:
 YY_RULE_SETUP
 #line 104 "hl/src//H5LTanalyze.l"
-{return hid(H5T_NATIVE_LDOUBLE_COMPLEX_TOKEN);}
+{return hid(H5T_NATIVE_FLOAT_COMPLEX_TOKEN);}
 	YY_BREAK
 case 47:
 YY_RULE_SETUP
-#line 106 "hl/src//H5LTanalyze.l"
-{return token(H5T_STRING_TOKEN);}
+#line 105 "hl/src//H5LTanalyze.l"
+{return hid(H5T_NATIVE_DOUBLE_COMPLEX_TOKEN);}
 	YY_BREAK
 case 48:
 YY_RULE_SETUP
-#line 107 "hl/src//H5LTanalyze.l"
-{return token(STRSIZE_TOKEN);}
+#line 106 "hl/src//H5LTanalyze.l"
+{return hid(H5T_NATIVE_LDOUBLE_COMPLEX_TOKEN);}
 	YY_BREAK
 case 49:
 YY_RULE_SETUP
 #line 108 "hl/src//H5LTanalyze.l"
-{return token(STRPAD_TOKEN);}
+{return token(H5T_STRING_TOKEN);}
 	YY_BREAK
 case 50:
 YY_RULE_SETUP
 #line 109 "hl/src//H5LTanalyze.l"
-{return token(CSET_TOKEN);}
+{return token(STRSIZE_TOKEN);}
 	YY_BREAK
 case 51:
 YY_RULE_SETUP
 #line 110 "hl/src//H5LTanalyze.l"
-{return token(CTYPE_TOKEN);}
+{return token(STRPAD_TOKEN);}
 	YY_BREAK
 case 52:
 YY_RULE_SETUP
 #line 111 "hl/src//H5LTanalyze.l"
-{return token(H5T_STR_NULLTERM_TOKEN);}
+{return token(CSET_TOKEN);}
 	YY_BREAK
 case 53:
 YY_RULE_SETUP
 #line 112 "hl/src//H5LTanalyze.l"
-{return token(H5T_STR_NULLPAD_TOKEN);}
+{return token(CTYPE_TOKEN);}
 	YY_BREAK
 case 54:
 YY_RULE_SETUP
 #line 113 "hl/src//H5LTanalyze.l"
-{return token(H5T_STR_SPACEPAD_TOKEN);}
+{return token(H5T_STR_NULLTERM_TOKEN);}
 	YY_BREAK
 case 55:
 YY_RULE_SETUP
 #line 114 "hl/src//H5LTanalyze.l"
-{return token(H5T_CSET_ASCII_TOKEN);}
+{return token(H5T_STR_NULLPAD_TOKEN);}
 	YY_BREAK
 case 56:
 YY_RULE_SETUP
 #line 115 "hl/src//H5LTanalyze.l"
-{return token(H5T_CSET_UTF8_TOKEN);}
+{return token(H5T_STR_SPACEPAD_TOKEN);}
 	YY_BREAK
 case 57:
 YY_RULE_SETUP
 #line 116 "hl/src//H5LTanalyze.l"
-{return token(H5T_C_S1_TOKEN);}
+{return token(H5T_CSET_ASCII_TOKEN);}
 	YY_BREAK
 case 58:
 YY_RULE_SETUP
 #line 117 "hl/src//H5LTanalyze.l"
-{return token(H5T_FORTRAN_S1_TOKEN);}
+{return token(H5T_CSET_UTF8_TOKEN);}
 	YY_BREAK
 case 59:
 YY_RULE_SETUP
 #line 118 "hl/src//H5LTanalyze.l"
-{return token(H5T_VARIABLE_TOKEN);}
+{return token(H5T_C_S1_TOKEN);}
 	YY_BREAK
 case 60:
 YY_RULE_SETUP
-#line 120 "hl/src//H5LTanalyze.l"
-{return token(H5T_COMPOUND_TOKEN);}
+#line 119 "hl/src//H5LTanalyze.l"
+{return token(H5T_FORTRAN_S1_TOKEN);}
 	YY_BREAK
 case 61:
 YY_RULE_SETUP
-#line 121 "hl/src//H5LTanalyze.l"
-{return token(H5T_ENUM_TOKEN);}
+#line 120 "hl/src//H5LTanalyze.l"
+{return token(H5T_VARIABLE_TOKEN);}
 	YY_BREAK
 case 62:
 YY_RULE_SETUP
 #line 122 "hl/src//H5LTanalyze.l"
-{return token(H5T_ARRAY_TOKEN);}
+{return token(H5T_COMPOUND_TOKEN);}
 	YY_BREAK
 case 63:
 YY_RULE_SETUP
 #line 123 "hl/src//H5LTanalyze.l"
-{return token(H5T_VLEN_TOKEN);}
+{return token(H5T_ENUM_TOKEN);}
 	YY_BREAK
 case 64:
 YY_RULE_SETUP
 #line 124 "hl/src//H5LTanalyze.l"
-{return token(H5T_COMPLEX_TOKEN);}
+{return token(H5T_ARRAY_TOKEN);}
 	YY_BREAK
 case 65:
 YY_RULE_SETUP
-#line 126 "hl/src//H5LTanalyze.l"
-{return token(H5T_OPAQUE_TOKEN);}
+#line 125 "hl/src//H5LTanalyze.l"
+{return token(H5T_VLEN_TOKEN);}
 	YY_BREAK
 case 66:
 YY_RULE_SETUP
-#line 127 "hl/src//H5LTanalyze.l"
-{return token(OPQ_SIZE_TOKEN);}
+#line 126 "hl/src//H5LTanalyze.l"
+{return token(H5T_COMPLEX_TOKEN);}
 	YY_BREAK
 case 67:
 YY_RULE_SETUP
 #line 128 "hl/src//H5LTanalyze.l"
-{return token(OPQ_TAG_TOKEN);}
+{return token(H5T_OPAQUE_TOKEN);}
 	YY_BREAK
 case 68:
 YY_RULE_SETUP
+#line 129 "hl/src//H5LTanalyze.l"
+{return token(OPQ_SIZE_TOKEN);}
+	YY_BREAK
+case 69:
+YY_RULE_SETUP
 #line 130 "hl/src//H5LTanalyze.l"
+{return token(OPQ_TAG_TOKEN);}
+	YY_BREAK
+case 70:
+YY_RULE_SETUP
+#line 132 "hl/src//H5LTanalyze.l"
 {
                         H5LTyylval.ival = atoi(yytext);
                         return NUMBER;
                  }
 	YY_BREAK
-case 69:
-/* rule 69 can match eol */
+case 71:
+/* rule 71 can match eol */
 YY_RULE_SETUP
-#line 135 "hl/src//H5LTanalyze.l"
+#line 137 "hl/src//H5LTanalyze.l"
 {
                     H5LTyylval.sval = trim_quotes(yytext);
                     return STRING;
                  }
 	YY_BREAK
-case 70:
-YY_RULE_SETUP
-#line 140 "hl/src//H5LTanalyze.l"
-{return token('{');}
-	YY_BREAK
-case 71:
-YY_RULE_SETUP
-#line 141 "hl/src//H5LTanalyze.l"
-{return token('}');}
-	YY_BREAK
 case 72:
 YY_RULE_SETUP
 #line 142 "hl/src//H5LTanalyze.l"
-{return token('[');}
+{return token('{');}
 	YY_BREAK
 case 73:
 YY_RULE_SETUP
 #line 143 "hl/src//H5LTanalyze.l"
-{return token(']');}
+{return token('}');}
 	YY_BREAK
 case 74:
 YY_RULE_SETUP
 #line 144 "hl/src//H5LTanalyze.l"
-{return token(':');}
+{return token('[');}
 	YY_BREAK
 case 75:
 YY_RULE_SETUP
 #line 145 "hl/src//H5LTanalyze.l"
-{return token(';');}
+{return token(']');}
 	YY_BREAK
 case 76:
-/* rule 76 can match eol */
 YY_RULE_SETUP
 #line 146 "hl/src//H5LTanalyze.l"
-;
+{return token(':');}
 	YY_BREAK
 case 77:
 YY_RULE_SETUP
+#line 147 "hl/src//H5LTanalyze.l"
+{return token(';');}
+	YY_BREAK
+case 78:
+/* rule 78 can match eol */
+YY_RULE_SETUP
 #line 148 "hl/src//H5LTanalyze.l"
+;
+	YY_BREAK
+case 79:
+YY_RULE_SETUP
+#line 150 "hl/src//H5LTanalyze.l"
 ECHO;
 	YY_BREAK
-#line 1609 "hl/src//H5LTanalyze.c"
+#line 1627 "hl/src//H5LTanalyze.c"
 case YY_STATE_EOF(INITIAL):
 	yyterminate();
 
@@ -1932,7 +1950,7 @@ static int yy_get_next_buffer (void)
 		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 			{
 			yy_current_state = (int) yy_def[yy_current_state];
-			if ( yy_current_state >= 335 )
+			if ( yy_current_state >= 352 )
 				yy_c = yy_meta[yy_c];
 			}
 		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
@@ -1960,11 +1978,11 @@ static int yy_get_next_buffer (void)
 	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 		{
 		yy_current_state = (int) yy_def[yy_current_state];
-		if ( yy_current_state >= 335 )
+		if ( yy_current_state >= 352 )
 			yy_c = yy_meta[yy_c];
 		}
 	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
-	yy_is_jam = (yy_current_state == 334);
+	yy_is_jam = (yy_current_state == 351);
 
 		return yy_is_jam ? 0 : yy_current_state;
 }
@@ -2640,7 +2658,7 @@ void yyfree (void * ptr )
 
 #define YYTABLES_NAME "yytables"
 
-#line 148 "hl/src//H5LTanalyze.l"
+#line 150 "hl/src//H5LTanalyze.l"
 
 
 /* Allocate a copy of `quoted` with the double quote character at
diff --git a/hl/src/H5LTanalyze.l b/hl/src/H5LTanalyze.l
index 84b0a61f03a..6acefd6f981 100644
--- a/hl/src/H5LTanalyze.l
+++ b/hl/src/H5LTanalyze.l
@@ -82,16 +82,18 @@ H5T_NATIVE_ULONG {return hid(H5T_NATIVE_ULONG_TOKEN);}
 H5T_NATIVE_LLONG   {return hid(H5T_NATIVE_LLONG_TOKEN);}
 H5T_NATIVE_ULLONG  {return hid(H5T_NATIVE_ULLONG_TOKEN);}
 
-H5T_IEEE_F16BE   {return hid(H5T_IEEE_F16BE_TOKEN);}
-H5T_IEEE_F16LE   {return hid(H5T_IEEE_F16LE_TOKEN);}
-H5T_IEEE_F32BE   {return hid(H5T_IEEE_F32BE_TOKEN);}
-H5T_IEEE_F32LE   {return hid(H5T_IEEE_F32LE_TOKEN);}
-H5T_IEEE_F64BE   {return hid(H5T_IEEE_F64BE_TOKEN);}
-H5T_IEEE_F64LE   {return hid(H5T_IEEE_F64LE_TOKEN);}
-H5T_NATIVE_FLOAT16 {return hid(H5T_NATIVE_FLOAT16_TOKEN);}
-H5T_NATIVE_FLOAT   {return hid(H5T_NATIVE_FLOAT_TOKEN);}
-H5T_NATIVE_DOUBLE  {return hid(H5T_NATIVE_DOUBLE_TOKEN);}
-H5T_NATIVE_LDOUBLE {return hid(H5T_NATIVE_LDOUBLE_TOKEN);}
+H5T_IEEE_F16BE       {return hid(H5T_IEEE_F16BE_TOKEN);}
+H5T_IEEE_F16LE       {return hid(H5T_IEEE_F16LE_TOKEN);}
+H5T_IEEE_F32BE       {return hid(H5T_IEEE_F32BE_TOKEN);}
+H5T_IEEE_F32LE       {return hid(H5T_IEEE_F32LE_TOKEN);}
+H5T_IEEE_F64BE       {return hid(H5T_IEEE_F64BE_TOKEN);}
+H5T_IEEE_F64LE       {return hid(H5T_IEEE_F64LE_TOKEN);}
+H5T_FLOAT_BFLOAT16BE {return hid(H5T_FLOAT_BFLOAT16BE_TOKEN);}
+H5T_FLOAT_BFLOAT16LE {return hid(H5T_FLOAT_BFLOAT16LE_TOKEN);}
+H5T_NATIVE_FLOAT16   {return hid(H5T_NATIVE_FLOAT16_TOKEN);}
+H5T_NATIVE_FLOAT     {return hid(H5T_NATIVE_FLOAT_TOKEN);}
+H5T_NATIVE_DOUBLE    {return hid(H5T_NATIVE_DOUBLE_TOKEN);}
+H5T_NATIVE_LDOUBLE   {return hid(H5T_NATIVE_LDOUBLE_TOKEN);}
 
 H5T_COMPLEX_IEEE_F16BE        {return hid(H5T_COMPLEX_IEEE_F16BE_TOKEN);}
 H5T_COMPLEX_IEEE_F16LE        {return hid(H5T_COMPLEX_IEEE_F16LE_TOKEN);}
diff --git a/hl/src/H5LTparse.c b/hl/src/H5LTparse.c
index df2b4d04d25..8abdf121380 100644
--- a/hl/src/H5LTparse.c
+++ b/hl/src/H5LTparse.c
@@ -217,92 +217,94 @@ enum yysymbol_kind_t
   YYSYMBOL_H5T_IEEE_F32LE_TOKEN = 33,      /* H5T_IEEE_F32LE_TOKEN  */
   YYSYMBOL_H5T_IEEE_F64BE_TOKEN = 34,      /* H5T_IEEE_F64BE_TOKEN  */
   YYSYMBOL_H5T_IEEE_F64LE_TOKEN = 35,      /* H5T_IEEE_F64LE_TOKEN  */
-  YYSYMBOL_H5T_NATIVE_FLOAT16_TOKEN = 36,  /* H5T_NATIVE_FLOAT16_TOKEN  */
-  YYSYMBOL_H5T_NATIVE_FLOAT_TOKEN = 37,    /* H5T_NATIVE_FLOAT_TOKEN  */
-  YYSYMBOL_H5T_NATIVE_DOUBLE_TOKEN = 38,   /* H5T_NATIVE_DOUBLE_TOKEN  */
-  YYSYMBOL_H5T_NATIVE_LDOUBLE_TOKEN = 39,  /* H5T_NATIVE_LDOUBLE_TOKEN  */
-  YYSYMBOL_H5T_COMPLEX_IEEE_F16BE_TOKEN = 40, /* H5T_COMPLEX_IEEE_F16BE_TOKEN  */
-  YYSYMBOL_H5T_COMPLEX_IEEE_F16LE_TOKEN = 41, /* H5T_COMPLEX_IEEE_F16LE_TOKEN  */
-  YYSYMBOL_H5T_COMPLEX_IEEE_F32BE_TOKEN = 42, /* H5T_COMPLEX_IEEE_F32BE_TOKEN  */
-  YYSYMBOL_H5T_COMPLEX_IEEE_F32LE_TOKEN = 43, /* H5T_COMPLEX_IEEE_F32LE_TOKEN  */
-  YYSYMBOL_H5T_COMPLEX_IEEE_F64BE_TOKEN = 44, /* H5T_COMPLEX_IEEE_F64BE_TOKEN  */
-  YYSYMBOL_H5T_COMPLEX_IEEE_F64LE_TOKEN = 45, /* H5T_COMPLEX_IEEE_F64LE_TOKEN  */
-  YYSYMBOL_H5T_NATIVE_FLOAT_COMPLEX_TOKEN = 46, /* H5T_NATIVE_FLOAT_COMPLEX_TOKEN  */
-  YYSYMBOL_H5T_NATIVE_DOUBLE_COMPLEX_TOKEN = 47, /* H5T_NATIVE_DOUBLE_COMPLEX_TOKEN  */
-  YYSYMBOL_H5T_NATIVE_LDOUBLE_COMPLEX_TOKEN = 48, /* H5T_NATIVE_LDOUBLE_COMPLEX_TOKEN  */
-  YYSYMBOL_H5T_STRING_TOKEN = 49,          /* H5T_STRING_TOKEN  */
-  YYSYMBOL_STRSIZE_TOKEN = 50,             /* STRSIZE_TOKEN  */
-  YYSYMBOL_STRPAD_TOKEN = 51,              /* STRPAD_TOKEN  */
-  YYSYMBOL_CSET_TOKEN = 52,                /* CSET_TOKEN  */
-  YYSYMBOL_CTYPE_TOKEN = 53,               /* CTYPE_TOKEN  */
-  YYSYMBOL_H5T_VARIABLE_TOKEN = 54,        /* H5T_VARIABLE_TOKEN  */
-  YYSYMBOL_H5T_STR_NULLTERM_TOKEN = 55,    /* H5T_STR_NULLTERM_TOKEN  */
-  YYSYMBOL_H5T_STR_NULLPAD_TOKEN = 56,     /* H5T_STR_NULLPAD_TOKEN  */
-  YYSYMBOL_H5T_STR_SPACEPAD_TOKEN = 57,    /* H5T_STR_SPACEPAD_TOKEN  */
-  YYSYMBOL_H5T_CSET_ASCII_TOKEN = 58,      /* H5T_CSET_ASCII_TOKEN  */
-  YYSYMBOL_H5T_CSET_UTF8_TOKEN = 59,       /* H5T_CSET_UTF8_TOKEN  */
-  YYSYMBOL_H5T_C_S1_TOKEN = 60,            /* H5T_C_S1_TOKEN  */
-  YYSYMBOL_H5T_FORTRAN_S1_TOKEN = 61,      /* H5T_FORTRAN_S1_TOKEN  */
-  YYSYMBOL_H5T_OPAQUE_TOKEN = 62,          /* H5T_OPAQUE_TOKEN  */
-  YYSYMBOL_OPQ_SIZE_TOKEN = 63,            /* OPQ_SIZE_TOKEN  */
-  YYSYMBOL_OPQ_TAG_TOKEN = 64,             /* OPQ_TAG_TOKEN  */
-  YYSYMBOL_H5T_COMPOUND_TOKEN = 65,        /* H5T_COMPOUND_TOKEN  */
-  YYSYMBOL_H5T_ENUM_TOKEN = 66,            /* H5T_ENUM_TOKEN  */
-  YYSYMBOL_H5T_ARRAY_TOKEN = 67,           /* H5T_ARRAY_TOKEN  */
-  YYSYMBOL_H5T_VLEN_TOKEN = 68,            /* H5T_VLEN_TOKEN  */
-  YYSYMBOL_H5T_COMPLEX_TOKEN = 69,         /* H5T_COMPLEX_TOKEN  */
-  YYSYMBOL_STRING = 70,                    /* STRING  */
-  YYSYMBOL_NUMBER = 71,                    /* NUMBER  */
-  YYSYMBOL_72_ = 72,                       /* '{'  */
-  YYSYMBOL_73_ = 73,                       /* '}'  */
-  YYSYMBOL_74_ = 74,                       /* '['  */
-  YYSYMBOL_75_ = 75,                       /* ']'  */
-  YYSYMBOL_76_ = 76,                       /* ':'  */
-  YYSYMBOL_77_ = 77,                       /* ';'  */
-  YYSYMBOL_YYACCEPT = 78,                  /* $accept  */
-  YYSYMBOL_start = 79,                     /* start  */
-  YYSYMBOL_ddl_type = 80,                  /* ddl_type  */
-  YYSYMBOL_atomic_type = 81,               /* atomic_type  */
-  YYSYMBOL_integer_type = 82,              /* integer_type  */
-  YYSYMBOL_fp_type = 83,                   /* fp_type  */
-  YYSYMBOL_compound_type = 84,             /* compound_type  */
-  YYSYMBOL_85_1 = 85,                      /* $@1  */
-  YYSYMBOL_memb_list = 86,                 /* memb_list  */
-  YYSYMBOL_memb_def = 87,                  /* memb_def  */
-  YYSYMBOL_88_2 = 88,                      /* $@2  */
-  YYSYMBOL_field_name = 89,                /* field_name  */
-  YYSYMBOL_field_offset = 90,              /* field_offset  */
-  YYSYMBOL_offset = 91,                    /* offset  */
-  YYSYMBOL_array_type = 92,                /* array_type  */
-  YYSYMBOL_93_3 = 93,                      /* $@3  */
-  YYSYMBOL_dim_list = 94,                  /* dim_list  */
-  YYSYMBOL_dim = 95,                       /* dim  */
-  YYSYMBOL_96_4 = 96,                      /* $@4  */
-  YYSYMBOL_97_5 = 97,                      /* $@5  */
-  YYSYMBOL_dimsize = 98,                   /* dimsize  */
-  YYSYMBOL_vlen_type = 99,                 /* vlen_type  */
-  YYSYMBOL_complex_type = 100,             /* complex_type  */
-  YYSYMBOL_opaque_type = 101,              /* opaque_type  */
-  YYSYMBOL_102_6 = 102,                    /* @6  */
-  YYSYMBOL_103_7 = 103,                    /* $@7  */
-  YYSYMBOL_opaque_size = 104,              /* opaque_size  */
-  YYSYMBOL_opaque_tag = 105,               /* opaque_tag  */
-  YYSYMBOL_string_type = 106,              /* string_type  */
-  YYSYMBOL_107_8 = 107,                    /* $@8  */
-  YYSYMBOL_108_9 = 108,                    /* $@9  */
-  YYSYMBOL_109_10 = 109,                   /* $@10  */
-  YYSYMBOL_110_11 = 110,                   /* @11  */
-  YYSYMBOL_strsize = 111,                  /* strsize  */
-  YYSYMBOL_strpad = 112,                   /* strpad  */
-  YYSYMBOL_cset = 113,                     /* cset  */
-  YYSYMBOL_ctype = 114,                    /* ctype  */
-  YYSYMBOL_enum_type = 115,                /* enum_type  */
-  YYSYMBOL_116_12 = 116,                   /* $@12  */
-  YYSYMBOL_enum_list = 117,                /* enum_list  */
-  YYSYMBOL_enum_def = 118,                 /* enum_def  */
-  YYSYMBOL_119_13 = 119,                   /* $@13  */
-  YYSYMBOL_enum_symbol = 120,              /* enum_symbol  */
-  YYSYMBOL_enum_val = 121                  /* enum_val  */
+  YYSYMBOL_H5T_FLOAT_BFLOAT16BE_TOKEN = 36, /* H5T_FLOAT_BFLOAT16BE_TOKEN  */
+  YYSYMBOL_H5T_FLOAT_BFLOAT16LE_TOKEN = 37, /* H5T_FLOAT_BFLOAT16LE_TOKEN  */
+  YYSYMBOL_H5T_NATIVE_FLOAT16_TOKEN = 38,  /* H5T_NATIVE_FLOAT16_TOKEN  */
+  YYSYMBOL_H5T_NATIVE_FLOAT_TOKEN = 39,    /* H5T_NATIVE_FLOAT_TOKEN  */
+  YYSYMBOL_H5T_NATIVE_DOUBLE_TOKEN = 40,   /* H5T_NATIVE_DOUBLE_TOKEN  */
+  YYSYMBOL_H5T_NATIVE_LDOUBLE_TOKEN = 41,  /* H5T_NATIVE_LDOUBLE_TOKEN  */
+  YYSYMBOL_H5T_COMPLEX_IEEE_F16BE_TOKEN = 42, /* H5T_COMPLEX_IEEE_F16BE_TOKEN  */
+  YYSYMBOL_H5T_COMPLEX_IEEE_F16LE_TOKEN = 43, /* H5T_COMPLEX_IEEE_F16LE_TOKEN  */
+  YYSYMBOL_H5T_COMPLEX_IEEE_F32BE_TOKEN = 44, /* H5T_COMPLEX_IEEE_F32BE_TOKEN  */
+  YYSYMBOL_H5T_COMPLEX_IEEE_F32LE_TOKEN = 45, /* H5T_COMPLEX_IEEE_F32LE_TOKEN  */
+  YYSYMBOL_H5T_COMPLEX_IEEE_F64BE_TOKEN = 46, /* H5T_COMPLEX_IEEE_F64BE_TOKEN  */
+  YYSYMBOL_H5T_COMPLEX_IEEE_F64LE_TOKEN = 47, /* H5T_COMPLEX_IEEE_F64LE_TOKEN  */
+  YYSYMBOL_H5T_NATIVE_FLOAT_COMPLEX_TOKEN = 48, /* H5T_NATIVE_FLOAT_COMPLEX_TOKEN  */
+  YYSYMBOL_H5T_NATIVE_DOUBLE_COMPLEX_TOKEN = 49, /* H5T_NATIVE_DOUBLE_COMPLEX_TOKEN  */
+  YYSYMBOL_H5T_NATIVE_LDOUBLE_COMPLEX_TOKEN = 50, /* H5T_NATIVE_LDOUBLE_COMPLEX_TOKEN  */
+  YYSYMBOL_H5T_STRING_TOKEN = 51,          /* H5T_STRING_TOKEN  */
+  YYSYMBOL_STRSIZE_TOKEN = 52,             /* STRSIZE_TOKEN  */
+  YYSYMBOL_STRPAD_TOKEN = 53,              /* STRPAD_TOKEN  */
+  YYSYMBOL_CSET_TOKEN = 54,                /* CSET_TOKEN  */
+  YYSYMBOL_CTYPE_TOKEN = 55,               /* CTYPE_TOKEN  */
+  YYSYMBOL_H5T_VARIABLE_TOKEN = 56,        /* H5T_VARIABLE_TOKEN  */
+  YYSYMBOL_H5T_STR_NULLTERM_TOKEN = 57,    /* H5T_STR_NULLTERM_TOKEN  */
+  YYSYMBOL_H5T_STR_NULLPAD_TOKEN = 58,     /* H5T_STR_NULLPAD_TOKEN  */
+  YYSYMBOL_H5T_STR_SPACEPAD_TOKEN = 59,    /* H5T_STR_SPACEPAD_TOKEN  */
+  YYSYMBOL_H5T_CSET_ASCII_TOKEN = 60,      /* H5T_CSET_ASCII_TOKEN  */
+  YYSYMBOL_H5T_CSET_UTF8_TOKEN = 61,       /* H5T_CSET_UTF8_TOKEN  */
+  YYSYMBOL_H5T_C_S1_TOKEN = 62,            /* H5T_C_S1_TOKEN  */
+  YYSYMBOL_H5T_FORTRAN_S1_TOKEN = 63,      /* H5T_FORTRAN_S1_TOKEN  */
+  YYSYMBOL_H5T_OPAQUE_TOKEN = 64,          /* H5T_OPAQUE_TOKEN  */
+  YYSYMBOL_OPQ_SIZE_TOKEN = 65,            /* OPQ_SIZE_TOKEN  */
+  YYSYMBOL_OPQ_TAG_TOKEN = 66,             /* OPQ_TAG_TOKEN  */
+  YYSYMBOL_H5T_COMPOUND_TOKEN = 67,        /* H5T_COMPOUND_TOKEN  */
+  YYSYMBOL_H5T_ENUM_TOKEN = 68,            /* H5T_ENUM_TOKEN  */
+  YYSYMBOL_H5T_ARRAY_TOKEN = 69,           /* H5T_ARRAY_TOKEN  */
+  YYSYMBOL_H5T_VLEN_TOKEN = 70,            /* H5T_VLEN_TOKEN  */
+  YYSYMBOL_H5T_COMPLEX_TOKEN = 71,         /* H5T_COMPLEX_TOKEN  */
+  YYSYMBOL_STRING = 72,                    /* STRING  */
+  YYSYMBOL_NUMBER = 73,                    /* NUMBER  */
+  YYSYMBOL_74_ = 74,                       /* '{'  */
+  YYSYMBOL_75_ = 75,                       /* '}'  */
+  YYSYMBOL_76_ = 76,                       /* '['  */
+  YYSYMBOL_77_ = 77,                       /* ']'  */
+  YYSYMBOL_78_ = 78,                       /* ':'  */
+  YYSYMBOL_79_ = 79,                       /* ';'  */
+  YYSYMBOL_YYACCEPT = 80,                  /* $accept  */
+  YYSYMBOL_start = 81,                     /* start  */
+  YYSYMBOL_ddl_type = 82,                  /* ddl_type  */
+  YYSYMBOL_atomic_type = 83,               /* atomic_type  */
+  YYSYMBOL_integer_type = 84,              /* integer_type  */
+  YYSYMBOL_fp_type = 85,                   /* fp_type  */
+  YYSYMBOL_compound_type = 86,             /* compound_type  */
+  YYSYMBOL_87_1 = 87,                      /* $@1  */
+  YYSYMBOL_memb_list = 88,                 /* memb_list  */
+  YYSYMBOL_memb_def = 89,                  /* memb_def  */
+  YYSYMBOL_90_2 = 90,                      /* $@2  */
+  YYSYMBOL_field_name = 91,                /* field_name  */
+  YYSYMBOL_field_offset = 92,              /* field_offset  */
+  YYSYMBOL_offset = 93,                    /* offset  */
+  YYSYMBOL_array_type = 94,                /* array_type  */
+  YYSYMBOL_95_3 = 95,                      /* $@3  */
+  YYSYMBOL_dim_list = 96,                  /* dim_list  */
+  YYSYMBOL_dim = 97,                       /* dim  */
+  YYSYMBOL_98_4 = 98,                      /* $@4  */
+  YYSYMBOL_99_5 = 99,                      /* $@5  */
+  YYSYMBOL_dimsize = 100,                  /* dimsize  */
+  YYSYMBOL_vlen_type = 101,                /* vlen_type  */
+  YYSYMBOL_complex_type = 102,             /* complex_type  */
+  YYSYMBOL_opaque_type = 103,              /* opaque_type  */
+  YYSYMBOL_104_6 = 104,                    /* @6  */
+  YYSYMBOL_105_7 = 105,                    /* $@7  */
+  YYSYMBOL_opaque_size = 106,              /* opaque_size  */
+  YYSYMBOL_opaque_tag = 107,               /* opaque_tag  */
+  YYSYMBOL_string_type = 108,              /* string_type  */
+  YYSYMBOL_109_8 = 109,                    /* $@8  */
+  YYSYMBOL_110_9 = 110,                    /* $@9  */
+  YYSYMBOL_111_10 = 111,                   /* $@10  */
+  YYSYMBOL_112_11 = 112,                   /* @11  */
+  YYSYMBOL_strsize = 113,                  /* strsize  */
+  YYSYMBOL_strpad = 114,                   /* strpad  */
+  YYSYMBOL_cset = 115,                     /* cset  */
+  YYSYMBOL_ctype = 116,                    /* ctype  */
+  YYSYMBOL_enum_type = 117,                /* enum_type  */
+  YYSYMBOL_118_12 = 118,                   /* $@12  */
+  YYSYMBOL_enum_list = 119,                /* enum_list  */
+  YYSYMBOL_enum_def = 120,                 /* enum_def  */
+  YYSYMBOL_121_13 = 121,                   /* $@13  */
+  YYSYMBOL_enum_symbol = 122,              /* enum_symbol  */
+  YYSYMBOL_enum_val = 123                  /* enum_val  */
 };
 typedef enum yysymbol_kind_t yysymbol_kind_t;
 
@@ -628,21 +630,21 @@ union yyalloc
 #endif /* !YYCOPY_NEEDED */
 
 /* YYFINAL -- State number of the termination state.  */
-#define YYFINAL  73
+#define YYFINAL  75
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   239
+#define YYLAST   245
 
 /* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS  78
+#define YYNTOKENS  80
 /* YYNNTS -- Number of nonterminals.  */
 #define YYNNTS  44
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  106
+#define YYNRULES  108
 /* YYNSTATES -- Number of states.  */
-#define YYNSTATES  151
+#define YYNSTATES  153
 
 /* YYMAXUTOK -- Last valid token kind.  */
-#define YYMAXUTOK   326
+#define YYMAXUTOK   328
 
 
 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
@@ -661,14 +663,14 @@ static const yytype_int8 yytranslate[] =
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,    76,    77,
+       2,     2,     2,     2,     2,     2,     2,     2,    78,    79,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,    74,     2,    75,     2,     2,     2,     2,     2,     2,
+       2,    76,     2,    77,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,    72,     2,    73,     2,     2,     2,     2,
+       2,     2,     2,    74,     2,    75,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
@@ -688,24 +690,24 @@ static const yytype_int8 yytranslate[] =
       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
-      65,    66,    67,    68,    69,    70,    71
+      65,    66,    67,    68,    69,    70,    71,    72,    73
 };
 
 #if YYDEBUG
 /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
 static const yytype_int16 yyrline[] =
 {
-       0,   108,   108,   109,   111,   112,   113,   114,   115,   117,
-     118,   119,   120,   121,   124,   125,   126,   127,   128,   129,
-     130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
-     140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
-     150,   153,   154,   155,   156,   157,   158,   159,   160,   161,
-     162,   166,   165,   174,   175,   177,   177,   214,   222,   223,
-     226,   228,   228,   237,   238,   240,   241,   240,   248,   251,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     271,   276,   268,   283,   285,   290,   297,   306,   313,   287,
-     337,   338,   340,   341,   342,   344,   345,   347,   348,   352,
-     351,   356,   357,   359,   359,   409,   411
+       0,   109,   109,   110,   112,   113,   114,   115,   116,   118,
+     119,   120,   121,   122,   125,   126,   127,   128,   129,   130,
+     131,   132,   133,   134,   135,   136,   137,   138,   139,   140,
+     141,   142,   143,   144,   145,   146,   147,   148,   149,   150,
+     151,   154,   155,   156,   157,   158,   159,   160,   161,   162,
+     163,   164,   165,   169,   168,   177,   178,   180,   180,   217,
+     225,   226,   229,   231,   231,   240,   241,   243,   244,   243,
+     251,   254,   258,   259,   260,   261,   262,   263,   264,   265,
+     266,   267,   274,   279,   271,   286,   288,   293,   300,   309,
+     316,   290,   340,   341,   343,   344,   345,   347,   348,   350,
+     351,   355,   354,   359,   360,   362,   362,   412,   414
 };
 #endif
 
@@ -735,6 +737,7 @@ static const char *const yytname[] =
   "H5T_NATIVE_ULLONG_TOKEN", "H5T_IEEE_F16BE_TOKEN",
   "H5T_IEEE_F16LE_TOKEN", "H5T_IEEE_F32BE_TOKEN", "H5T_IEEE_F32LE_TOKEN",
   "H5T_IEEE_F64BE_TOKEN", "H5T_IEEE_F64LE_TOKEN",
+  "H5T_FLOAT_BFLOAT16BE_TOKEN", "H5T_FLOAT_BFLOAT16LE_TOKEN",
   "H5T_NATIVE_FLOAT16_TOKEN", "H5T_NATIVE_FLOAT_TOKEN",
   "H5T_NATIVE_DOUBLE_TOKEN", "H5T_NATIVE_LDOUBLE_TOKEN",
   "H5T_COMPLEX_IEEE_F16BE_TOKEN", "H5T_COMPLEX_IEEE_F16LE_TOKEN",
@@ -780,22 +783,22 @@ yysymbol_name (yysymbol_kind_t yysymbol)
    STATE-NUM.  */
 static const yytype_int16 yypact[] =
 {
-     140,   -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,
+     144,   -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,
      -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,
      -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,
      -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,
-     -24,   -24,   -24,   -24,   -24,   -24,   -24,   -21,   -15,   -24,
-     -14,   -24,    -4,    -2,   119,   -24,   -24,   -24,   -24,   -24,
-     -24,   -24,   -24,   -24,   -24,   -24,    70,    58,    51,   207,
-      52,   140,   140,   -24,    68,    54,   -24,    49,   -24,    55,
-      56,   -24,   -24,    50,   -24,    53,    69,   -24,    -3,   -24,
-     -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,    59,   -24,
-      82,    76,    71,   -23,   120,   -24,    -1,   122,   -24,   114,
-     -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,   116,
-     -24,   117,   124,   121,   125,   126,   -24,   -24,   -24,   -24,
-     -24,   -24,   123,   -24,   145,   130,   -24,   -10,   -24,   -24,
-     -24,   127,   -24,   146,     0,   -24,   -24,   160,   -24,   165,
-     -24
+     -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,   -21,
+     -15,   -24,   -14,   -24,    -4,    -2,   123,   -24,   -24,   -24,
+     -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,    72,    60,
+      53,   213,    54,   144,   144,   -24,    70,    56,   -24,    51,
+     -24,    57,    58,   -24,   -24,    52,   -24,    55,    71,   -24,
+      -3,   -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,
+      61,   -24,    84,    78,    73,   -23,   124,   -24,    -1,   126,
+     -24,   118,   -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,
+     -24,   120,   -24,   121,   128,   125,   129,   130,   -24,   -24,
+     -24,   -24,   -24,   -24,   127,   -24,   149,   134,   -24,   -10,
+     -24,   -24,   -24,   131,   -24,   150,     0,   -24,   -24,   164,
+     -24,   169,   -24
 };
 
 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
@@ -806,25 +809,25 @@ static const yytype_int8 yydefact[] =
        2,    14,    15,    16,    17,    18,    19,    20,    21,    22,
       23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
       33,    34,    35,    36,    37,    38,    39,    40,    41,    42,
-      43,    44,    45,    46,    47,    48,    49,    50,    74,    73,
-      76,    75,    78,    77,    70,    71,    72,     0,     0,    51,
-       0,    61,     0,     0,     0,     3,     4,     9,    10,     5,
-       6,     7,     8,    13,    11,    12,     0,     0,     0,     0,
-       0,     0,     0,     1,     0,     0,    53,     0,    63,     0,
-       0,    90,    91,     0,    83,     0,     0,    99,     0,    69,
-      79,    85,    80,    52,    55,    54,   101,    65,     0,    64,
-       0,     0,     0,     0,     0,    62,     0,     0,    57,    58,
-     105,   100,   102,   103,    68,    66,    92,    93,    94,     0,
-      84,     0,     0,     0,     0,     0,    86,    81,    60,    59,
-      56,   106,     0,    67,     0,     0,   104,     0,    82,    95,
-      96,     0,    87,     0,     0,    97,    98,     0,    88,     0,
-      89
+      43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
+      76,    75,    78,    77,    80,    79,    72,    73,    74,     0,
+       0,    53,     0,    63,     0,     0,     0,     3,     4,     9,
+      10,     5,     6,     7,     8,    13,    11,    12,     0,     0,
+       0,     0,     0,     0,     0,     1,     0,     0,    55,     0,
+      65,     0,     0,    92,    93,     0,    85,     0,     0,   101,
+       0,    71,    81,    87,    82,    54,    57,    56,   103,    67,
+       0,    66,     0,     0,     0,     0,     0,    64,     0,     0,
+      59,    60,   107,   102,   104,   105,    70,    68,    94,    95,
+      96,     0,    86,     0,     0,     0,     0,     0,    88,    83,
+      62,    61,    58,   108,     0,    69,     0,     0,   106,     0,
+      84,    97,    98,     0,    89,     0,     0,    99,   100,     0,
+      90,     0,    91
 };
 
 /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int16 yypgoto[] =
 {
-     -24,   -24,   -19,   -24,   170,   -24,   -24,   -24,   -24,   -24,
+     -24,   -24,   -19,   -24,   174,   -24,   -24,   -24,   -24,   -24,
      -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,
      -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,
      -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,
@@ -834,11 +837,11 @@ static const yytype_int16 yypgoto[] =
 /* YYDEFGOTO[NTERM-NUM].  */
 static const yytype_uint8 yydefgoto[] =
 {
-       0,    54,    55,    56,    57,    58,    59,    68,    86,    95,
-     102,   109,   123,   129,    60,    70,    88,    99,   104,   125,
-     115,    61,    62,    63,   101,   135,    85,   121,    64,   100,
-     134,   143,   149,    83,   119,   141,   147,    65,    96,   103,
-     112,   124,   113,   132
+       0,    56,    57,    58,    59,    60,    61,    70,    88,    97,
+     104,   111,   125,   131,    62,    72,    90,   101,   106,   127,
+     117,    63,    64,    65,   103,   137,    87,   123,    66,   102,
+     136,   145,   151,    85,   121,   143,   149,    67,    98,   105,
+     114,   126,   115,   134
 };
 
 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
@@ -850,26 +853,27 @@ static const yytype_uint8 yytable[] =
       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
       21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
-      41,    42,    43,    44,    45,    46,    47,   110,   139,   140,
-     111,    66,    79,    80,   116,   117,   118,    67,    69,    48,
-     145,   146,    49,    50,    51,    52,    53,    94,    71,    98,
-      72,    97,     1,     2,     3,     4,     5,     6,     7,     8,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
-      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
-      39,    40,    41,    42,    43,    44,    45,    46,    47,    73,
-      74,    75,    81,    76,    78,    84,    87,    91,    89,    90,
-      92,    48,   105,   106,    49,    50,    51,    52,    53,    82,
-     107,   108,    93,     1,     2,     3,     4,     5,     6,     7,
-       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
-      28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
-      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
-     122,   114,   120,   126,   127,   128,   131,   137,   130,   144,
-     136,   133,    48,   138,   142,    49,    50,    51,    52,    53,
-       1,     2,     3,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    27,   148,   150,    77
+      41,    42,    43,    44,    45,    46,    47,    48,    49,   112,
+     141,   142,   113,    68,    81,    82,   118,   119,   120,    69,
+      71,    50,   147,   148,    51,    52,    53,    54,    55,    96,
+      73,   100,    74,    99,     1,     2,     3,     4,     5,     6,
+       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+      27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
+      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
+      47,    48,    49,    75,    76,    77,    83,    78,    80,    86,
+      89,    93,    91,    92,    94,    50,   107,   108,    51,    52,
+      53,    54,    55,    84,   109,   110,    95,     1,     2,     3,
+       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
+      34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
+      44,    45,    46,    47,    48,    49,   124,   116,   122,   128,
+     129,   130,   133,   139,   132,   146,   138,   135,    50,   140,
+     144,    51,    52,    53,    54,    55,     1,     2,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    26,    27,   150,   152,    79
 };
 
 static const yytype_int8 yycheck[] =
@@ -878,26 +882,27 @@ static const yytype_int8 yycheck[] =
       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
       23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
       33,    34,    35,    36,    37,    38,    39,    40,    41,    42,
-      43,    44,    45,    46,    47,    48,    49,    70,    58,    59,
-      73,    72,    71,    72,    55,    56,    57,    72,    72,    62,
-      60,    61,    65,    66,    67,    68,    69,    86,    72,    88,
-      72,    74,     3,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
-      31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
-      41,    42,    43,    44,    45,    46,    47,    48,    49,     0,
-      50,    63,    54,    72,    72,    71,    77,    77,    73,    73,
-      77,    62,    73,    51,    65,    66,    67,    68,    69,    71,
-      64,    70,    73,     3,     4,     5,     6,     7,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
-      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
-      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
-      76,    71,    70,    77,    77,    71,    71,    52,    77,    53,
-      77,    75,    62,    73,    77,    65,    66,    67,    68,    69,
-       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,    25,    26,    27,    28,    29,    77,    73,    69
+      43,    44,    45,    46,    47,    48,    49,    50,    51,    72,
+      60,    61,    75,    74,    73,    74,    57,    58,    59,    74,
+      74,    64,    62,    63,    67,    68,    69,    70,    71,    88,
+      74,    90,    74,    76,     3,     4,     5,     6,     7,     8,
+       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
+      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
+      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
+      49,    50,    51,     0,    52,    65,    56,    74,    74,    73,
+      79,    79,    75,    75,    79,    64,    75,    53,    67,    68,
+      69,    70,    71,    73,    66,    72,    75,     3,     4,     5,
+       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+      26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
+      36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
+      46,    47,    48,    49,    50,    51,    78,    73,    72,    79,
+      79,    73,    73,    54,    79,    55,    79,    77,    64,    75,
+      79,    67,    68,    69,    70,    71,     3,     4,     5,     6,
+       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+      27,    28,    29,    79,    75,    71
 };
 
 /* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of
@@ -908,34 +913,34 @@ static const yytype_int8 yystos[] =
       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
       22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
       32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
-      42,    43,    44,    45,    46,    47,    48,    49,    62,    65,
-      66,    67,    68,    69,    79,    80,    81,    82,    83,    84,
-      92,    99,   100,   101,   106,   115,    72,    72,    85,    72,
-      93,    72,    72,     0,    50,    63,    72,    82,    72,    80,
-      80,    54,    71,   111,    71,   104,    86,    77,    94,    73,
-      73,    77,    77,    73,    80,    87,   116,    74,    80,    95,
-     107,   102,    88,   117,    96,    73,    51,    64,    70,    89,
-      70,    73,   118,   120,    71,    98,    55,    56,    57,   112,
-      70,   105,    76,    90,   119,    97,    77,    77,    71,    91,
-      77,    71,   121,    75,   108,   103,    77,    52,    73,    58,
-      59,   113,    77,   109,    53,    60,    61,   114,    77,   110,
-      73
+      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
+      64,    67,    68,    69,    70,    71,    81,    82,    83,    84,
+      85,    86,    94,   101,   102,   103,   108,   117,    74,    74,
+      87,    74,    95,    74,    74,     0,    52,    65,    74,    84,
+      74,    82,    82,    56,    73,   113,    73,   106,    88,    79,
+      96,    75,    75,    79,    79,    75,    82,    89,   118,    76,
+      82,    97,   109,   104,    90,   119,    98,    75,    53,    66,
+      72,    91,    72,    75,   120,   122,    73,   100,    57,    58,
+      59,   114,    72,   107,    78,    92,   121,    99,    79,    79,
+      73,    93,    79,    73,   123,    77,   110,   105,    79,    54,
+      75,    60,    61,   115,    79,   111,    55,    62,    63,   116,
+      79,   112,    75
 };
 
 /* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM.  */
 static const yytype_int8 yyr1[] =
 {
-       0,    78,    79,    79,    80,    80,    80,    80,    80,    81,
-      81,    81,    81,    81,    82,    82,    82,    82,    82,    82,
-      82,    82,    82,    82,    82,    82,    82,    82,    82,    82,
-      82,    82,    82,    82,    82,    82,    82,    82,    82,    82,
-      82,    83,    83,    83,    83,    83,    83,    83,    83,    83,
-      83,    85,    84,    86,    86,    88,    87,    89,    90,    90,
-      91,    93,    92,    94,    94,    96,    97,    95,    98,    99,
-     100,   100,   100,   100,   100,   100,   100,   100,   100,   100,
-     102,   103,   101,   104,   105,   107,   108,   109,   110,   106,
-     111,   111,   112,   112,   112,   113,   113,   114,   114,   116,
-     115,   117,   117,   119,   118,   120,   121
+       0,    80,    81,    81,    82,    82,    82,    82,    82,    83,
+      83,    83,    83,    83,    84,    84,    84,    84,    84,    84,
+      84,    84,    84,    84,    84,    84,    84,    84,    84,    84,
+      84,    84,    84,    84,    84,    84,    84,    84,    84,    84,
+      84,    85,    85,    85,    85,    85,    85,    85,    85,    85,
+      85,    85,    85,    87,    86,    88,    88,    90,    89,    91,
+      92,    92,    93,    95,    94,    96,    96,    98,    99,    97,
+     100,   101,   102,   102,   102,   102,   102,   102,   102,   102,
+     102,   102,   104,   105,   103,   106,   107,   109,   110,   111,
+     112,   108,   113,   113,   114,   114,   114,   115,   115,   116,
+     116,   118,   117,   119,   119,   121,   120,   122,   123
 };
 
 /* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM.  */
@@ -946,12 +951,12 @@ static const yytype_int8 yyr2[] =
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     0,     5,     0,     2,     0,     5,     1,     0,     2,
-       1,     0,     6,     0,     2,     0,     0,     5,     1,     4,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     4,
-       0,     0,    11,     1,     1,     0,     0,     0,     0,    19,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     0,
-       7,     0,     2,     0,     4,     1,     1
+       1,     1,     1,     0,     5,     0,     2,     0,     5,     1,
+       0,     2,     1,     0,     6,     0,     2,     0,     0,     5,
+       1,     4,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     4,     0,     0,    11,     1,     1,     0,     0,     0,
+       0,    19,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     0,     7,     0,     2,     0,     4,     1,     1
 };
 
 
@@ -1415,263 +1420,275 @@ yyreduce:
   switch (yyn)
     {
   case 2: /* start: %empty  */
-#line 108 "hl/src//H5LTparse.y"
+#line 109 "hl/src//H5LTparse.y"
                 { memset(arr_stack, 0, STACK_SIZE*sizeof(struct arr_info)); /*initialize here?*/ }
-#line 1392 "hl/src//H5LTparse.c"
+#line 1397 "hl/src//H5LTparse.c"
     break;
 
   case 3: /* start: ddl_type  */
-#line 109 "hl/src//H5LTparse.y"
+#line 110 "hl/src//H5LTparse.y"
                           { return (yyval.hid);}
-#line 1398 "hl/src//H5LTparse.c"
+#line 1403 "hl/src//H5LTparse.c"
     break;
 
   case 14: /* integer_type: H5T_STD_I8BE_TOKEN  */
-#line 124 "hl/src//H5LTparse.y"
+#line 125 "hl/src//H5LTparse.y"
                                             { (yyval.hid) = H5Tcopy(H5T_STD_I8BE); }
-#line 1404 "hl/src//H5LTparse.c"
+#line 1409 "hl/src//H5LTparse.c"
     break;
 
   case 15: /* integer_type: H5T_STD_I8LE_TOKEN  */
-#line 125 "hl/src//H5LTparse.y"
+#line 126 "hl/src//H5LTparse.y"
                                             { (yyval.hid) = H5Tcopy(H5T_STD_I8LE); }
-#line 1410 "hl/src//H5LTparse.c"
+#line 1415 "hl/src//H5LTparse.c"
     break;
 
   case 16: /* integer_type: H5T_STD_I16BE_TOKEN  */
-#line 126 "hl/src//H5LTparse.y"
+#line 127 "hl/src//H5LTparse.y"
                                             { (yyval.hid) = H5Tcopy(H5T_STD_I16BE); }
-#line 1416 "hl/src//H5LTparse.c"
+#line 1421 "hl/src//H5LTparse.c"
     break;
 
   case 17: /* integer_type: H5T_STD_I16LE_TOKEN  */
-#line 127 "hl/src//H5LTparse.y"
+#line 128 "hl/src//H5LTparse.y"
                                             { (yyval.hid) = H5Tcopy(H5T_STD_I16LE); }
-#line 1422 "hl/src//H5LTparse.c"
+#line 1427 "hl/src//H5LTparse.c"
     break;
 
   case 18: /* integer_type: H5T_STD_I32BE_TOKEN  */
-#line 128 "hl/src//H5LTparse.y"
+#line 129 "hl/src//H5LTparse.y"
                                             { (yyval.hid) = H5Tcopy(H5T_STD_I32BE); }
-#line 1428 "hl/src//H5LTparse.c"
+#line 1433 "hl/src//H5LTparse.c"
     break;
 
   case 19: /* integer_type: H5T_STD_I32LE_TOKEN  */
-#line 129 "hl/src//H5LTparse.y"
+#line 130 "hl/src//H5LTparse.y"
                                             { (yyval.hid) = H5Tcopy(H5T_STD_I32LE); }
-#line 1434 "hl/src//H5LTparse.c"
+#line 1439 "hl/src//H5LTparse.c"
     break;
 
   case 20: /* integer_type: H5T_STD_I64BE_TOKEN  */
-#line 130 "hl/src//H5LTparse.y"
+#line 131 "hl/src//H5LTparse.y"
                                             { (yyval.hid) = H5Tcopy(H5T_STD_I64BE); }
-#line 1440 "hl/src//H5LTparse.c"
+#line 1445 "hl/src//H5LTparse.c"
     break;
 
   case 21: /* integer_type: H5T_STD_I64LE_TOKEN  */
-#line 131 "hl/src//H5LTparse.y"
+#line 132 "hl/src//H5LTparse.y"
                                             { (yyval.hid) = H5Tcopy(H5T_STD_I64LE); }
-#line 1446 "hl/src//H5LTparse.c"
+#line 1451 "hl/src//H5LTparse.c"
     break;
 
   case 22: /* integer_type: H5T_STD_U8BE_TOKEN  */
-#line 132 "hl/src//H5LTparse.y"
+#line 133 "hl/src//H5LTparse.y"
                                             { (yyval.hid) = H5Tcopy(H5T_STD_U8BE); }
-#line 1452 "hl/src//H5LTparse.c"
+#line 1457 "hl/src//H5LTparse.c"
     break;
 
   case 23: /* integer_type: H5T_STD_U8LE_TOKEN  */
-#line 133 "hl/src//H5LTparse.y"
+#line 134 "hl/src//H5LTparse.y"
                                             { (yyval.hid) = H5Tcopy(H5T_STD_U8LE); }
-#line 1458 "hl/src//H5LTparse.c"
+#line 1463 "hl/src//H5LTparse.c"
     break;
 
   case 24: /* integer_type: H5T_STD_U16BE_TOKEN  */
-#line 134 "hl/src//H5LTparse.y"
+#line 135 "hl/src//H5LTparse.y"
                                             { (yyval.hid) = H5Tcopy(H5T_STD_U16BE); }
-#line 1464 "hl/src//H5LTparse.c"
+#line 1469 "hl/src//H5LTparse.c"
     break;
 
   case 25: /* integer_type: H5T_STD_U16LE_TOKEN  */
-#line 135 "hl/src//H5LTparse.y"
+#line 136 "hl/src//H5LTparse.y"
                                             { (yyval.hid) = H5Tcopy(H5T_STD_U16LE); }
-#line 1470 "hl/src//H5LTparse.c"
+#line 1475 "hl/src//H5LTparse.c"
     break;
 
   case 26: /* integer_type: H5T_STD_U32BE_TOKEN  */
-#line 136 "hl/src//H5LTparse.y"
+#line 137 "hl/src//H5LTparse.y"
                                             { (yyval.hid) = H5Tcopy(H5T_STD_U32BE); }
-#line 1476 "hl/src//H5LTparse.c"
+#line 1481 "hl/src//H5LTparse.c"
     break;
 
   case 27: /* integer_type: H5T_STD_U32LE_TOKEN  */
-#line 137 "hl/src//H5LTparse.y"
+#line 138 "hl/src//H5LTparse.y"
                                             { (yyval.hid) = H5Tcopy(H5T_STD_U32LE); }
-#line 1482 "hl/src//H5LTparse.c"
+#line 1487 "hl/src//H5LTparse.c"
     break;
 
   case 28: /* integer_type: H5T_STD_U64BE_TOKEN  */
-#line 138 "hl/src//H5LTparse.y"
+#line 139 "hl/src//H5LTparse.y"
                                             { (yyval.hid) = H5Tcopy(H5T_STD_U64BE); }
-#line 1488 "hl/src//H5LTparse.c"
+#line 1493 "hl/src//H5LTparse.c"
     break;
 
   case 29: /* integer_type: H5T_STD_U64LE_TOKEN  */
-#line 139 "hl/src//H5LTparse.y"
+#line 140 "hl/src//H5LTparse.y"
                                             { (yyval.hid) = H5Tcopy(H5T_STD_U64LE); }
-#line 1494 "hl/src//H5LTparse.c"
+#line 1499 "hl/src//H5LTparse.c"
     break;
 
   case 30: /* integer_type: H5T_NATIVE_CHAR_TOKEN  */
-#line 140 "hl/src//H5LTparse.y"
+#line 141 "hl/src//H5LTparse.y"
                                                 { (yyval.hid) = H5Tcopy(H5T_NATIVE_CHAR); }
-#line 1500 "hl/src//H5LTparse.c"
+#line 1505 "hl/src//H5LTparse.c"
     break;
 
   case 31: /* integer_type: H5T_NATIVE_SCHAR_TOKEN  */
-#line 141 "hl/src//H5LTparse.y"
+#line 142 "hl/src//H5LTparse.y"
                                                 { (yyval.hid) = H5Tcopy(H5T_NATIVE_SCHAR); }
-#line 1506 "hl/src//H5LTparse.c"
+#line 1511 "hl/src//H5LTparse.c"
     break;
 
   case 32: /* integer_type: H5T_NATIVE_UCHAR_TOKEN  */
-#line 142 "hl/src//H5LTparse.y"
+#line 143 "hl/src//H5LTparse.y"
                                                 { (yyval.hid) = H5Tcopy(H5T_NATIVE_UCHAR); }
-#line 1512 "hl/src//H5LTparse.c"
+#line 1517 "hl/src//H5LTparse.c"
     break;
 
   case 33: /* integer_type: H5T_NATIVE_SHORT_TOKEN  */
-#line 143 "hl/src//H5LTparse.y"
+#line 144 "hl/src//H5LTparse.y"
                                                 { (yyval.hid) = H5Tcopy(H5T_NATIVE_SHORT); }
-#line 1518 "hl/src//H5LTparse.c"
+#line 1523 "hl/src//H5LTparse.c"
     break;
 
   case 34: /* integer_type: H5T_NATIVE_USHORT_TOKEN  */
-#line 144 "hl/src//H5LTparse.y"
+#line 145 "hl/src//H5LTparse.y"
                                                 { (yyval.hid) = H5Tcopy(H5T_NATIVE_USHORT); }
-#line 1524 "hl/src//H5LTparse.c"
+#line 1529 "hl/src//H5LTparse.c"
     break;
 
   case 35: /* integer_type: H5T_NATIVE_INT_TOKEN  */
-#line 145 "hl/src//H5LTparse.y"
+#line 146 "hl/src//H5LTparse.y"
                                                 { (yyval.hid) = H5Tcopy(H5T_NATIVE_INT); }
-#line 1530 "hl/src//H5LTparse.c"
+#line 1535 "hl/src//H5LTparse.c"
     break;
 
   case 36: /* integer_type: H5T_NATIVE_UINT_TOKEN  */
-#line 146 "hl/src//H5LTparse.y"
+#line 147 "hl/src//H5LTparse.y"
                                                 { (yyval.hid) = H5Tcopy(H5T_NATIVE_UINT); }
-#line 1536 "hl/src//H5LTparse.c"
+#line 1541 "hl/src//H5LTparse.c"
     break;
 
   case 37: /* integer_type: H5T_NATIVE_LONG_TOKEN  */
-#line 147 "hl/src//H5LTparse.y"
+#line 148 "hl/src//H5LTparse.y"
                                                 { (yyval.hid) = H5Tcopy(H5T_NATIVE_LONG); }
-#line 1542 "hl/src//H5LTparse.c"
+#line 1547 "hl/src//H5LTparse.c"
     break;
 
   case 38: /* integer_type: H5T_NATIVE_ULONG_TOKEN  */
-#line 148 "hl/src//H5LTparse.y"
+#line 149 "hl/src//H5LTparse.y"
                                                 { (yyval.hid) = H5Tcopy(H5T_NATIVE_ULONG); }
-#line 1548 "hl/src//H5LTparse.c"
+#line 1553 "hl/src//H5LTparse.c"
     break;
 
   case 39: /* integer_type: H5T_NATIVE_LLONG_TOKEN  */
-#line 149 "hl/src//H5LTparse.y"
+#line 150 "hl/src//H5LTparse.y"
                                                 { (yyval.hid) = H5Tcopy(H5T_NATIVE_LLONG); }
-#line 1554 "hl/src//H5LTparse.c"
+#line 1559 "hl/src//H5LTparse.c"
     break;
 
   case 40: /* integer_type: H5T_NATIVE_ULLONG_TOKEN  */
-#line 150 "hl/src//H5LTparse.y"
+#line 151 "hl/src//H5LTparse.y"
                                                 { (yyval.hid) = H5Tcopy(H5T_NATIVE_ULLONG); }
-#line 1560 "hl/src//H5LTparse.c"
+#line 1565 "hl/src//H5LTparse.c"
     break;
 
   case 41: /* fp_type: H5T_IEEE_F16BE_TOKEN  */
-#line 153 "hl/src//H5LTparse.y"
+#line 154 "hl/src//H5LTparse.y"
                                              { (yyval.hid) = H5Tcopy(H5T_IEEE_F16BE); }
-#line 1566 "hl/src//H5LTparse.c"
+#line 1571 "hl/src//H5LTparse.c"
     break;
 
   case 42: /* fp_type: H5T_IEEE_F16LE_TOKEN  */
-#line 154 "hl/src//H5LTparse.y"
+#line 155 "hl/src//H5LTparse.y"
                                              { (yyval.hid) = H5Tcopy(H5T_IEEE_F16LE); }
-#line 1572 "hl/src//H5LTparse.c"
+#line 1577 "hl/src//H5LTparse.c"
     break;
 
   case 43: /* fp_type: H5T_IEEE_F32BE_TOKEN  */
-#line 155 "hl/src//H5LTparse.y"
+#line 156 "hl/src//H5LTparse.y"
                                              { (yyval.hid) = H5Tcopy(H5T_IEEE_F32BE); }
-#line 1578 "hl/src//H5LTparse.c"
+#line 1583 "hl/src//H5LTparse.c"
     break;
 
   case 44: /* fp_type: H5T_IEEE_F32LE_TOKEN  */
-#line 156 "hl/src//H5LTparse.y"
+#line 157 "hl/src//H5LTparse.y"
                                              { (yyval.hid) = H5Tcopy(H5T_IEEE_F32LE); }
-#line 1584 "hl/src//H5LTparse.c"
+#line 1589 "hl/src//H5LTparse.c"
     break;
 
   case 45: /* fp_type: H5T_IEEE_F64BE_TOKEN  */
-#line 157 "hl/src//H5LTparse.y"
+#line 158 "hl/src//H5LTparse.y"
                                              { (yyval.hid) = H5Tcopy(H5T_IEEE_F64BE); }
-#line 1590 "hl/src//H5LTparse.c"
+#line 1595 "hl/src//H5LTparse.c"
     break;
 
   case 46: /* fp_type: H5T_IEEE_F64LE_TOKEN  */
-#line 158 "hl/src//H5LTparse.y"
-                                             { (yyval.hid) = H5Tcopy(H5T_IEEE_F64LE); }
-#line 1596 "hl/src//H5LTparse.c"
-    break;
-
-  case 47: /* fp_type: H5T_NATIVE_FLOAT16_TOKEN  */
 #line 159 "hl/src//H5LTparse.y"
-                                                  { (yyval.hid) = H5Tcopy(H5T_NATIVE_FLOAT16); }
-#line 1602 "hl/src//H5LTparse.c"
+                                             { (yyval.hid) = H5Tcopy(H5T_IEEE_F64LE); }
+#line 1601 "hl/src//H5LTparse.c"
     break;
 
-  case 48: /* fp_type: H5T_NATIVE_FLOAT_TOKEN  */
+  case 47: /* fp_type: H5T_FLOAT_BFLOAT16BE_TOKEN  */
 #line 160 "hl/src//H5LTparse.y"
-                                                  { (yyval.hid) = H5Tcopy(H5T_NATIVE_FLOAT); }
-#line 1608 "hl/src//H5LTparse.c"
+                                                   { (yyval.hid) = H5Tcopy(H5T_FLOAT_BFLOAT16BE); }
+#line 1607 "hl/src//H5LTparse.c"
     break;
 
-  case 49: /* fp_type: H5T_NATIVE_DOUBLE_TOKEN  */
+  case 48: /* fp_type: H5T_FLOAT_BFLOAT16LE_TOKEN  */
 #line 161 "hl/src//H5LTparse.y"
-                                                  { (yyval.hid) = H5Tcopy(H5T_NATIVE_DOUBLE); }
-#line 1614 "hl/src//H5LTparse.c"
+                                                   { (yyval.hid) = H5Tcopy(H5T_FLOAT_BFLOAT16LE); }
+#line 1613 "hl/src//H5LTparse.c"
     break;
 
-  case 50: /* fp_type: H5T_NATIVE_LDOUBLE_TOKEN  */
+  case 49: /* fp_type: H5T_NATIVE_FLOAT16_TOKEN  */
 #line 162 "hl/src//H5LTparse.y"
-                                                  { (yyval.hid) = H5Tcopy(H5T_NATIVE_LDOUBLE); }
-#line 1620 "hl/src//H5LTparse.c"
+                                                   { (yyval.hid) = H5Tcopy(H5T_NATIVE_FLOAT16); }
+#line 1619 "hl/src//H5LTparse.c"
     break;
 
-  case 51: /* $@1: %empty  */
-#line 166 "hl/src//H5LTparse.y"
+  case 50: /* fp_type: H5T_NATIVE_FLOAT_TOKEN  */
+#line 163 "hl/src//H5LTparse.y"
+                                                   { (yyval.hid) = H5Tcopy(H5T_NATIVE_FLOAT); }
+#line 1625 "hl/src//H5LTparse.c"
+    break;
+
+  case 51: /* fp_type: H5T_NATIVE_DOUBLE_TOKEN  */
+#line 164 "hl/src//H5LTparse.y"
+                                                   { (yyval.hid) = H5Tcopy(H5T_NATIVE_DOUBLE); }
+#line 1631 "hl/src//H5LTparse.c"
+    break;
+
+  case 52: /* fp_type: H5T_NATIVE_LDOUBLE_TOKEN  */
+#line 165 "hl/src//H5LTparse.y"
+                                                   { (yyval.hid) = H5Tcopy(H5T_NATIVE_LDOUBLE); }
+#line 1637 "hl/src//H5LTparse.c"
+    break;
+
+  case 53: /* $@1: %empty  */
+#line 169 "hl/src//H5LTparse.y"
                             { csindex++; cmpd_stack[csindex].id = H5Tcreate(H5T_COMPOUND, 1); /*temporarily set size to 1*/ }
-#line 1626 "hl/src//H5LTparse.c"
+#line 1643 "hl/src//H5LTparse.c"
     break;
 
-  case 52: /* compound_type: H5T_COMPOUND_TOKEN $@1 '{' memb_list '}'  */
-#line 168 "hl/src//H5LTparse.y"
+  case 54: /* compound_type: H5T_COMPOUND_TOKEN $@1 '{' memb_list '}'  */
+#line 171 "hl/src//H5LTparse.y"
                             { (yyval.hid) = cmpd_stack[csindex].id; 
                               cmpd_stack[csindex].id = 0;
                               cmpd_stack[csindex].first_memb = 1; 
                               csindex--;
                             }
-#line 1636 "hl/src//H5LTparse.c"
+#line 1653 "hl/src//H5LTparse.c"
     break;
 
-  case 55: /* $@2: %empty  */
-#line 177 "hl/src//H5LTparse.y"
+  case 57: /* $@2: %empty  */
+#line 180 "hl/src//H5LTparse.y"
                                  { cmpd_stack[csindex].is_field = 1; /*notify lexer a compound member is parsed*/ }
-#line 1642 "hl/src//H5LTparse.c"
+#line 1659 "hl/src//H5LTparse.c"
     break;
 
-  case 56: /* memb_def: ddl_type $@2 field_name field_offset ';'  */
-#line 179 "hl/src//H5LTparse.y"
+  case 58: /* memb_def: ddl_type $@2 field_name field_offset ';'  */
+#line 182 "hl/src//H5LTparse.y"
                         {   
                             size_t origin_size, new_size;
                             hid_t dtype_id = cmpd_stack[csindex].id;
@@ -1706,168 +1723,168 @@ yyreduce:
                              
                             new_size = H5Tget_size(dtype_id);
                         }
-#line 1681 "hl/src//H5LTparse.c"
+#line 1698 "hl/src//H5LTparse.c"
     break;
 
-  case 57: /* field_name: STRING  */
-#line 215 "hl/src//H5LTparse.y"
+  case 59: /* field_name: STRING  */
+#line 218 "hl/src//H5LTparse.y"
                         {
                             (yyval.sval) = strdup(yylval.sval);
                             free(yylval.sval);
                             yylval.sval = NULL;
                         }
-#line 1691 "hl/src//H5LTparse.c"
+#line 1708 "hl/src//H5LTparse.c"
     break;
 
-  case 58: /* field_offset: %empty  */
-#line 222 "hl/src//H5LTparse.y"
+  case 60: /* field_offset: %empty  */
+#line 225 "hl/src//H5LTparse.y"
                         { (yyval.ival) = 0; }
-#line 1697 "hl/src//H5LTparse.c"
+#line 1714 "hl/src//H5LTparse.c"
     break;
 
-  case 59: /* field_offset: ':' offset  */
-#line 224 "hl/src//H5LTparse.y"
+  case 61: /* field_offset: ':' offset  */
+#line 227 "hl/src//H5LTparse.y"
                         { (yyval.ival) = yylval.ival; }
-#line 1703 "hl/src//H5LTparse.c"
+#line 1720 "hl/src//H5LTparse.c"
     break;
 
-  case 61: /* $@3: %empty  */
-#line 228 "hl/src//H5LTparse.y"
+  case 63: /* $@3: %empty  */
+#line 231 "hl/src//H5LTparse.y"
                                         { asindex++; /*pushd onto the stack*/ }
-#line 1709 "hl/src//H5LTparse.c"
+#line 1726 "hl/src//H5LTparse.c"
     break;
 
-  case 62: /* array_type: H5T_ARRAY_TOKEN $@3 '{' dim_list ddl_type '}'  */
-#line 230 "hl/src//H5LTparse.y"
+  case 64: /* array_type: H5T_ARRAY_TOKEN $@3 '{' dim_list ddl_type '}'  */
+#line 233 "hl/src//H5LTparse.y"
                         { 
                           (yyval.hid) = H5Tarray_create2((yyvsp[-1].hid), arr_stack[asindex].ndims, arr_stack[asindex].dims);
                           arr_stack[asindex].ndims = 0;
                           asindex--;
                           H5Tclose((yyvsp[-1].hid));
                         }
-#line 1720 "hl/src//H5LTparse.c"
+#line 1737 "hl/src//H5LTparse.c"
     break;
 
-  case 65: /* $@4: %empty  */
-#line 240 "hl/src//H5LTparse.y"
+  case 67: /* $@4: %empty  */
+#line 243 "hl/src//H5LTparse.y"
                             { arr_stack[asindex].is_dim = 1; /*notice lexer of dimension size*/ }
-#line 1726 "hl/src//H5LTparse.c"
+#line 1743 "hl/src//H5LTparse.c"
     break;
 
-  case 66: /* $@5: %empty  */
-#line 241 "hl/src//H5LTparse.y"
+  case 68: /* $@5: %empty  */
+#line 244 "hl/src//H5LTparse.y"
                                 { unsigned ndims = arr_stack[asindex].ndims;
                                   arr_stack[asindex].dims[ndims] = (hsize_t)yylval.ival; 
                                   arr_stack[asindex].ndims++;
                                   arr_stack[asindex].is_dim = 0; 
                                 }
-#line 1736 "hl/src//H5LTparse.c"
+#line 1753 "hl/src//H5LTparse.c"
     break;
 
-  case 69: /* vlen_type: H5T_VLEN_TOKEN '{' ddl_type '}'  */
-#line 252 "hl/src//H5LTparse.y"
-                            { (yyval.hid) = H5Tvlen_create((yyvsp[-1].hid)); H5Tclose((yyvsp[-1].hid)); }
-#line 1742 "hl/src//H5LTparse.c"
-    break;
-
-  case 70: /* complex_type: H5T_NATIVE_FLOAT_COMPLEX_TOKEN  */
+  case 71: /* vlen_type: H5T_VLEN_TOKEN '{' ddl_type '}'  */
 #line 255 "hl/src//H5LTparse.y"
-                                                        { (yyval.hid) = H5Tcopy(H5T_NATIVE_FLOAT_COMPLEX); }
-#line 1748 "hl/src//H5LTparse.c"
+                            { (yyval.hid) = H5Tvlen_create((yyvsp[-1].hid)); H5Tclose((yyvsp[-1].hid)); }
+#line 1759 "hl/src//H5LTparse.c"
     break;
 
-  case 71: /* complex_type: H5T_NATIVE_DOUBLE_COMPLEX_TOKEN  */
-#line 256 "hl/src//H5LTparse.y"
-                                                         { (yyval.hid) = H5Tcopy(H5T_NATIVE_DOUBLE_COMPLEX); }
-#line 1754 "hl/src//H5LTparse.c"
-    break;
-
-  case 72: /* complex_type: H5T_NATIVE_LDOUBLE_COMPLEX_TOKEN  */
-#line 257 "hl/src//H5LTparse.y"
-                                                          { (yyval.hid) = H5Tcopy(H5T_NATIVE_LDOUBLE_COMPLEX); }
-#line 1760 "hl/src//H5LTparse.c"
-    break;
-
-  case 73: /* complex_type: H5T_COMPLEX_IEEE_F16LE_TOKEN  */
+  case 72: /* complex_type: H5T_NATIVE_FLOAT_COMPLEX_TOKEN  */
 #line 258 "hl/src//H5LTparse.y"
-                                                      { (yyval.hid) = H5Tcopy(H5T_COMPLEX_IEEE_F16LE); }
-#line 1766 "hl/src//H5LTparse.c"
+                                                        { (yyval.hid) = H5Tcopy(H5T_NATIVE_FLOAT_COMPLEX); }
+#line 1765 "hl/src//H5LTparse.c"
     break;
 
-  case 74: /* complex_type: H5T_COMPLEX_IEEE_F16BE_TOKEN  */
+  case 73: /* complex_type: H5T_NATIVE_DOUBLE_COMPLEX_TOKEN  */
 #line 259 "hl/src//H5LTparse.y"
-                                                      { (yyval.hid) = H5Tcopy(H5T_COMPLEX_IEEE_F16BE); }
-#line 1772 "hl/src//H5LTparse.c"
+                                                         { (yyval.hid) = H5Tcopy(H5T_NATIVE_DOUBLE_COMPLEX); }
+#line 1771 "hl/src//H5LTparse.c"
     break;
 
-  case 75: /* complex_type: H5T_COMPLEX_IEEE_F32LE_TOKEN  */
+  case 74: /* complex_type: H5T_NATIVE_LDOUBLE_COMPLEX_TOKEN  */
 #line 260 "hl/src//H5LTparse.y"
-                                                      { (yyval.hid) = H5Tcopy(H5T_COMPLEX_IEEE_F32LE); }
-#line 1778 "hl/src//H5LTparse.c"
+                                                          { (yyval.hid) = H5Tcopy(H5T_NATIVE_LDOUBLE_COMPLEX); }
+#line 1777 "hl/src//H5LTparse.c"
     break;
 
-  case 76: /* complex_type: H5T_COMPLEX_IEEE_F32BE_TOKEN  */
+  case 75: /* complex_type: H5T_COMPLEX_IEEE_F16LE_TOKEN  */
 #line 261 "hl/src//H5LTparse.y"
-                                                      { (yyval.hid) = H5Tcopy(H5T_COMPLEX_IEEE_F32BE); }
-#line 1784 "hl/src//H5LTparse.c"
+                                                      { (yyval.hid) = H5Tcopy(H5T_COMPLEX_IEEE_F16LE); }
+#line 1783 "hl/src//H5LTparse.c"
     break;
 
-  case 77: /* complex_type: H5T_COMPLEX_IEEE_F64LE_TOKEN  */
+  case 76: /* complex_type: H5T_COMPLEX_IEEE_F16BE_TOKEN  */
 #line 262 "hl/src//H5LTparse.y"
-                                                      { (yyval.hid) = H5Tcopy(H5T_COMPLEX_IEEE_F64LE); }
-#line 1790 "hl/src//H5LTparse.c"
+                                                      { (yyval.hid) = H5Tcopy(H5T_COMPLEX_IEEE_F16BE); }
+#line 1789 "hl/src//H5LTparse.c"
     break;
 
-  case 78: /* complex_type: H5T_COMPLEX_IEEE_F64BE_TOKEN  */
+  case 77: /* complex_type: H5T_COMPLEX_IEEE_F32LE_TOKEN  */
 #line 263 "hl/src//H5LTparse.y"
-                                                      { (yyval.hid) = H5Tcopy(H5T_COMPLEX_IEEE_F64BE); }
-#line 1796 "hl/src//H5LTparse.c"
+                                                      { (yyval.hid) = H5Tcopy(H5T_COMPLEX_IEEE_F32LE); }
+#line 1795 "hl/src//H5LTparse.c"
     break;
 
-  case 79: /* complex_type: H5T_COMPLEX_TOKEN '{' ddl_type '}'  */
+  case 78: /* complex_type: H5T_COMPLEX_IEEE_F32BE_TOKEN  */
+#line 264 "hl/src//H5LTparse.y"
+                                                      { (yyval.hid) = H5Tcopy(H5T_COMPLEX_IEEE_F32BE); }
+#line 1801 "hl/src//H5LTparse.c"
+    break;
+
+  case 79: /* complex_type: H5T_COMPLEX_IEEE_F64LE_TOKEN  */
 #line 265 "hl/src//H5LTparse.y"
-                            { (yyval.hid) = H5Tcomplex_create((yyvsp[-1].hid)); H5Tclose((yyvsp[-1].hid)); }
-#line 1802 "hl/src//H5LTparse.c"
+                                                      { (yyval.hid) = H5Tcopy(H5T_COMPLEX_IEEE_F64LE); }
+#line 1807 "hl/src//H5LTparse.c"
     break;
 
-  case 80: /* @6: %empty  */
-#line 271 "hl/src//H5LTparse.y"
+  case 80: /* complex_type: H5T_COMPLEX_IEEE_F64BE_TOKEN  */
+#line 266 "hl/src//H5LTparse.y"
+                                                      { (yyval.hid) = H5Tcopy(H5T_COMPLEX_IEEE_F64BE); }
+#line 1813 "hl/src//H5LTparse.c"
+    break;
+
+  case 81: /* complex_type: H5T_COMPLEX_TOKEN '{' ddl_type '}'  */
+#line 268 "hl/src//H5LTparse.y"
+                            { (yyval.hid) = H5Tcomplex_create((yyvsp[-1].hid)); H5Tclose((yyvsp[-1].hid)); }
+#line 1819 "hl/src//H5LTparse.c"
+    break;
+
+  case 82: /* @6: %empty  */
+#line 274 "hl/src//H5LTparse.y"
                             {   
                                 size_t size = (size_t)yylval.ival;
                                 (yyval.hid) = H5Tcreate(H5T_OPAQUE, size);
                             }
-#line 1811 "hl/src//H5LTparse.c"
+#line 1828 "hl/src//H5LTparse.c"
     break;
 
-  case 81: /* $@7: %empty  */
-#line 276 "hl/src//H5LTparse.y"
+  case 83: /* $@7: %empty  */
+#line 279 "hl/src//H5LTparse.y"
                             {  
                                 H5Tset_tag((yyvsp[-3].hid), yylval.sval);
                                 free(yylval.sval);
                                 yylval.sval = NULL;
                             }
-#line 1821 "hl/src//H5LTparse.c"
+#line 1838 "hl/src//H5LTparse.c"
     break;
 
-  case 82: /* opaque_type: H5T_OPAQUE_TOKEN '{' OPQ_SIZE_TOKEN opaque_size ';' @6 OPQ_TAG_TOKEN opaque_tag ';' $@7 '}'  */
-#line 281 "hl/src//H5LTparse.y"
+  case 84: /* opaque_type: H5T_OPAQUE_TOKEN '{' OPQ_SIZE_TOKEN opaque_size ';' @6 OPQ_TAG_TOKEN opaque_tag ';' $@7 '}'  */
+#line 284 "hl/src//H5LTparse.y"
                             { (yyval.hid) = (yyvsp[-5].hid); }
-#line 1827 "hl/src//H5LTparse.c"
+#line 1844 "hl/src//H5LTparse.c"
     break;
 
-  case 85: /* $@8: %empty  */
-#line 290 "hl/src//H5LTparse.y"
+  case 87: /* $@8: %empty  */
+#line 293 "hl/src//H5LTparse.y"
                             {  
                                 if((yyvsp[-1].ival) == H5T_VARIABLE_TOKEN)
                                     is_variable = 1;
                                 else 
                                     str_size = yylval.ival;
                             }
-#line 1838 "hl/src//H5LTparse.c"
+#line 1855 "hl/src//H5LTparse.c"
     break;
 
-  case 86: /* $@9: %empty  */
-#line 297 "hl/src//H5LTparse.y"
+  case 88: /* $@9: %empty  */
+#line 300 "hl/src//H5LTparse.y"
                             {
                                 if((yyvsp[-1].ival) == H5T_STR_NULLTERM_TOKEN)
                                     str_pad = H5T_STR_NULLTERM;
@@ -1876,33 +1893,33 @@ yyreduce:
                                 else if((yyvsp[-1].ival) == H5T_STR_SPACEPAD_TOKEN)
                                     str_pad = H5T_STR_SPACEPAD;
                             }
-#line 1851 "hl/src//H5LTparse.c"
+#line 1868 "hl/src//H5LTparse.c"
     break;
 
-  case 87: /* $@10: %empty  */
-#line 306 "hl/src//H5LTparse.y"
+  case 89: /* $@10: %empty  */
+#line 309 "hl/src//H5LTparse.y"
                             {  
                                 if((yyvsp[-1].ival) == H5T_CSET_ASCII_TOKEN)
                                     str_cset = H5T_CSET_ASCII;
                                 else if((yyvsp[-1].ival) == H5T_CSET_UTF8_TOKEN)
                                     str_cset = H5T_CSET_UTF8;
                             }
-#line 1862 "hl/src//H5LTparse.c"
+#line 1879 "hl/src//H5LTparse.c"
     break;
 
-  case 88: /* @11: %empty  */
-#line 313 "hl/src//H5LTparse.y"
+  case 90: /* @11: %empty  */
+#line 316 "hl/src//H5LTparse.y"
                             {
                                 if((yyvsp[-1].hid) == H5T_C_S1_TOKEN)
                                     (yyval.hid) = H5Tcopy(H5T_C_S1);
                                 else if((yyvsp[-1].hid) == H5T_FORTRAN_S1_TOKEN)
                                     (yyval.hid) = H5Tcopy(H5T_FORTRAN_S1);
                             }
-#line 1873 "hl/src//H5LTparse.c"
+#line 1890 "hl/src//H5LTparse.c"
     break;
 
-  case 89: /* string_type: H5T_STRING_TOKEN '{' STRSIZE_TOKEN strsize ';' $@8 STRPAD_TOKEN strpad ';' $@9 CSET_TOKEN cset ';' $@10 CTYPE_TOKEN ctype ';' @11 '}'  */
-#line 320 "hl/src//H5LTparse.y"
+  case 91: /* string_type: H5T_STRING_TOKEN '{' STRSIZE_TOKEN strsize ';' $@8 STRPAD_TOKEN strpad ';' $@9 CSET_TOKEN cset ';' $@10 CTYPE_TOKEN ctype ';' @11 '}'  */
+#line 323 "hl/src//H5LTparse.y"
                             {   
                                 hid_t str_id = (yyvsp[-1].hid);
 
@@ -1919,82 +1936,82 @@ yyreduce:
 
                                 (yyval.hid) = str_id; 
                             }
-#line 1894 "hl/src//H5LTparse.c"
+#line 1911 "hl/src//H5LTparse.c"
     break;
 
-  case 90: /* strsize: H5T_VARIABLE_TOKEN  */
-#line 337 "hl/src//H5LTparse.y"
-                                               {(yyval.ival) = H5T_VARIABLE_TOKEN;}
-#line 1900 "hl/src//H5LTparse.c"
-    break;
-
-  case 92: /* strpad: H5T_STR_NULLTERM_TOKEN  */
+  case 92: /* strsize: H5T_VARIABLE_TOKEN  */
 #line 340 "hl/src//H5LTparse.y"
+                                               {(yyval.ival) = H5T_VARIABLE_TOKEN;}
+#line 1917 "hl/src//H5LTparse.c"
+    break;
+
+  case 94: /* strpad: H5T_STR_NULLTERM_TOKEN  */
+#line 343 "hl/src//H5LTparse.y"
                                                {(yyval.ival) = H5T_STR_NULLTERM_TOKEN;}
-#line 1906 "hl/src//H5LTparse.c"
+#line 1923 "hl/src//H5LTparse.c"
     break;
 
-  case 93: /* strpad: H5T_STR_NULLPAD_TOKEN  */
-#line 341 "hl/src//H5LTparse.y"
-                                               {(yyval.ival) = H5T_STR_NULLPAD_TOKEN;}
-#line 1912 "hl/src//H5LTparse.c"
-    break;
-
-  case 94: /* strpad: H5T_STR_SPACEPAD_TOKEN  */
-#line 342 "hl/src//H5LTparse.y"
-                                               {(yyval.ival) = H5T_STR_SPACEPAD_TOKEN;}
-#line 1918 "hl/src//H5LTparse.c"
-    break;
-
-  case 95: /* cset: H5T_CSET_ASCII_TOKEN  */
+  case 95: /* strpad: H5T_STR_NULLPAD_TOKEN  */
 #line 344 "hl/src//H5LTparse.y"
-                                             {(yyval.ival) = H5T_CSET_ASCII_TOKEN;}
-#line 1924 "hl/src//H5LTparse.c"
+                                               {(yyval.ival) = H5T_STR_NULLPAD_TOKEN;}
+#line 1929 "hl/src//H5LTparse.c"
     break;
 
-  case 96: /* cset: H5T_CSET_UTF8_TOKEN  */
+  case 96: /* strpad: H5T_STR_SPACEPAD_TOKEN  */
 #line 345 "hl/src//H5LTparse.y"
-                                            {(yyval.ival) = H5T_CSET_UTF8_TOKEN;}
-#line 1930 "hl/src//H5LTparse.c"
+                                               {(yyval.ival) = H5T_STR_SPACEPAD_TOKEN;}
+#line 1935 "hl/src//H5LTparse.c"
     break;
 
-  case 97: /* ctype: H5T_C_S1_TOKEN  */
+  case 97: /* cset: H5T_CSET_ASCII_TOKEN  */
 #line 347 "hl/src//H5LTparse.y"
-                                               {(yyval.hid) = H5T_C_S1_TOKEN;}
-#line 1936 "hl/src//H5LTparse.c"
+                                             {(yyval.ival) = H5T_CSET_ASCII_TOKEN;}
+#line 1941 "hl/src//H5LTparse.c"
     break;
 
-  case 98: /* ctype: H5T_FORTRAN_S1_TOKEN  */
+  case 98: /* cset: H5T_CSET_UTF8_TOKEN  */
 #line 348 "hl/src//H5LTparse.y"
+                                            {(yyval.ival) = H5T_CSET_UTF8_TOKEN;}
+#line 1947 "hl/src//H5LTparse.c"
+    break;
+
+  case 99: /* ctype: H5T_C_S1_TOKEN  */
+#line 350 "hl/src//H5LTparse.y"
+                                               {(yyval.hid) = H5T_C_S1_TOKEN;}
+#line 1953 "hl/src//H5LTparse.c"
+    break;
+
+  case 100: /* ctype: H5T_FORTRAN_S1_TOKEN  */
+#line 351 "hl/src//H5LTparse.y"
                                                {(yyval.hid) = H5T_FORTRAN_S1_TOKEN;}
-#line 1942 "hl/src//H5LTparse.c"
+#line 1959 "hl/src//H5LTparse.c"
     break;
 
-  case 99: /* $@12: %empty  */
-#line 352 "hl/src//H5LTparse.y"
+  case 101: /* $@12: %empty  */
+#line 355 "hl/src//H5LTparse.y"
                             { is_enum = 1; enum_id = H5Tenum_create((yyvsp[-1].hid)); H5Tclose((yyvsp[-1].hid)); }
-#line 1948 "hl/src//H5LTparse.c"
+#line 1965 "hl/src//H5LTparse.c"
     break;
 
-  case 100: /* enum_type: H5T_ENUM_TOKEN '{' integer_type ';' $@12 enum_list '}'  */
-#line 354 "hl/src//H5LTparse.y"
+  case 102: /* enum_type: H5T_ENUM_TOKEN '{' integer_type ';' $@12 enum_list '}'  */
+#line 357 "hl/src//H5LTparse.y"
                             { is_enum = 0; /*reset*/ (yyval.hid) = enum_id; }
-#line 1954 "hl/src//H5LTparse.c"
+#line 1971 "hl/src//H5LTparse.c"
     break;
 
-  case 103: /* $@13: %empty  */
-#line 359 "hl/src//H5LTparse.y"
+  case 105: /* $@13: %empty  */
+#line 362 "hl/src//H5LTparse.y"
                                             {
                                                 is_enum_memb = 1; /*indicate member of enum*/
                                                 enum_memb_symbol = strdup(yylval.sval); 
                                                 free(yylval.sval);
                                                 yylval.sval = NULL;
                                             }
-#line 1965 "hl/src//H5LTparse.c"
+#line 1982 "hl/src//H5LTparse.c"
     break;
 
-  case 104: /* enum_def: enum_symbol $@13 enum_val ';'  */
-#line 366 "hl/src//H5LTparse.y"
+  case 106: /* enum_def: enum_symbol $@13 enum_val ';'  */
+#line 369 "hl/src//H5LTparse.y"
                             {
                                 char char_val=(char)yylval.ival;
                                 short short_val=(short)yylval.ival;
@@ -2037,11 +2054,11 @@ yyreduce:
                                 H5Tclose(super);
                                 H5Tclose(native);
                             }
-#line 2012 "hl/src//H5LTparse.c"
+#line 2029 "hl/src//H5LTparse.c"
     break;
 
 
-#line 2016 "hl/src//H5LTparse.c"
+#line 2033 "hl/src//H5LTparse.c"
 
       default: break;
     }
diff --git a/hl/src/H5LTparse.h b/hl/src/H5LTparse.h
index 0ac873895c3..70aab7373bc 100644
--- a/hl/src/H5LTparse.h
+++ b/hl/src/H5LTparse.h
@@ -87,42 +87,44 @@ extern int H5LTyydebug;
     H5T_IEEE_F32LE_TOKEN = 288,    /* H5T_IEEE_F32LE_TOKEN  */
     H5T_IEEE_F64BE_TOKEN = 289,    /* H5T_IEEE_F64BE_TOKEN  */
     H5T_IEEE_F64LE_TOKEN = 290,    /* H5T_IEEE_F64LE_TOKEN  */
-    H5T_NATIVE_FLOAT16_TOKEN = 291, /* H5T_NATIVE_FLOAT16_TOKEN  */
-    H5T_NATIVE_FLOAT_TOKEN = 292,  /* H5T_NATIVE_FLOAT_TOKEN  */
-    H5T_NATIVE_DOUBLE_TOKEN = 293, /* H5T_NATIVE_DOUBLE_TOKEN  */
-    H5T_NATIVE_LDOUBLE_TOKEN = 294, /* H5T_NATIVE_LDOUBLE_TOKEN  */
-    H5T_COMPLEX_IEEE_F16BE_TOKEN = 295, /* H5T_COMPLEX_IEEE_F16BE_TOKEN  */
-    H5T_COMPLEX_IEEE_F16LE_TOKEN = 296, /* H5T_COMPLEX_IEEE_F16LE_TOKEN  */
-    H5T_COMPLEX_IEEE_F32BE_TOKEN = 297, /* H5T_COMPLEX_IEEE_F32BE_TOKEN  */
-    H5T_COMPLEX_IEEE_F32LE_TOKEN = 298, /* H5T_COMPLEX_IEEE_F32LE_TOKEN  */
-    H5T_COMPLEX_IEEE_F64BE_TOKEN = 299, /* H5T_COMPLEX_IEEE_F64BE_TOKEN  */
-    H5T_COMPLEX_IEEE_F64LE_TOKEN = 300, /* H5T_COMPLEX_IEEE_F64LE_TOKEN  */
-    H5T_NATIVE_FLOAT_COMPLEX_TOKEN = 301, /* H5T_NATIVE_FLOAT_COMPLEX_TOKEN  */
-    H5T_NATIVE_DOUBLE_COMPLEX_TOKEN = 302, /* H5T_NATIVE_DOUBLE_COMPLEX_TOKEN  */
-    H5T_NATIVE_LDOUBLE_COMPLEX_TOKEN = 303, /* H5T_NATIVE_LDOUBLE_COMPLEX_TOKEN  */
-    H5T_STRING_TOKEN = 304,        /* H5T_STRING_TOKEN  */
-    STRSIZE_TOKEN = 305,           /* STRSIZE_TOKEN  */
-    STRPAD_TOKEN = 306,            /* STRPAD_TOKEN  */
-    CSET_TOKEN = 307,              /* CSET_TOKEN  */
-    CTYPE_TOKEN = 308,             /* CTYPE_TOKEN  */
-    H5T_VARIABLE_TOKEN = 309,      /* H5T_VARIABLE_TOKEN  */
-    H5T_STR_NULLTERM_TOKEN = 310,  /* H5T_STR_NULLTERM_TOKEN  */
-    H5T_STR_NULLPAD_TOKEN = 311,   /* H5T_STR_NULLPAD_TOKEN  */
-    H5T_STR_SPACEPAD_TOKEN = 312,  /* H5T_STR_SPACEPAD_TOKEN  */
-    H5T_CSET_ASCII_TOKEN = 313,    /* H5T_CSET_ASCII_TOKEN  */
-    H5T_CSET_UTF8_TOKEN = 314,     /* H5T_CSET_UTF8_TOKEN  */
-    H5T_C_S1_TOKEN = 315,          /* H5T_C_S1_TOKEN  */
-    H5T_FORTRAN_S1_TOKEN = 316,    /* H5T_FORTRAN_S1_TOKEN  */
-    H5T_OPAQUE_TOKEN = 317,        /* H5T_OPAQUE_TOKEN  */
-    OPQ_SIZE_TOKEN = 318,          /* OPQ_SIZE_TOKEN  */
-    OPQ_TAG_TOKEN = 319,           /* OPQ_TAG_TOKEN  */
-    H5T_COMPOUND_TOKEN = 320,      /* H5T_COMPOUND_TOKEN  */
-    H5T_ENUM_TOKEN = 321,          /* H5T_ENUM_TOKEN  */
-    H5T_ARRAY_TOKEN = 322,         /* H5T_ARRAY_TOKEN  */
-    H5T_VLEN_TOKEN = 323,          /* H5T_VLEN_TOKEN  */
-    H5T_COMPLEX_TOKEN = 324,       /* H5T_COMPLEX_TOKEN  */
-    STRING = 325,                  /* STRING  */
-    NUMBER = 326                   /* NUMBER  */
+    H5T_FLOAT_BFLOAT16BE_TOKEN = 291, /* H5T_FLOAT_BFLOAT16BE_TOKEN  */
+    H5T_FLOAT_BFLOAT16LE_TOKEN = 292, /* H5T_FLOAT_BFLOAT16LE_TOKEN  */
+    H5T_NATIVE_FLOAT16_TOKEN = 293, /* H5T_NATIVE_FLOAT16_TOKEN  */
+    H5T_NATIVE_FLOAT_TOKEN = 294,  /* H5T_NATIVE_FLOAT_TOKEN  */
+    H5T_NATIVE_DOUBLE_TOKEN = 295, /* H5T_NATIVE_DOUBLE_TOKEN  */
+    H5T_NATIVE_LDOUBLE_TOKEN = 296, /* H5T_NATIVE_LDOUBLE_TOKEN  */
+    H5T_COMPLEX_IEEE_F16BE_TOKEN = 297, /* H5T_COMPLEX_IEEE_F16BE_TOKEN  */
+    H5T_COMPLEX_IEEE_F16LE_TOKEN = 298, /* H5T_COMPLEX_IEEE_F16LE_TOKEN  */
+    H5T_COMPLEX_IEEE_F32BE_TOKEN = 299, /* H5T_COMPLEX_IEEE_F32BE_TOKEN  */
+    H5T_COMPLEX_IEEE_F32LE_TOKEN = 300, /* H5T_COMPLEX_IEEE_F32LE_TOKEN  */
+    H5T_COMPLEX_IEEE_F64BE_TOKEN = 301, /* H5T_COMPLEX_IEEE_F64BE_TOKEN  */
+    H5T_COMPLEX_IEEE_F64LE_TOKEN = 302, /* H5T_COMPLEX_IEEE_F64LE_TOKEN  */
+    H5T_NATIVE_FLOAT_COMPLEX_TOKEN = 303, /* H5T_NATIVE_FLOAT_COMPLEX_TOKEN  */
+    H5T_NATIVE_DOUBLE_COMPLEX_TOKEN = 304, /* H5T_NATIVE_DOUBLE_COMPLEX_TOKEN  */
+    H5T_NATIVE_LDOUBLE_COMPLEX_TOKEN = 305, /* H5T_NATIVE_LDOUBLE_COMPLEX_TOKEN  */
+    H5T_STRING_TOKEN = 306,        /* H5T_STRING_TOKEN  */
+    STRSIZE_TOKEN = 307,           /* STRSIZE_TOKEN  */
+    STRPAD_TOKEN = 308,            /* STRPAD_TOKEN  */
+    CSET_TOKEN = 309,              /* CSET_TOKEN  */
+    CTYPE_TOKEN = 310,             /* CTYPE_TOKEN  */
+    H5T_VARIABLE_TOKEN = 311,      /* H5T_VARIABLE_TOKEN  */
+    H5T_STR_NULLTERM_TOKEN = 312,  /* H5T_STR_NULLTERM_TOKEN  */
+    H5T_STR_NULLPAD_TOKEN = 313,   /* H5T_STR_NULLPAD_TOKEN  */
+    H5T_STR_SPACEPAD_TOKEN = 314,  /* H5T_STR_SPACEPAD_TOKEN  */
+    H5T_CSET_ASCII_TOKEN = 315,    /* H5T_CSET_ASCII_TOKEN  */
+    H5T_CSET_UTF8_TOKEN = 316,     /* H5T_CSET_UTF8_TOKEN  */
+    H5T_C_S1_TOKEN = 317,          /* H5T_C_S1_TOKEN  */
+    H5T_FORTRAN_S1_TOKEN = 318,    /* H5T_FORTRAN_S1_TOKEN  */
+    H5T_OPAQUE_TOKEN = 319,        /* H5T_OPAQUE_TOKEN  */
+    OPQ_SIZE_TOKEN = 320,          /* OPQ_SIZE_TOKEN  */
+    OPQ_TAG_TOKEN = 321,           /* OPQ_TAG_TOKEN  */
+    H5T_COMPOUND_TOKEN = 322,      /* H5T_COMPOUND_TOKEN  */
+    H5T_ENUM_TOKEN = 323,          /* H5T_ENUM_TOKEN  */
+    H5T_ARRAY_TOKEN = 324,         /* H5T_ARRAY_TOKEN  */
+    H5T_VLEN_TOKEN = 325,          /* H5T_VLEN_TOKEN  */
+    H5T_COMPLEX_TOKEN = 326,       /* H5T_COMPLEX_TOKEN  */
+    STRING = 327,                  /* STRING  */
+    NUMBER = 328                   /* NUMBER  */
   };
   typedef enum yytokentype yytoken_kind_t;
 #endif
@@ -137,7 +139,7 @@ union YYSTYPE
     char    *sval;        /*for name string*/
     hid_t   hid;          /*for hid_t token*/
 
-#line 141 "hl/src//H5LTparse.h"
+#line 143 "hl/src//H5LTparse.h"
 
 };
 typedef union YYSTYPE YYSTYPE;
diff --git a/hl/src/H5LTparse.y b/hl/src/H5LTparse.y
index 2d36af73b0c..4c3db030656 100644
--- a/hl/src/H5LTparse.y
+++ b/hl/src/H5LTparse.y
@@ -81,6 +81,7 @@ static char*       enum_memb_symbol;       /*enum member symbol string*/
 
 %token <hid> H5T_IEEE_F16BE_TOKEN H5T_IEEE_F16LE_TOKEN
 %token <hid> H5T_IEEE_F32BE_TOKEN H5T_IEEE_F32LE_TOKEN H5T_IEEE_F64BE_TOKEN H5T_IEEE_F64LE_TOKEN
+%token <hid> H5T_FLOAT_BFLOAT16BE_TOKEN H5T_FLOAT_BFLOAT16LE_TOKEN
 %token <hid> H5T_NATIVE_FLOAT16_TOKEN H5T_NATIVE_FLOAT_TOKEN H5T_NATIVE_DOUBLE_TOKEN H5T_NATIVE_LDOUBLE_TOKEN
 
 %token <hid> H5T_COMPLEX_IEEE_F16BE_TOKEN H5T_COMPLEX_IEEE_F16LE_TOKEN
@@ -156,10 +157,12 @@ fp_type         :       H5T_IEEE_F16BE_TOKEN { $<hid>$ = H5Tcopy(H5T_IEEE_F16BE)
                 |       H5T_IEEE_F32LE_TOKEN { $<hid>$ = H5Tcopy(H5T_IEEE_F32LE); }
                 |       H5T_IEEE_F64BE_TOKEN { $<hid>$ = H5Tcopy(H5T_IEEE_F64BE); }
                 |       H5T_IEEE_F64LE_TOKEN { $<hid>$ = H5Tcopy(H5T_IEEE_F64LE); }
-                |       H5T_NATIVE_FLOAT16_TOKEN  { $<hid>$ = H5Tcopy(H5T_NATIVE_FLOAT16); }
-                |       H5T_NATIVE_FLOAT_TOKEN    { $<hid>$ = H5Tcopy(H5T_NATIVE_FLOAT); }
-                |       H5T_NATIVE_DOUBLE_TOKEN   { $<hid>$ = H5Tcopy(H5T_NATIVE_DOUBLE); }
-                |       H5T_NATIVE_LDOUBLE_TOKEN  { $<hid>$ = H5Tcopy(H5T_NATIVE_LDOUBLE); }
+                |       H5T_FLOAT_BFLOAT16BE_TOKEN { $<hid>$ = H5Tcopy(H5T_FLOAT_BFLOAT16BE); }
+                |       H5T_FLOAT_BFLOAT16LE_TOKEN { $<hid>$ = H5Tcopy(H5T_FLOAT_BFLOAT16LE); }
+                |       H5T_NATIVE_FLOAT16_TOKEN   { $<hid>$ = H5Tcopy(H5T_NATIVE_FLOAT16); }
+                |       H5T_NATIVE_FLOAT_TOKEN     { $<hid>$ = H5Tcopy(H5T_NATIVE_FLOAT); }
+                |       H5T_NATIVE_DOUBLE_TOKEN    { $<hid>$ = H5Tcopy(H5T_NATIVE_DOUBLE); }
+                |       H5T_NATIVE_LDOUBLE_TOKEN   { $<hid>$ = H5Tcopy(H5T_NATIVE_LDOUBLE); }
                 ;
 
 compound_type   :       H5T_COMPOUND_TOKEN
diff --git a/hl/test/test_lite.c b/hl/test/test_lite.c
index d17ca14870f..0bf8812ed47 100644
--- a/hl/test/test_lite.c
+++ b/hl/test/test_lite.c
@@ -1193,6 +1193,20 @@ test_fps(void)
     if (H5Tclose(dtype) < 0)
         goto out;
 
+    if ((dtype = H5LTtext_to_dtype("H5T_FLOAT_BFLOAT16BE\n", H5LT_DDL)) < 0)
+        goto out;
+    if (!H5Tequal(dtype, H5T_FLOAT_BFLOAT16BE))
+        goto out;
+    if (H5Tclose(dtype) < 0)
+        goto out;
+
+    if ((dtype = H5LTtext_to_dtype("H5T_FLOAT_BFLOAT16LE\n", H5LT_DDL)) < 0)
+        goto out;
+    if (!H5Tequal(dtype, H5T_FLOAT_BFLOAT16LE))
+        goto out;
+    if (H5Tclose(dtype) < 0)
+        goto out;
+
     PASSED();
     return 0;
 
diff --git a/java/src/hdf/hdf5lib/HDF5Constants.java b/java/src/hdf/hdf5lib/HDF5Constants.java
index 05ed9b5a3ca..014d5fd2e5e 100644
--- a/java/src/hdf/hdf5lib/HDF5Constants.java
+++ b/java/src/hdf/hdf5lib/HDF5Constants.java
@@ -1121,6 +1121,10 @@ public class HDF5Constants {
     /** */
     public static final long H5T_IEEE_F64LE = H5T_IEEE_F64LE();
     /** */
+    public static final long H5T_FLOAT_BFLOAT16BE = H5T_FLOAT_BFLOAT16BE();
+    /** */
+    public static final long H5T_FLOAT_BFLOAT16LE = H5T_FLOAT_BFLOAT16LE();
+    /** */
     public static final int H5T_INTEGER = H5T_INTEGER();
     /** */
     public static final long H5T_INTEL_B16 = H5T_INTEL_B16();
@@ -2632,6 +2636,10 @@ public class HDF5Constants {
 
     private static native final long H5T_IEEE_F64LE();
 
+    private static native final long H5T_FLOAT_BFLOAT16BE();
+
+    private static native final long H5T_FLOAT_BFLOAT16LE();
+
     private static native final int H5T_INTEGER();
 
     private static native final long H5T_INTEL_B16();
diff --git a/java/src/jni/h5Constants.c b/java/src/jni/h5Constants.c
index 65730f598d9..18ea37df1f9 100644
--- a/java/src/jni/h5Constants.c
+++ b/java/src/jni/h5Constants.c
@@ -2736,6 +2736,16 @@ Java_hdf_hdf5lib_HDF5Constants_H5T_1IEEE_1F64LE(JNIEnv *env, jclass cls)
 {
     return H5T_IEEE_F64LE;
 }
+JNIEXPORT jlong JNICALL
+Java_hdf_hdf5lib_HDF5Constants_H5T_1FLOAT_1BFLOAT16BE(JNIEnv *env, jclass cls)
+{
+    return H5T_FLOAT_BFLOAT16BE;
+}
+JNIEXPORT jlong JNICALL
+Java_hdf_hdf5lib_HDF5Constants_H5T_1FLOAT_1BFLOAT16LE(JNIEnv *env, jclass cls)
+{
+    return H5T_FLOAT_BFLOAT16LE;
+}
 JNIEXPORT jint JNICALL
 Java_hdf_hdf5lib_HDF5Constants_H5T_1INTEGER(JNIEnv *env, jclass cls)
 {
diff --git a/java/src/jni/h5util.c b/java/src/jni/h5util.c
index cc08e33ab70..3946f7764e0 100644
--- a/java/src/jni/h5util.c
+++ b/java/src/jni/h5util.c
@@ -2166,8 +2166,13 @@ h5str_get_little_endian_type(hid_t tid)
         }
 
         case H5T_FLOAT: {
-            if (size == 2)
-                p_type = H5Tcopy(H5T_IEEE_F16LE);
+            if (size == 2) {
+                if (true == H5Tequal(tid, H5T_IEEE_F16LE) || true == H5Tequal(tid, H5T_IEEE_F16BE))
+                    p_type = H5Tcopy(H5T_IEEE_F16LE);
+                else if (true == H5Tequal(tid, H5T_FLOAT_BFLOAT16LE) ||
+                         true == H5Tequal(tid, H5T_FLOAT_BFLOAT16BE))
+                    p_type = H5Tcopy(H5T_FLOAT_BFLOAT16LE);
+            }
             else if (size == 4)
                 p_type = H5Tcopy(H5T_IEEE_F32LE);
             else if (size == 8)
@@ -2273,8 +2278,13 @@ h5str_get_big_endian_type(hid_t tid)
         }
 
         case H5T_FLOAT: {
-            if (size == 2)
-                p_type = H5Tcopy(H5T_IEEE_F16BE);
+            if (size == 2) {
+                if (true == H5Tequal(tid, H5T_IEEE_F16LE) || true == H5Tequal(tid, H5T_IEEE_F16BE))
+                    p_type = H5Tcopy(H5T_IEEE_F16BE);
+                else if (true == H5Tequal(tid, H5T_FLOAT_BFLOAT16LE) ||
+                         true == H5Tequal(tid, H5T_FLOAT_BFLOAT16BE))
+                    p_type = H5Tcopy(H5T_FLOAT_BFLOAT16BE);
+            }
             else if (size == 4)
                 p_type = H5Tcopy(H5T_IEEE_F32BE);
             else if (size == 8)
diff --git a/release_docs/CHANGELOG.md b/release_docs/CHANGELOG.md
index db47b6c24ac..a99746e8a99 100644
--- a/release_docs/CHANGELOG.md
+++ b/release_docs/CHANGELOG.md
@@ -172,8 +172,22 @@ All other HDF5 library CMake options are prefixed with `HDF5_`
 
 ## Library
 
-### Removed `hbool_t` from public API calls
+### Added predefined datatypes for bfloat16 data
 
+   Predefined datatypes have been added for little- and big-endian bfloat16 (https://en.wikipedia.org/wiki/Bfloat16_floating-point_format) data.
+
+   The following new macros have been added:
+
+    - H5T_FLOAT_BFLOAT16LE / H5T_FLOAT_BFLOAT16BE
+
+      These macros map to IDs of HDF5 datatypes representing a little- or big-endian 16-bit floating-point datatype with 1 sign bit, 8 exponent bits and 7 fraction bits.
+
+      Note that support for a native bfloat16 datatype has not been added yet. This means that any datatype conversions to/from the new bfloat16 datatypes will be emulated in software rather than potentially using specialized hardware instructions. Until support for a native bfloat16 type is added, an application can avoid datatype conversion performance issues if it is sure that the datatype used for in-memory data buffers matches the above floating-point format (such as the __bf16 type). In this case, the application can specify one of the above macros for both the file datatype when creating a dataset or attribute and the memory datatype when performing I/O on the dataset or attribute.
+
+### Removed hbool_t from public API calls
+                                  
+### Removed `hbool_t` from public API calls
+                                  
 The `hbool_t` type was introduced before the library supported C99's Boolean type. Originally typedef'd to an integer, it has been typedef'd to C99's bool for many years.
 
 It had been previously purged from the bulk of the library code and only remained in public API signatures. In HDF5 2.0, it has also been removed from public API signatures.
diff --git a/src/H5T.c b/src/H5T.c
index 12fc4ae0be2..6426016f304 100644
--- a/src/H5T.c
+++ b/src/H5T.c
@@ -143,6 +143,30 @@
         H5T_INIT_TYPE_FLOAT16_COMMON(H5T_ORDER_BE)                                                           \
     }
 
+/* Define the code templates for standard 16-bit bfloat16 floats for the "GUTS" in the H5T_INIT_TYPE macro */
+#define H5T_INIT_TYPE_BFLOAT16_COMMON(ENDIANNESS)                                                            \
+    {                                                                                                        \
+        H5T_INIT_TYPE_NUM_COMMON(ENDIANNESS)                                                                 \
+        dt->shared->u.atomic.u.f.sign  = 15;                                                                 \
+        dt->shared->u.atomic.u.f.epos  = 7;                                                                  \
+        dt->shared->u.atomic.u.f.esize = 8;                                                                  \
+        dt->shared->u.atomic.u.f.ebias = 0x7f;                                                               \
+        dt->shared->u.atomic.u.f.mpos  = 0;                                                                  \
+        dt->shared->u.atomic.u.f.msize = 7;                                                                  \
+        dt->shared->u.atomic.u.f.norm  = H5T_NORM_IMPLIED;                                                   \
+        dt->shared->u.atomic.u.f.pad   = H5T_PAD_ZERO;                                                       \
+    }
+
+#define H5T_INIT_TYPE_BFLOAT16LE_CORE                                                                        \
+    {                                                                                                        \
+        H5T_INIT_TYPE_BFLOAT16_COMMON(H5T_ORDER_LE)                                                          \
+    }
+
+#define H5T_INIT_TYPE_BFLOAT16BE_CORE                                                                        \
+    {                                                                                                        \
+        H5T_INIT_TYPE_BFLOAT16_COMMON(H5T_ORDER_BE)                                                          \
+    }
+
 /* Define the code templates for standard floats for the "GUTS" in the H5T_INIT_TYPE macro */
 #define H5T_INIT_TYPE_FLOAT_COMMON(ENDIANNESS)                                                               \
     {                                                                                                        \
@@ -433,6 +457,9 @@ hid_t H5T_IEEE_F32LE_g = H5I_INVALID_HID;
 hid_t H5T_IEEE_F64BE_g = H5I_INVALID_HID;
 hid_t H5T_IEEE_F64LE_g = H5I_INVALID_HID;
 
+hid_t H5T_FLOAT_BFLOAT16BE_g = H5I_INVALID_HID;
+hid_t H5T_FLOAT_BFLOAT16LE_g = H5I_INVALID_HID;
+
 hid_t H5T_COMPLEX_IEEE_F16BE_g = H5I_INVALID_HID;
 hid_t H5T_COMPLEX_IEEE_F16LE_g = H5I_INVALID_HID;
 hid_t H5T_COMPLEX_IEEE_F32BE_g = H5I_INVALID_HID;
@@ -1087,6 +1114,17 @@ H5T__init_package(void)
     /* IEEE 8-byte big-endian float */
     H5T_INIT_TYPE(DOUBLEBE, H5T_IEEE_F64BE_g, COPY, native_double, SET, 8)
 
+    /*------------------------------------------------------------
+     * Alternative floating-point types
+     *------------------------------------------------------------
+     */
+
+    /* 2-byte little-endian bfloat16 float type */
+    H5T_INIT_TYPE(BFLOAT16LE, H5T_FLOAT_BFLOAT16LE_g, COPY, native_double, SET, 2)
+
+    /* 2-byte big-endian bfloat16 float type */
+    H5T_INIT_TYPE(BFLOAT16BE, H5T_FLOAT_BFLOAT16BE_g, COPY, native_double, SET, 2)
+
     /*------------------------------------------------------------
      * VAX Types
      *------------------------------------------------------------
@@ -2182,6 +2220,9 @@ H5T_top_term_package(void)
             H5T_IEEE_F64BE_g = H5I_INVALID_HID;
             H5T_IEEE_F64LE_g = H5I_INVALID_HID;
 
+            H5T_FLOAT_BFLOAT16BE_g = H5I_INVALID_HID;
+            H5T_FLOAT_BFLOAT16LE_g = H5I_INVALID_HID;
+
             H5T_COMPLEX_IEEE_F16BE_g = H5I_INVALID_HID;
             H5T_COMPLEX_IEEE_F16LE_g = H5I_INVALID_HID;
             H5T_COMPLEX_IEEE_F32BE_g = H5I_INVALID_HID;
diff --git a/src/H5Tmodule.h b/src/H5Tmodule.h
index dee04c5169e..619aa331b11 100644
--- a/src/H5Tmodule.h
+++ b/src/H5Tmodule.h
@@ -4013,6 +4013,7 @@ filled according to the value of this property. The padding can be:
  *   <float> ::= H5T_IEEE_F16BE | H5T_IEEE_F16LE |
  *               H5T_IEEE_F32BE | H5T_IEEE_F32LE |
  *               H5T_IEEE_F64BE | H5T_IEEE_F64LE |
+ *               H5T_FLOAT_BFLOAT16BE | H5T_FLOAT_BFLOAT16LE |
  *               H5T_NATIVE_FLOAT16 | H5T_NATIVE_FLOAT |
  *               H5T_NATIVE_DOUBLE | H5T_NATIVE_LDOUBLE
  *
@@ -4189,6 +4190,13 @@ filled according to the value of this property. The padding can be:
  * \snippet{doc} tables/predefinedDatatypes.dox predefined_ieee_datatypes_table
  * </div>
  *
+ * \defgroup PDTALTFLOAT Alternative Floating Point Datatypes
+ * \ingroup PDT
+ * \details Alternative (non-IEEE) floating point types.
+ * <div>
+ * \snippet{doc} tables/predefinedDatatypes.dox predefined_alt_float_datatypes_table
+ * </div>
+ *
  * \defgroup PDTCOMPLEX Complex Number Datatypes
  * \ingroup PDT
  * \details Complex number types consisting of 2 floating point values in big-
diff --git a/src/H5Tnative.c b/src/H5Tnative.c
index d02a577bc58..357c6b38e4b 100644
--- a/src/H5Tnative.c
+++ b/src/H5Tnative.c
@@ -28,7 +28,7 @@ static H5T_t *H5T__get_native_type(H5T_t *dt, H5T_direction_t direction, size_t
                                    size_t *comp_size);
 static H5T_t *H5T__get_native_integer(size_t prec, H5T_sign_t sign, H5T_direction_t direction,
                                       size_t *struct_align, size_t *offset, size_t *comp_size);
-static H5T_t *H5T__get_native_float(size_t size, H5T_direction_t direction, size_t *struct_align,
+static H5T_t *H5T__get_native_float(const H5T_t *dtype, H5T_direction_t direction, size_t *struct_align,
                                     size_t *offset, size_t *comp_size);
 static H5T_t *H5T__get_native_bitfield(size_t prec, H5T_direction_t direction, size_t *struct_align,
                                        size_t *offset, size_t *comp_size);
@@ -161,7 +161,8 @@ H5T__get_native_type(H5T_t *dtype, H5T_direction_t direction, size_t *struct_ali
         break;
 
         case H5T_FLOAT:
-            if (NULL == (ret_value = H5T__get_native_float(size, direction, struct_align, offset, comp_size)))
+            if (NULL ==
+                (ret_value = H5T__get_native_float(dtype, direction, struct_align, offset, comp_size)))
                 HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot retrieve float type");
 
             break;
@@ -706,11 +707,12 @@ done:
  *-------------------------------------------------------------------------
  */
 static H5T_t *
-H5T__get_native_float(size_t size, H5T_direction_t direction, size_t *struct_align, size_t *offset,
+H5T__get_native_float(const H5T_t *dtype, H5T_direction_t direction, size_t *struct_align, size_t *offset,
                       size_t *comp_size)
 {
     H5T_t *dt          = NULL; /* Appropriate native datatype to copy */
     hid_t  tid         = (-1); /* Datatype ID of appropriate native datatype */
+    size_t size        = 0;    /* Size of datatype to make native */
     size_t align       = 0;    /* Alignment necessary for native datatype */
     size_t native_size = 0;    /* Datatype size of the native type */
     enum match_type {          /* The different kinds of floating point types we can match */
@@ -724,18 +726,44 @@ H5T__get_native_float(size_t size, H5T_direction_t direction, size_t *struct_ali
 
     FUNC_ENTER_PACKAGE
 
-    assert(size > 0);
+    if (0 == (size = H5T_get_size(dtype)))
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a valid size");
 
     H5_WARN_DUPLICATED_BRANCHES_OFF
     if (direction == H5T_DIR_DEFAULT || direction == H5T_DIR_ASCEND) {
+        if (size <= 2) {
 #ifdef H5_HAVE__FLOAT16
-        if (size <= sizeof(H5__Float16)) {
-            match       = H5T_NATIVE_FLOAT_MATCH_FLOAT16;
-            native_size = sizeof(H5__Float16);
-        }
-        else
+            /*
+             * When _Float16 support is available, map _Float16-like types
+             * to the native type and all other types of this size group
+             * without a specific carve-out to the native float type.
+             */
+            H5T_t *f16_le_dt = NULL; /* Datatype for little-endian float16 */
+            H5T_t *f16_be_dt = NULL; /* Datatype for big-endian float16 */
+
+            if (NULL == (f16_le_dt = H5I_object(H5T_IEEE_F16LE)))
+                HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a data type");
+            if (NULL == (f16_be_dt = H5I_object(H5T_IEEE_F16BE)))
+                HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a data type");
+
+            if (0 == H5T_cmp(dtype, f16_le_dt, false) || 0 == H5T_cmp(dtype, f16_be_dt, false)) {
+                match       = H5T_NATIVE_FLOAT_MATCH_FLOAT16;
+                native_size = sizeof(H5__Float16);
+            }
+            else {
+                match       = H5T_NATIVE_FLOAT_MATCH_FLOAT;
+                native_size = sizeof(float);
+            }
+#else
+            /* When _Float16 support is not available, just map all types of
+             * this size group without a specific carve-out to the native
+             * float type.
+             */
+            match       = H5T_NATIVE_FLOAT_MATCH_FLOAT;
+            native_size = sizeof(float);
 #endif
-            if (size <= sizeof(float)) {
+        }
+        else if (size <= sizeof(float)) {
             match       = H5T_NATIVE_FLOAT_MATCH_FLOAT;
             native_size = sizeof(float);
         }
@@ -761,20 +789,44 @@ H5T__get_native_float(size_t size, H5T_direction_t direction, size_t *struct_ali
             match       = H5T_NATIVE_FLOAT_MATCH_DOUBLE;
             native_size = sizeof(double);
         }
-        else
+        else {
 #ifdef H5_HAVE__FLOAT16
-            if (size > sizeof(H5__Float16))
-#endif
-        {
+            if (size > sizeof(H5__Float16)) {
+                match       = H5T_NATIVE_FLOAT_MATCH_FLOAT;
+                native_size = sizeof(float);
+            }
+            else {
+                /*
+                 * When _Float16 support is available, map _Float16-like types
+                 * to the native type and all other types of this size group
+                 * without a specific carve-out to the native float type.
+                 */
+                H5T_t *f16_le_dt = NULL; /* Datatype for little-endian float16 */
+                H5T_t *f16_be_dt = NULL; /* Datatype for big-endian float16 */
+
+                if (NULL == (f16_le_dt = H5I_object(H5T_IEEE_F16LE)))
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a data type");
+                if (NULL == (f16_be_dt = H5I_object(H5T_IEEE_F16BE)))
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a data type");
+
+                if (0 == H5T_cmp(dtype, f16_le_dt, false) || 0 == H5T_cmp(dtype, f16_be_dt, false)) {
+                    match       = H5T_NATIVE_FLOAT_MATCH_FLOAT16;
+                    native_size = sizeof(H5__Float16);
+                }
+                else {
+                    match       = H5T_NATIVE_FLOAT_MATCH_FLOAT;
+                    native_size = sizeof(float);
+                }
+            }
+#else
+            /* When _Float16 support is not available, just map all types of
+             * this size group without a specific carve-out to the native
+             * float type.
+             */
             match       = H5T_NATIVE_FLOAT_MATCH_FLOAT;
             native_size = sizeof(float);
-        }
-#ifdef H5_HAVE__FLOAT16
-        else {
-            match       = H5T_NATIVE_FLOAT_MATCH_FLOAT16;
-            native_size = sizeof(H5__Float16);
-        }
 #endif
+        }
     }
     H5_WARN_DUPLICATED_BRANCHES_ON
 
diff --git a/src/H5Tpublic.h b/src/H5Tpublic.h
index 28670b4dfb3..38813229e92 100644
--- a/src/H5Tpublic.h
+++ b/src/H5Tpublic.h
@@ -280,17 +280,33 @@ H5_DLLVAR hid_t H5T_IEEE_F32LE_g;
 H5_DLLVAR hid_t H5T_IEEE_F64BE_g;
 H5_DLLVAR hid_t H5T_IEEE_F64LE_g;
 
+/*
+ * Alternative (non-IEEE) floating point types.
+ */
+/**
+ * \ingroup PDTALTFLOAT
+ * 16-bit big-endian bfloat16 floating-point numbers
+ */
+#define H5T_FLOAT_BFLOAT16BE (H5OPEN H5T_FLOAT_BFLOAT16BE_g)
+/**
+ * \ingroup PDTALTFLOAT
+ * 16-bit little-endian bfloat16 floating-point numbers
+ */
+#define H5T_FLOAT_BFLOAT16LE (H5OPEN H5T_FLOAT_BFLOAT16LE_g)
+H5_DLLVAR hid_t H5T_FLOAT_BFLOAT16BE_g;
+H5_DLLVAR hid_t H5T_FLOAT_BFLOAT16LE_g;
+
 /*
  * Complex number types made up of IEEE floating point types
  */
 /**
  * \ingroup PDTCOMPLEX
- * Complex number of 2 16-bit little-endian IEEE floating-point numbers
+ * Complex number of 2 16-bit big-endian IEEE floating-point numbers
  */
 #define H5T_COMPLEX_IEEE_F16BE (H5OPEN H5T_COMPLEX_IEEE_F16BE_g)
 /**
  * \ingroup PDTCOMPLEX
- * Complex number of 2 16-bit big-endian IEEE floating-point numbers
+ * Complex number of 2 16-bit little-endian IEEE floating-point numbers
  */
 #define H5T_COMPLEX_IEEE_F16LE (H5OPEN H5T_COMPLEX_IEEE_F16LE_g)
 /**
diff --git a/src/H5trace.c b/src/H5trace.c
index e23dcbd83ab..6b9a18cb305 100644
--- a/src/H5trace.c
+++ b/src/H5trace.c
@@ -1687,6 +1687,10 @@ H5_trace_args(H5RS_str_t *rs, const char *type, va_list ap)
                                     H5RS_acat(rs, "H5T_IEEE_F64BE");
                                 else if (obj == H5T_IEEE_F64LE_g)
                                     H5RS_acat(rs, "H5T_IEEE_F64LE");
+                                else if (obj == H5T_FLOAT_BFLOAT16BE_g)
+                                    H5RS_acat(rs, "H5T_FLOAT_BFLOAT16BE");
+                                else if (obj == H5T_FLOAT_BFLOAT16LE_g)
+                                    H5RS_acat(rs, "H5T_FLOAT_BFLOAT16LE");
                                 else if (obj == H5T_COMPLEX_IEEE_F16BE_g)
                                     H5RS_acat(rs, "H5T_COMPLEX_IEEE_F16BE");
                                 else if (obj == H5T_COMPLEX_IEEE_F16LE_g)
diff --git a/test/API/H5_api_dataset_test.c b/test/API/H5_api_dataset_test.c
index 633b759ef2b..6d9066d6e63 100644
--- a/test/API/H5_api_dataset_test.c
+++ b/test/API/H5_api_dataset_test.c
@@ -1217,8 +1217,9 @@ test_create_dataset_predefined_types(void H5_ATTR_UNUSED *params)
         H5T_STD_U32LE,          H5T_STD_U32BE,          H5T_STD_I32LE,          H5T_STD_I32BE,
         H5T_STD_U64LE,          H5T_STD_U64BE,          H5T_STD_I64LE,          H5T_STD_I64BE,
         H5T_IEEE_F16LE,         H5T_IEEE_F16BE,         H5T_IEEE_F32LE,         H5T_IEEE_F32BE,
-        H5T_IEEE_F64LE,         H5T_IEEE_F64BE,         H5T_COMPLEX_IEEE_F16BE, H5T_COMPLEX_IEEE_F16LE,
-        H5T_COMPLEX_IEEE_F32BE, H5T_COMPLEX_IEEE_F32LE, H5T_COMPLEX_IEEE_F64BE, H5T_COMPLEX_IEEE_F64LE};
+        H5T_IEEE_F64LE,         H5T_IEEE_F64BE,         H5T_FLOAT_BFLOAT16LE,   H5T_FLOAT_BFLOAT16BE,
+        H5T_COMPLEX_IEEE_F16BE, H5T_COMPLEX_IEEE_F16LE, H5T_COMPLEX_IEEE_F32BE, H5T_COMPLEX_IEEE_F32LE,
+        H5T_COMPLEX_IEEE_F64BE, H5T_COMPLEX_IEEE_F64LE};
 
     TESTING("dataset creation with predefined datatypes");
 
diff --git a/test/API/H5_api_test_util.c b/test/API/H5_api_test_util.c
index efb88c77100..49eaa39be5c 100644
--- a/test/API/H5_api_test_util.c
+++ b/test/API/H5_api_test_util.c
@@ -44,7 +44,7 @@
 
 /* The number of predefined floating point types in HDF5
  */
-#define NUM_PREDEFINED_FLOAT_TYPES 6
+#define NUM_PREDEFINED_FLOAT_TYPES 8
 
 /* The number of predefined complex number types in HDF5
  */
@@ -321,6 +321,12 @@ generate_random_datatype_float(H5T_class_t H5_ATTR_UNUSED parent_class, bool H5_
         case 5:
             type_to_copy = H5T_IEEE_F64LE;
             break;
+        case 6:
+            type_to_copy = H5T_FLOAT_BFLOAT16BE;
+            break;
+        case 7:
+            type_to_copy = H5T_FLOAT_BFLOAT16LE;
+            break;
 
         default:
             printf("    invalid value for floating point type; should not happen\n");
diff --git a/test/dt_arith.c b/test/dt_arith.c
index 16de6819170..10a85e39a16 100644
--- a/test/dt_arith.c
+++ b/test/dt_arith.c
@@ -2031,6 +2031,195 @@ error:
     return MAX((int)fails_this_test, 1);
 }
 
+/*-------------------------------------------------------------------------
+ * Function:    test_bfloat16
+ *
+ * Purpose:     Tests special values for bfloat16 datatypes
+ *
+ * Return:      Success:    0
+ *              Failure:    number of errors
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+test_bfloat16(void)
+{
+    const unsigned char *buf_ptr;
+    H5T_order_t          native_type_order;
+    uint16_t             bf16_val;
+    uint16_t             bf16_convval;
+    size_t               float_spos;
+    size_t               float_mpos;
+    size_t               float_epos;
+    size_t               float_msize;
+    size_t               float_esize;
+    hid_t                src_bf16_type;
+    float                val_buf;
+
+    TESTING("bfloat16 datatype special values");
+
+    buf_ptr = (const unsigned char *)&val_buf;
+
+    if ((native_type_order = H5Tget_order(H5T_NATIVE_FLOAT)) < 0) {
+        H5_FAILED();
+        printf("Can't check endian-ness of native float type\n");
+        goto error;
+    }
+
+    /* Just test on little- or big-endian systems */
+    if (native_type_order != H5T_ORDER_LE && native_type_order != H5T_ORDER_BE) {
+        SKIPPED();
+        return 0;
+    }
+
+    src_bf16_type = (native_type_order == H5T_ORDER_LE) ? H5T_FLOAT_BFLOAT16LE : H5T_FLOAT_BFLOAT16BE;
+
+    if (H5Tget_fields(H5T_NATIVE_FLOAT, &float_spos, &float_epos, &float_esize, &float_mpos, &float_msize) <
+        0) {
+        H5_FAILED();
+        printf("Can't get floating-point bit field information for native float type\n");
+        goto error;
+    }
+
+    /* Until native support for bfloat16 type is added, use uint16_t
+     * to represent initial value, then check properties after using
+     * H5T to convert to float
+     */
+
+    bf16_val = 0x7F80; /* +Inf */
+    memcpy(&val_buf, &bf16_val, 2);
+    if (H5Tconvert(src_bf16_type, H5T_NATIVE_FLOAT, 1, &val_buf, NULL, H5P_DEFAULT) < 0) {
+        H5_FAILED();
+        printf("Couldn't convert bfloat16 value to float\n");
+        goto error;
+    }
+
+    if (0 == my_isinf((int)native_type_order, buf_ptr, sizeof(float), float_mpos, float_msize, float_epos,
+                      float_esize)) {
+        H5_FAILED();
+        printf("bfloat16 positive infinity value wasn't infinity after conversion\n");
+        goto error;
+    }
+
+    if (1 == my_isnan(FLT_FLOAT, &val_buf)) {
+        H5_FAILED();
+        printf("bfloat16 positive infinity value matched NaN\n");
+        goto error;
+    }
+
+    /* Convert value back and check */
+    if (H5Tconvert(H5T_NATIVE_FLOAT, src_bf16_type, 1, &val_buf, NULL, H5P_DEFAULT) < 0) {
+        H5_FAILED();
+        printf("Couldn't convert float value to bfloat16\n");
+        goto error;
+    }
+
+    memcpy(&bf16_convval, &val_buf, 2);
+    if (0 != memcmp(&bf16_convval, &bf16_val, 2)) {
+        H5_FAILED();
+        printf("bfloat16 value wasn't preserved between conversions\n");
+        goto error;
+    }
+
+    bf16_val = 0xFF80; /* -Inf */
+    memcpy(&val_buf, &bf16_val, 2);
+    if (H5Tconvert(src_bf16_type, H5T_NATIVE_FLOAT, 1, &val_buf, NULL, H5P_DEFAULT) < 0) {
+        H5_FAILED();
+        printf("Couldn't convert bfloat16 value to float\n");
+        goto error;
+    }
+
+    if (0 == my_isinf((int)native_type_order, buf_ptr, sizeof(float), float_mpos, float_msize, float_epos,
+                      float_esize)) {
+        H5_FAILED();
+        printf("bfloat16 negative infinity value wasn't infinity after conversion\n");
+        goto error;
+    }
+
+    if (1 == my_isnan(FLT_FLOAT, &val_buf)) {
+        H5_FAILED();
+        printf("bfloat16 negative infinity value matched NaN\n");
+        goto error;
+    }
+
+    /* Convert value back and check */
+    if (H5Tconvert(H5T_NATIVE_FLOAT, src_bf16_type, 1, &val_buf, NULL, H5P_DEFAULT) < 0) {
+        H5_FAILED();
+        printf("Couldn't convert float value to bfloat16\n");
+        goto error;
+    }
+
+    memcpy(&bf16_convval, &val_buf, 2);
+    if (0 != memcmp(&bf16_convval, &bf16_val, 2)) {
+        H5_FAILED();
+        printf("bfloat16 value wasn't preserved between conversions\n");
+        goto error;
+    }
+
+    /*
+     * For NaN values, don't bother checking the value after converting
+     * back. The library sets all bits in the significand to 1 when a
+     * NaN is encountered, so the values won't match. Note that at least
+     * on x86 and ARM CPUs this should convert the NaNs into quiet NaNs.
+     * However, this may convert the NaNs to signaling NaNs on some CPUs
+     * which could be problematic if the buffer is used in almost any
+     * fashion. The my_isnan() function might attempt to print the value
+     * into a buffer to compare against NaN strings, which could cause
+     * a floating-point exception for some values. So far, this hasn't
+     * been an issue in practice, but may need some exception handling
+     * here if it becomes an issue.
+     */
+
+    bf16_val = 0xffc1; /* One of many qNaN values */
+    memcpy(&val_buf, &bf16_val, 2);
+    if (H5Tconvert(src_bf16_type, H5T_NATIVE_FLOAT, 1, &val_buf, NULL, H5P_DEFAULT) < 0) {
+        H5_FAILED();
+        printf("Couldn't convert bfloat16 value to float\n");
+        goto error;
+    }
+
+    if (1 == my_isinf((int)native_type_order, buf_ptr, sizeof(float), float_mpos, float_msize, float_epos,
+                      float_esize)) {
+        H5_FAILED();
+        printf("bfloat16 qNaN value was an infinity value after conversion\n");
+        goto error;
+    }
+
+    if (0 == my_isnan(FLT_FLOAT, &val_buf)) {
+        H5_FAILED();
+        printf("bfloat16 qNaN value wasn't a NaN value after conversion\n");
+        goto error;
+    }
+
+    bf16_val = 0xff81; /* One of many sNaN values */
+    memcpy(&val_buf, &bf16_val, 2);
+    if (H5Tconvert(src_bf16_type, H5T_NATIVE_FLOAT, 1, &val_buf, NULL, H5P_DEFAULT) < 0) {
+        H5_FAILED();
+        printf("Couldn't convert bfloat16 value to float\n");
+        goto error;
+    }
+
+    if (1 == my_isinf((int)native_type_order, buf_ptr, sizeof(float), float_mpos, float_msize, float_epos,
+                      float_esize)) {
+        H5_FAILED();
+        printf("bfloat16 sNaN value was an infinity value after conversion\n");
+        goto error;
+    }
+
+    if (0 == my_isnan(FLT_FLOAT, &val_buf)) {
+        H5_FAILED();
+        printf("bfloat16 sNaN value wasn't a NaN value after conversion\n");
+        goto error;
+    }
+
+    PASSED();
+
+    return 0;
+
+error:
+    return 1;
+}
+
 /*-------------------------------------------------------------------------
  * Function:    test_conv_int_1
  *
@@ -9985,6 +10174,9 @@ main(void)
      * for user-defined complex number types */
     nerrors += (unsigned long)test_derived_complex();
 
+    /* Test bfloat16 special values */
+    nerrors += (unsigned long)test_bfloat16();
+
     /* Test degenerate cases */
     nerrors += (unsigned long)run_fp_tests("noop");
 
diff --git a/test/dtypes.c b/test/dtypes.c
index 3863f492523..4b7468c6681 100644
--- a/test/dtypes.c
+++ b/test/dtypes.c
@@ -76,7 +76,7 @@
 
 static const char *FILENAME[] = {"dtypes0",  "dtypes1",  "dtypes2",  "dtypes3",  "dtypes4",  "dtypes5",
                                  "dtypes6",  "dtypes7",  "dtypes8",  "dtypes9",  "dtypes10", "dtypes11",
-                                 "dtypes12", "dtypes13", "dtypes14", "dtypes15", NULL};
+                                 "dtypes12", "dtypes13", "dtypes14", "dtypes15", "dtypes16", NULL};
 
 #define TESTFILE "bad_compound.h5"
 
@@ -6341,14 +6341,14 @@ test__Float16(void)
     const char *driver_name;
     hsize_t     dims[1];
     htri_t      is_little_endian;
-    H5T_t      *native_dtype = NULL;
-    H5T_t      *tmp_dtype    = NULL;
-    hid_t       fid          = H5I_INVALID_HID;
-    hid_t       space_id     = H5I_INVALID_HID;
-    hid_t       dset_id      = H5I_INVALID_HID;
-    hid_t       dcpl_id      = H5I_INVALID_HID;
-    hid_t       native_type  = H5I_INVALID_HID;
-    char        filename[256];
+    H5T_t      *native_dtype  = NULL;
+    H5T_t      *tmp_dtype     = NULL;
+    hid_t       fid           = H5I_INVALID_HID;
+    hid_t       space_id      = H5I_INVALID_HID;
+    hid_t       dset_id       = H5I_INVALID_HID;
+    hid_t       dcpl_id       = H5I_INVALID_HID;
+    hid_t       native_type   = H5I_INVALID_HID;
+    char        filename[256] = {0};
 
     TESTING("_Float16 datatype");
 
@@ -6731,6 +6731,7 @@ error:
         H5Sclose(space_id);
         H5Dclose(dset_id);
         H5Fclose(fid);
+        H5Fdelete(filename, H5P_DEFAULT);
     }
     H5E_END_TRY
 
@@ -6756,6 +6757,415 @@ error:
 #endif
 }
 
+/*-------------------------------------------------------------------------
+ * Function:    test_bfloat16
+ *
+ * Purpose:     Tests the bfloat16 datatypes.
+ *
+ * Return:      Success:    0
+ *              Failure:    number of errors
+ *-------------------------------------------------------------------------
+ */
+static int
+test_bfloat16(void)
+{
+    H5T_class_t type_class;
+    H5T_order_t type_order;
+    H5T_norm_t  type_norm;
+    H5T_pad_t   lsb_pad;
+    H5T_pad_t   msb_pad;
+    H5T_pad_t   inpad;
+    hsize_t     dims[1];
+    size_t      type_size;
+    size_t      type_prec;
+    size_t      sign_pos;
+    size_t      expo_pos;
+    size_t      mant_pos;
+    size_t      expo_size;
+    size_t      mant_size;
+    size_t      expo_bias;
+    hid_t       fid           = H5I_INVALID_HID;
+    hid_t       space_id      = H5I_INVALID_HID;
+    hid_t       dset_id       = H5I_INVALID_HID;
+    hid_t       dcpl_id       = H5I_INVALID_HID;
+    char        filename[256] = {0};
+    int         type_offset;
+
+    TESTING("bfloat16 datatypes");
+
+    /* Check characteristics of the predefined types */
+
+    if ((type_class = H5Tget_class(H5T_FLOAT_BFLOAT16LE)) < 0) {
+        H5_FAILED();
+        printf("Couldn't get datatype class for H5T_FLOAT_BFLOAT16LE\n");
+        goto error;
+    }
+
+    if (H5T_FLOAT != type_class) {
+        H5_FAILED();
+        printf("Datatype class for H5T_FLOAT_BFLOAT16LE wasn't H5T_FLOAT\n");
+        goto error;
+    }
+
+    if ((type_class = H5Tget_class(H5T_FLOAT_BFLOAT16BE)) < 0) {
+        H5_FAILED();
+        printf("Couldn't get datatype class for H5T_FLOAT_BFLOAT16BE\n");
+        goto error;
+    }
+
+    if (H5T_FLOAT != type_class) {
+        H5_FAILED();
+        printf("Datatype class for H5T_FLOAT_BFLOAT16BE wasn't H5T_FLOAT\n");
+        goto error;
+    }
+
+    if ((type_size = H5Tget_size(H5T_FLOAT_BFLOAT16LE)) == 0) {
+        H5_FAILED();
+        printf("Couldn't get datatype size for H5T_FLOAT_BFLOAT16LE\n");
+        goto error;
+    }
+
+    if (type_size != 2) {
+        H5_FAILED();
+        printf("Datatype size for H5T_FLOAT_BFLOAT16LE was incorrect (expected 2, got %zu)\n", type_size);
+        goto error;
+    }
+
+    if ((type_size = H5Tget_size(H5T_FLOAT_BFLOAT16BE)) == 0) {
+        H5_FAILED();
+        printf("Couldn't get datatype size for H5T_FLOAT_BFLOAT16BE\n");
+        goto error;
+    }
+
+    if (type_size != 2) {
+        H5_FAILED();
+        printf("Datatype size for H5T_FLOAT_BFLOAT16BE was incorrect (expected 2, got %zu)\n", type_size);
+        goto error;
+    }
+
+    if ((type_order = H5Tget_order(H5T_FLOAT_BFLOAT16LE)) < 0) {
+        H5_FAILED();
+        printf("Couldn't get datatype order for H5T_FLOAT_BFLOAT16LE\n");
+        goto error;
+    }
+
+    if (type_order != H5T_ORDER_LE) {
+        H5_FAILED();
+        printf("Datatype order for H5T_FLOAT_BFLOAT16LE wasn't H5T_ORDER_LE\n");
+        goto error;
+    }
+
+    if ((type_order = H5Tget_order(H5T_FLOAT_BFLOAT16BE)) < 0) {
+        H5_FAILED();
+        printf("Couldn't get datatype order for H5T_FLOAT_BFLOAT16BE\n");
+        goto error;
+    }
+
+    if (type_order != H5T_ORDER_BE) {
+        H5_FAILED();
+        printf("Datatype order for H5T_FLOAT_BFLOAT16BE wasn't H5T_ORDER_BE\n");
+        goto error;
+    }
+
+    if ((type_prec = H5Tget_precision(H5T_FLOAT_BFLOAT16LE)) == 0) {
+        H5_FAILED();
+        printf("Couldn't get datatype precision for H5T_FLOAT_BFLOAT16LE\n");
+        goto error;
+    }
+
+    if (type_prec != 16) {
+        H5_FAILED();
+        printf("Datatype precision for H5T_FLOAT_BFLOAT16LE was incorrect (expected 16, got %zu)\n",
+               type_prec);
+        goto error;
+    }
+
+    if ((type_prec = H5Tget_precision(H5T_FLOAT_BFLOAT16BE)) == 0) {
+        H5_FAILED();
+        printf("Couldn't get datatype precision for H5T_FLOAT_BFLOAT16BE\n");
+        goto error;
+    }
+
+    if (type_prec != 16) {
+        H5_FAILED();
+        printf("Datatype precision for H5T_FLOAT_BFLOAT16BE was incorrect (expected 16, got %zu)\n",
+               type_prec);
+        goto error;
+    }
+
+    if ((type_offset = H5Tget_offset(H5T_FLOAT_BFLOAT16LE)) < 0) {
+        H5_FAILED();
+        printf("Couldn't get datatype offset for H5T_FLOAT_BFLOAT16LE\n");
+        goto error;
+    }
+
+    if (type_offset != 0) {
+        H5_FAILED();
+        printf("Datatype offset for H5T_FLOAT_BFLOAT16LE was incorrect (expected 0, got %d)\n", type_offset);
+        goto error;
+    }
+
+    if ((type_offset = H5Tget_offset(H5T_FLOAT_BFLOAT16BE)) < 0) {
+        H5_FAILED();
+        printf("Couldn't get datatype offset for H5T_FLOAT_BFLOAT16BE\n");
+        goto error;
+    }
+
+    if (type_offset != 0) {
+        H5_FAILED();
+        printf("Datatype offset for H5T_FLOAT_BFLOAT16BE was incorrect (expected 0, got %d)\n", type_offset);
+        goto error;
+    }
+
+    if (H5Tget_pad(H5T_FLOAT_BFLOAT16LE, &lsb_pad, &msb_pad) < 0) {
+        H5_FAILED();
+        printf("Couldn't get datatype padding type for H5T_FLOAT_BFLOAT16LE\n");
+        goto error;
+    }
+
+    if (lsb_pad != H5T_PAD_ZERO || msb_pad != H5T_PAD_ZERO) {
+        H5_FAILED();
+        printf("Datatype padding type for H5T_FLOAT_BFLOAT16LE was incorrect (expected H5T_PAD_ZERO, got lsb "
+               "pad "
+               "type %d, msb pad type %d)\n",
+               lsb_pad, msb_pad);
+        goto error;
+    }
+
+    if (H5Tget_pad(H5T_FLOAT_BFLOAT16BE, &lsb_pad, &msb_pad) < 0) {
+        H5_FAILED();
+        printf("Couldn't get datatype padding type for H5T_FLOAT_BFLOAT16BE\n");
+        goto error;
+    }
+
+    if (lsb_pad != H5T_PAD_ZERO || msb_pad != H5T_PAD_ZERO) {
+        H5_FAILED();
+        printf("Datatype padding type for H5T_FLOAT_BFLOAT16BE was incorrect (expected H5T_PAD_ZERO, got lsb "
+               "pad "
+               "type %d, msb pad type %d)\n",
+               lsb_pad, msb_pad);
+        goto error;
+    }
+
+    if (H5Tget_fields(H5T_FLOAT_BFLOAT16LE, &sign_pos, &expo_pos, &expo_size, &mant_pos, &mant_size) < 0) {
+        H5_FAILED();
+        printf("Couldn't get floating-point bit field information for H5T_FLOAT_BFLOAT16LE\n");
+        goto error;
+    }
+
+    if (sign_pos != 15 || expo_pos != 7 || mant_pos != 0 || expo_size != 8 || mant_size != 7) {
+        H5_FAILED();
+        printf("H5T_FLOAT_BFLOAT16LE didn't match bfloat16 specification "
+               "(expected spos=15, epos=7, esize=8, mpos=0, msize=7, "
+               "got spos=%zu, epos=%zu, esize=%zu, mpos=%zu, msize=%zu",
+               sign_pos, expo_pos, expo_size, mant_pos, mant_size);
+        goto error;
+    }
+
+    if (H5Tget_fields(H5T_FLOAT_BFLOAT16BE, &sign_pos, &expo_pos, &expo_size, &mant_pos, &mant_size) < 0) {
+        H5_FAILED();
+        printf("Couldn't get floating-point bit field information for H5T_FLOAT_BFLOAT16BE\n");
+        goto error;
+    }
+
+    if (sign_pos != 15 || expo_pos != 7 || mant_pos != 0 || expo_size != 8 || mant_size != 7) {
+        H5_FAILED();
+        printf("H5T_FLOAT_BFLOAT16BE didn't match bfloat16 specification "
+               "(expected spos=15, epos=7, esize=8, mpos=0, msize=7, "
+               "got spos=%zu, epos=%zu, esize=%zu, mpos=%zu, msize=%zu",
+               sign_pos, expo_pos, expo_size, mant_pos, mant_size);
+        goto error;
+    }
+
+    if ((expo_bias = H5Tget_ebias(H5T_FLOAT_BFLOAT16LE)) == 0) {
+        H5_FAILED();
+        printf("Couldn't get datatype exponent bias for H5T_FLOAT_BFLOAT16LE\n");
+        goto error;
+    }
+
+    if (expo_bias != 127) {
+        H5_FAILED();
+        printf("Datatype exponent bias for H5T_FLOAT_BFLOAT16LE was incorrect (expected 127, got %zu)\n",
+               expo_bias);
+        goto error;
+    }
+
+    if ((expo_bias = H5Tget_ebias(H5T_FLOAT_BFLOAT16BE)) == 0) {
+        H5_FAILED();
+        printf("Couldn't get datatype exponent bias for H5T_FLOAT_BFLOAT16BE\n");
+        goto error;
+    }
+
+    if (expo_bias != 127) {
+        H5_FAILED();
+        printf("Datatype exponent bias for H5T_FLOAT_BFLOAT16BE was incorrect (expected 127, got %zu)\n",
+               expo_bias);
+        goto error;
+    }
+
+    if ((type_norm = H5Tget_norm(H5T_FLOAT_BFLOAT16LE)) < 0) {
+        H5_FAILED();
+        printf("Couldn't get datatype mantissa normalization type for H5T_FLOAT_BFLOAT16LE\n");
+        goto error;
+    }
+
+    if (type_norm != H5T_NORM_IMPLIED) {
+        H5_FAILED();
+        printf("Datatype mantissa normalization type for H5T_FLOAT_BFLOAT16LE wasn't H5T_NORM_IMPLIED\n");
+        goto error;
+    }
+
+    if ((type_norm = H5Tget_norm(H5T_FLOAT_BFLOAT16BE)) < 0) {
+        H5_FAILED();
+        printf("Couldn't get datatype mantissa normalization type for H5T_FLOAT_BFLOAT16BE\n");
+        goto error;
+    }
+
+    if (type_norm != H5T_NORM_IMPLIED) {
+        H5_FAILED();
+        printf("Datatype mantissa normalization type for H5T_FLOAT_BFLOAT16BE wasn't H5T_NORM_IMPLIED\n");
+        goto error;
+    }
+
+    if ((inpad = H5Tget_inpad(H5T_FLOAT_BFLOAT16LE)) < 0) {
+        H5_FAILED();
+        printf("Couldn't get datatype unused bits padding type for H5T_FLOAT_BFLOAT16LE\n");
+        goto error;
+    }
+
+    if (inpad != H5T_PAD_ZERO) {
+        H5_FAILED();
+        printf("Datatype unused bits padding type for H5T_FLOAT_BFLOAT16LE was incorrect (expected "
+               "H5T_PAD_ZERO, "
+               "got pad type %d)\n",
+               inpad);
+        goto error;
+    }
+
+    if ((inpad = H5Tget_inpad(H5T_FLOAT_BFLOAT16BE)) < 0) {
+        H5_FAILED();
+        printf("Couldn't get datatype unused bits padding type for H5T_FLOAT_BFLOAT16BE\n");
+        goto error;
+    }
+
+    if (inpad != H5T_PAD_ZERO) {
+        H5_FAILED();
+        printf("Datatype unused bits padding type for H5T_FLOAT_BFLOAT16BE was incorrect (expected "
+               "H5T_PAD_ZERO, "
+               "got pad type %d)\n",
+               inpad);
+        goto error;
+    }
+
+    /*
+     * Ensure that some random conversions on the bfloat16 datatypes
+     * are currently covered by general software routines rather
+     * than compiler conversions.
+     */
+
+    if (H5Tcompiler_conv(H5T_FLOAT_BFLOAT16LE, H5T_IEEE_F32LE) != false) {
+        H5_FAILED();
+        printf("Conversion path for H5T_FLOAT_BFLOAT16LE -> H5T_IEEE_F32LE was not a software conversion\n");
+        goto error;
+    }
+
+    if (H5Tcompiler_conv(H5T_FLOAT_BFLOAT16LE, H5T_NATIVE_INT) != false) {
+        H5_FAILED();
+        printf("Conversion path for H5T_FLOAT_BFLOAT16LE -> H5T_NATIVE_INT was not a software conversion\n");
+        goto error;
+    }
+
+    if (H5Tcompiler_conv(H5T_FLOAT_BFLOAT16BE, H5T_IEEE_F64BE) != false) {
+        H5_FAILED();
+        printf("Conversion path for H5T_FLOAT_BFLOAT16BE -> H5T_IEEE_F64BE was not a software conversion\n");
+        goto error;
+    }
+
+    if (H5Tcompiler_conv(H5T_FLOAT_BFLOAT16BE, H5T_STD_I64LE) != false) {
+        H5_FAILED();
+        printf("Conversion path for H5T_FLOAT_BFLOAT16BE -> H5T_STD_I64LE was not a software conversion\n");
+        goto error;
+    }
+
+    /*
+     * Create a dataset with the little-endian bfloat16 datatype and
+     * check the dataset raw data storage size
+     */
+    h5_fixname(FILENAME[16], H5P_DEFAULT, filename, sizeof filename);
+
+    if ((fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0) {
+        H5_FAILED();
+        AT();
+        printf("Can't create file!\n");
+        goto error;
+    }
+
+    dims[0] = 10000;
+    if ((space_id = H5Screate_simple(1, dims, NULL)) < 0) {
+        H5_FAILED();
+        AT();
+        printf("Can't create dataspace\n");
+        goto error;
+    }
+
+    if ((dcpl_id = H5Pcreate(H5P_DATASET_CREATE)) < 0) {
+        H5_FAILED();
+        AT();
+        printf("Can't create DCPL\n");
+        goto error;
+    }
+
+    if (H5Pset_alloc_time(dcpl_id, H5D_ALLOC_TIME_EARLY) < 0) {
+        H5_FAILED();
+        AT();
+        printf("Can't set alloc time\n");
+        goto error;
+    }
+
+    if ((dset_id = H5Dcreate2(fid, "Dataset", H5T_FLOAT_BFLOAT16LE, space_id, H5P_DEFAULT, dcpl_id,
+                              H5P_DEFAULT)) < 0) {
+        H5_FAILED();
+        AT();
+        printf("Can't create dataset\n");
+        goto error;
+    }
+
+    if (H5Dget_storage_size(dset_id) != dims[0] * 2 /* 2 byte datatype */) {
+        H5_FAILED();
+        AT();
+        printf("Incorrect dataset raw data storage size allocated in file\n");
+        goto error;
+    }
+
+    if (H5Pclose(dcpl_id) < 0)
+        TEST_ERROR;
+    if (H5Sclose(space_id) < 0)
+        TEST_ERROR;
+    if (H5Dclose(dset_id) < 0)
+        TEST_ERROR;
+    if (H5Fclose(fid) < 0)
+        TEST_ERROR;
+    if (H5Fdelete(filename, H5P_DEFAULT) < 0)
+        TEST_ERROR;
+
+    PASSED();
+
+    return 0;
+
+error:
+    H5E_BEGIN_TRY
+    {
+        H5Pclose(dcpl_id);
+        H5Sclose(space_id);
+        H5Dclose(dset_id);
+        H5Fclose(fid);
+        H5Fdelete(filename, H5P_DEFAULT);
+    }
+    H5E_END_TRY
+
+    return 1;
+}
+
 /*-------------------------------------------------------------------------
  * Function:    test_complex_type
  *
@@ -12951,6 +13361,7 @@ main(void)
     nerrors += test_set_size_invalid();
 
     nerrors += test__Float16();
+    nerrors += test_bfloat16();
     nerrors += test_complex_type();
 #ifdef H5_HAVE_COMPLEX_NUMBERS
     nerrors += test_complex_type_conv_funcs();
diff --git a/test/ntypes.c b/test/ntypes.c
index bfad2322487..bfe6c307e9f 100644
--- a/test/ntypes.c
+++ b/test/ntypes.c
@@ -3171,6 +3171,48 @@ error:
 }
 #endif
 
+static herr_t
+test_bfloat16(void)
+{
+    hid_t native_type = H5I_INVALID_HID;
+
+    TESTING("bfloat16 datatype");
+
+    /*
+     * Just ensure that the bfloat16 type is currently promoted
+     * to float. Until native support is added for a bfloat16
+     * type, conversion from bfloat16 to float should be easy.
+     */
+    if ((native_type = H5Tget_native_type(H5T_FLOAT_BFLOAT16LE, H5T_DIR_ASCEND)) < 0)
+        TEST_ERROR;
+    if (true != H5Tequal(native_type, H5T_NATIVE_FLOAT))
+        TEST_ERROR;
+
+    if (H5Tclose(native_type) < 0)
+        TEST_ERROR;
+
+    if ((native_type = H5Tget_native_type(H5T_FLOAT_BFLOAT16LE, H5T_DIR_DESCEND)) < 0)
+        TEST_ERROR;
+    if (true != H5Tequal(native_type, H5T_NATIVE_FLOAT))
+        TEST_ERROR;
+
+    if (H5Tclose(native_type) < 0)
+        TEST_ERROR;
+
+    PASSED();
+
+    return 0;
+
+error:
+    H5E_BEGIN_TRY
+    {
+        H5Tclose(native_type);
+    }
+    H5E_END_TRY
+
+    return -1;
+}
+
 #ifdef H5_HAVE_COMPLEX_NUMBERS
 static herr_t
 test_complex(hid_t file)
@@ -3349,6 +3391,8 @@ main(void)
     nerrors += test__Float16(file) < 0 ? 1 : 0;
 #endif
 
+    nerrors += test_bfloat16() < 0 ? 1 : 0;
+
 #ifdef H5_HAVE_COMPLEX_NUMBERS
     nerrors += test_complex(file) < 0 ? 1 : 0;
 #endif
diff --git a/tools/lib/h5diff_util.c b/tools/lib/h5diff_util.c
index 5c61de050d4..a71e662dcd1 100644
--- a/tools/lib/h5diff_util.c
+++ b/tools/lib/h5diff_util.c
@@ -132,6 +132,10 @@ print_type(hid_t type)
                 parallel_print("H5T_IEEE_F64BE");
             else if (H5Tequal(type, H5T_IEEE_F64LE))
                 parallel_print("H5T_IEEE_F64LE");
+            else if (H5Tequal(type, H5T_FLOAT_BFLOAT16BE))
+                parallel_print("H5T_FLOAT_BFLOAT16BE");
+            else if (H5Tequal(type, H5T_FLOAT_BFLOAT16LE))
+                parallel_print("H5T_FLOAT_BFLOAT16LE");
 #ifdef H5_HAVE__FLOAT16
             else if (H5Tequal(type, H5T_NATIVE_FLOAT16))
                 parallel_print("H5T_NATIVE_FLOAT16");
diff --git a/tools/lib/h5tools_dump.c b/tools/lib/h5tools_dump.c
index fe3e17b55d4..0871b8e3bf4 100644
--- a/tools/lib/h5tools_dump.c
+++ b/tools/lib/h5tools_dump.c
@@ -2208,6 +2208,10 @@ h5tools_print_datatype(FILE *stream, h5tools_str_t *buffer, const h5tool_format_
                 h5tools_str_append(buffer, "H5T_IEEE_F64BE");
             else if (H5Tequal(type, H5T_IEEE_F64LE) == true)
                 h5tools_str_append(buffer, "H5T_IEEE_F64LE");
+            else if (H5Tequal(type, H5T_FLOAT_BFLOAT16BE) == true)
+                h5tools_str_append(buffer, "H5T_FLOAT_BFLOAT16BE");
+            else if (H5Tequal(type, H5T_FLOAT_BFLOAT16LE) == true)
+                h5tools_str_append(buffer, "H5T_FLOAT_BFLOAT16LE");
             else if (H5Tequal(type, H5T_VAX_F32) == true)
                 h5tools_str_append(buffer, "H5T_VAX_F32");
             else if (H5Tequal(type, H5T_VAX_F64) == true)
diff --git a/tools/lib/h5tools_type.c b/tools/lib/h5tools_type.c
index 3a608da3e76..e8db7e9b0d1 100644
--- a/tools/lib/h5tools_type.c
+++ b/tools/lib/h5tools_type.c
@@ -55,8 +55,13 @@ h5tools_get_little_endian_type(hid_t tid)
             break;
 
         case H5T_FLOAT:
-            if (size == 2)
-                p_type = H5Tcopy(H5T_IEEE_F16LE);
+            if (size == 2) {
+                if (true == H5Tequal(tid, H5T_IEEE_F16LE) || true == H5Tequal(tid, H5T_IEEE_F16BE))
+                    p_type = H5Tcopy(H5T_IEEE_F16LE);
+                else if (true == H5Tequal(tid, H5T_FLOAT_BFLOAT16LE) ||
+                         true == H5Tequal(tid, H5T_FLOAT_BFLOAT16BE))
+                    p_type = H5Tcopy(H5T_FLOAT_BFLOAT16LE);
+            }
             else if (size == 4)
                 p_type = H5Tcopy(H5T_IEEE_F32LE);
             else if (size == 8)
@@ -145,8 +150,13 @@ h5tools_get_big_endian_type(hid_t tid)
             break;
 
         case H5T_FLOAT:
-            if (size == 2)
-                p_type = H5Tcopy(H5T_IEEE_F16BE);
+            if (size == 2) {
+                if (true == H5Tequal(tid, H5T_IEEE_F16LE) || true == H5Tequal(tid, H5T_IEEE_F16BE))
+                    p_type = H5Tcopy(H5T_IEEE_F16BE);
+                else if (true == H5Tequal(tid, H5T_FLOAT_BFLOAT16LE) ||
+                         true == H5Tequal(tid, H5T_FLOAT_BFLOAT16BE))
+                    p_type = H5Tcopy(H5T_FLOAT_BFLOAT16BE);
+            }
             else if (size == 4)
                 p_type = H5Tcopy(H5T_IEEE_F32BE);
             else if (size == 8)
diff --git a/tools/src/h5import/h5import.c b/tools/src/h5import/h5import.c
index d5eaaba4d86..c148aee9030 100644
--- a/tools/src/h5import/h5import.c
+++ b/tools/src/h5import/h5import.c
@@ -2436,9 +2436,13 @@ validateConfigurationParameters(struct Input *in)
         "Cannot specify chunking or compression or extendible data sets with the external file option.\n";
     const char *err3 =
         "Cannot specify the compression or the extendible data sets without the chunking option.\n";
-    const char *err4a = "OUTPUT-ARCHITECTURE cannot be STD if OUTPUT-CLASS is floating point (FP).\n";
-    const char *err4b = "OUTPUT-ARCHITECTURE cannot be IEEE if OUTPUT-CLASS is integer (IN).\n";
-    const char *err5  = "For OUTPUT-CLASS FP, valid values for OUTPUT-SIZE are (32, 64) .\n";
+    const char *err4a      = "OUTPUT-ARCHITECTURE cannot be STD if OUTPUT-CLASS is floating point (FP).\n";
+    const char *err4b      = "OUTPUT-ARCHITECTURE cannot be IEEE if OUTPUT-CLASS is integer (IN).\n";
+    const char *err5       = "For OUTPUT-CLASS FP, valid values for OUTPUT-SIZE are (32, 64) .\n";
+    const char *err6       = "Cannot get OUTPUT-ARCHITECTUREs for validation.\n";
+    int         std_index  = -1;
+    int         ieee_index = -1;
+    int         flt_index  = -1;
 
     /* for class STR other parameters are ignored */
     if (in->inputClass == 5) /* STR */
@@ -2464,15 +2468,24 @@ validateConfigurationParameters(struct Input *in)
         }
     }
 
+    /* Obtain index values for type arch to be checked */
+    std_index  = OutputArchStrToInt("STD");
+    ieee_index = OutputArchStrToInt("IEEE");
+    flt_index  = OutputArchStrToInt("FLOAT");
+    if (std_index == -1 || ieee_index == -1 || flt_index == -1) {
+        (void)fprintf(stderr, "%s", err6);
+        return -1;
+    }
+
     /* Arch can't be STD if O/p class is FP */
-    if (in->outputArchitecture == 1)
+    if (in->outputArchitecture == std_index)
         if (in->outputClass == 1) {
             (void)fprintf(rawerrorstream, "%s", err4a);
             return (-1);
         }
 
-    /* Arch can't be IEEE if O/p class is IN */
-    if (in->outputArchitecture == 2)
+    /* Arch can't be IEEE or FLOAT if O/p class is IN */
+    if (in->outputArchitecture == ieee_index || in->outputArchitecture == flt_index)
         if (in->outputClass == 0) {
             (void)fprintf(rawerrorstream, "%s", err4b);
             return (-1);
@@ -3228,6 +3241,48 @@ getInputClassType(struct Input *in, char *buffer)
 
         kindex = 3;
     }
+    else if (!strcmp(buffer, "H5T_FLOAT_BFLOAT16BE")) {
+        in->inputSize                      = 16;
+        in->configOptionVector[INPUT_SIZE] = 1;
+
+        if ((kindex = OutputArchStrToInt("FLOAT")) == -1) {
+            (void)fprintf(stderr, "%s", err2);
+            return (-1);
+        }
+        in->outputArchitecture = kindex;
+
+        if ((kindex = OutputByteOrderStrToInt("BE")) == -1) {
+            (void)fprintf(stderr, "%s", err3);
+            return (-1);
+        }
+        in->outputByteOrder = kindex;
+#ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+#endif
+
+        kindex = 3;
+    }
+    else if (!strcmp(buffer, "H5T_FLOAT_BFLOAT16LE")) {
+        in->inputSize                      = 16;
+        in->configOptionVector[INPUT_SIZE] = 1;
+
+        if ((kindex = OutputArchStrToInt("FLOAT")) == -1) {
+            (void)fprintf(stderr, "%s", err2);
+            return (-1);
+        }
+        in->outputArchitecture = kindex;
+
+        if ((kindex = OutputByteOrderStrToInt("LE")) == -1) {
+            (void)fprintf(stderr, "%s", err3);
+            return (-1);
+        }
+        in->outputByteOrder = kindex;
+#ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+#endif
+
+        kindex = 3;
+    }
     else if (!strcmp(buffer, "H5T_VAX_F32")) {
         in->inputSize                      = 32;
         in->configOptionVector[INPUT_SIZE] = 1;
@@ -3690,8 +3745,9 @@ static int
 OutputArchStrToInt(const char *temp)
 {
     int  i;
-    char outputArchKeywordTable[8][15] = {"NATIVE", "STD", "IEEE", "INTEL", "CRAY", "MIPS", "ALPHA", "UNIX"};
-    for (i = 0; i < 8; i++)
+    char outputArchKeywordTable[9][15] = {"NATIVE", "STD",   "IEEE", "INTEL", "CRAY",
+                                          "MIPS",   "ALPHA", "UNIX", "FLOAT"};
+    for (i = 0; i < 9; i++)
         if (!strcmp(outputArchKeywordTable[i], temp))
             return i;
     return -1;
@@ -4082,6 +4138,31 @@ createOutputDataType(struct Input *in)
                     }
                     break;
 
+                case 8:
+                    switch (in->outputSize) {
+                        case 16:
+                            switch (in->outputByteOrder) {
+                                case -1:
+                                case 0:
+                                    new_type = H5Tcopy(H5T_FLOAT_BFLOAT16BE);
+                                    break;
+
+                                case 1:
+                                    new_type = H5Tcopy(H5T_FLOAT_BFLOAT16LE);
+                                    break;
+
+                                default:
+                                    (void)fprintf(stderr, "%s", err3);
+                                    return (-1);
+                            }
+                            break;
+
+                        default:
+                            (void)fprintf(stderr, "%s", err2);
+                            return (-1);
+                    }
+                    break;
+
                 default:
                     (void)fprintf(rawerrorstream, "%s", err4);
                     return (-1);
@@ -4460,6 +4541,31 @@ createInputDataType(struct Input *in)
                         }
                         break;
 
+                    case 8:
+                        switch (in->inputSize) {
+                            case 16:
+                                switch (in->inputByteOrder) {
+                                    case -1:
+                                    case 0:
+                                        new_type = H5Tcopy(H5T_FLOAT_BFLOAT16BE);
+                                        break;
+
+                                    case 1:
+                                        new_type = H5Tcopy(H5T_FLOAT_BFLOAT16LE);
+                                        break;
+
+                                    default:
+                                        (void)fprintf(stderr, "%s", err3);
+                                        return (-1);
+                                }
+                                break;
+
+                            default:
+                                (void)fprintf(stderr, "%s", err2);
+                                return (-1);
+                        }
+                        break;
+
                     default:
                         (void)fprintf(rawerrorstream, "%s", err4);
                         return (-1);
diff --git a/tools/src/h5ls/h5ls.c b/tools/src/h5ls/h5ls.c
index d5973ab2af9..15c5ef55ae9 100644
--- a/tools/src/h5ls/h5ls.c
+++ b/tools/src/h5ls/h5ls.c
@@ -569,16 +569,17 @@ print_native_type(h5tools_str_t *buffer, hid_t type, int ind)
 }
 
 /*-------------------------------------------------------------------------
- * Function:    print_ieee_type
+ * Function:    print_specific_float_type
  *
- * Purpose:     Print the name of an IEEE floating-point data type.
+ * Purpose:     Print the name of an IEEE or alternative floating-point
+ *              data type.
  *
  * Return:      Success: true
  *              Failure: false, nothing printed
  *-------------------------------------------------------------------------
  */
 static bool
-print_ieee_type(h5tools_str_t *buffer, hid_t type, int ind)
+print_specific_float_type(h5tools_str_t *buffer, hid_t type, int ind)
 {
     if (H5Tequal(type, H5T_IEEE_F16BE) == true) {
         h5tools_str_append(buffer, "IEEE 16-bit big-endian float");
@@ -598,6 +599,12 @@ print_ieee_type(h5tools_str_t *buffer, hid_t type, int ind)
     else if (H5Tequal(type, H5T_IEEE_F64LE) == true) {
         h5tools_str_append(buffer, "IEEE 64-bit little-endian float");
     }
+    else if (H5Tequal(type, H5T_FLOAT_BFLOAT16BE) == true) {
+        h5tools_str_append(buffer, "bfloat16 16-bit big-endian float");
+    }
+    else if (H5Tequal(type, H5T_FLOAT_BFLOAT16LE) == true) {
+        h5tools_str_append(buffer, "bfloat16 16-bit little-endian float");
+    }
     else {
         return print_float_type(buffer, type, ind);
     }
@@ -1342,7 +1349,7 @@ print_type(h5tools_str_t *buffer, hid_t type, int ind)
     } /* end if */
 
     /* Print the type */
-    if (print_native_type(buffer, type, ind) || print_ieee_type(buffer, type, ind) ||
+    if (print_native_type(buffer, type, ind) || print_specific_float_type(buffer, type, ind) ||
         print_complex_type(buffer, type, ind) || print_cmpd_type(buffer, type, ind) ||
         print_enum_type(buffer, type, ind) || print_string_type(buffer, type, ind) ||
         print_reference_type(buffer, type, ind) || print_vlen_type(buffer, type, ind) ||
diff --git a/tools/test/h5dump/CMakeTests.cmake b/tools/test/h5dump/CMakeTests.cmake
index b79528d2b45..fad5da0c947 100644
--- a/tools/test/h5dump/CMakeTests.cmake
+++ b/tools/test/h5dump/CMakeTests.cmake
@@ -58,6 +58,8 @@ set (HDF5_REFERENCE_FILES
     tattrintsize.ddl
     tattrreg.ddl
     tattrregR.ddl
+    tbfloat16.ddl
+    tbfloat16_be.ddl
     tbin1.ddl
     tbin1.ddl
     tbin2.ddl
@@ -264,6 +266,8 @@ set (HDF5_REFERENCE_TEST_FILES
     tattr4_be.h5
     tattrintsize.h5
     tattrreg.h5
+    tbfloat16.h5
+    tbfloat16_be.h5
     tbigdims.h5
     tbinary.h5
     tbitnopaque.h5
@@ -1157,6 +1161,10 @@ ADD_H5_TEST (tldouble_scalar RESULT_CODE 0 -p --enable-error-stack TARGET_FILE t
 ADD_H5_TEST (tfloat16 RESULT_CODE 0 --enable-error-stack TARGET_FILE tfloat16.h5)
 ADD_H5_TEST (tfloat16_be RESULT_CODE 0 --enable-error-stack TARGET_FILE tfloat16_be.h5)
 
+# Add tests for bfloat16 type
+ADD_H5_TEST (tbfloat16 RESULT_CODE 0 --enable-error-stack TARGET_FILE tbfloat16.h5)
+ADD_H5_TEST (tbfloat16_be RESULT_CODE 0 --enable-error-stack TARGET_FILE tbfloat16_be.h5)
+
 # Add tests for complex numbers. For portability, use a fixed floating-point
 # precision and skip dumping of the "long double _Complex" dataset. The "long
 # double _Complex" dataset may display differently across platforms, e.g.
diff --git a/tools/test/h5dump/CMakeTestsXML.cmake b/tools/test/h5dump/CMakeTestsXML.cmake
index c0da6592690..0d612971112 100644
--- a/tools/test/h5dump/CMakeTestsXML.cmake
+++ b/tools/test/h5dump/CMakeTestsXML.cmake
@@ -51,6 +51,8 @@ set (HDF5_XML_REFERENCE_TEST_FILES
     tarray6.h5
     tarray7.h5
     tattr.h5
+    tbfloat16.h5
+    tbfloat16_be.h5
     tcompound.h5
     tcompound_complex.h5
     tdatareg.h5
@@ -88,6 +90,8 @@ set (HDF5_XML_REFERENCE_FILES
     tarray6.h5.xml
     tarray7.h5.xml
     tattr.h5.xml
+    tbfloat16.h5.xml
+    tbfloat16_be.h5.xml
     tbitfields_be.h5.xml
     tbitfields_le.h5.xml
     tcompound_complex.h5.xml
@@ -302,6 +306,10 @@ ADD_XML_H5_TEST (torderattr4.h5 0 -H --sort_by=creation_order --sort_order=desce
 ADD_XML_H5_TEST (tfloat16.h5 0 tfloat16.h5)
 ADD_XML_H5_TEST (tfloat16_be.h5 0 tfloat16_be.h5)
 
+# Add tests for bfloat16 type
+ADD_XML_H5_TEST (tbfloat16.h5 0 tbfloat16.h5)
+ADD_XML_H5_TEST (tbfloat16_be.h5 0 tbfloat16_be.h5)
+
 # tests for floating point user defined printf format
 ADD_XML_H5_TEST (tfpformat.h5 0 -u -m %.7f tfpformat.h5)
 
diff --git a/tools/test/h5dump/expected/tbfloat16.ddl b/tools/test/h5dump/expected/tbfloat16.ddl
new file mode 100644
index 00000000000..cff2fa5de37
--- /dev/null
+++ b/tools/test/h5dump/expected/tbfloat16.ddl
@@ -0,0 +1,46 @@
+HDF5 "tbfloat16.h5" {
+GROUP "/" {
+   DATASET "DS16BITS" {
+      DATATYPE  H5T_FLOAT_BFLOAT16LE
+      DATASPACE  SIMPLE { ( 8, 16 ) / ( 8, 16 ) }
+      DATA {
+      (0,0): 16, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6, 6.5, 7, 7.5,
+      (1,0): 15, 0.5625, 1.0625, 1.5625, 2.0625, 2.5625, 3.0625, 3.5625,
+      (1,8): 4.0625, 4.5625, 5.0625, 5.5625, 6.0625, 6.5625, 7.0625, 7.5625,
+      (2,0): 14, 0.625, 1.125, 1.625, 2.125, 2.625, 3.125, 3.625, 4.125,
+      (2,9): 4.625, 5.125, 5.625, 6.125, 6.625, 7.125, 7.625,
+      (3,0): 13, 0.6875, 1.1875, 1.6875, 2.1875, 2.6875, 3.1875, 3.6875,
+      (3,8): 4.1875, 4.6875, 5.1875, 5.6875, 6.1875, 6.6875, 7.1875, 7.6875,
+      (4,0): 12, 0.75, 1.25, 1.75, 2.25, 2.75, 3.25, 3.75, 4.25, 4.75, 5.25,
+      (4,11): 5.75, 6.25, 6.75, 7.25, 7.75,
+      (5,0): 11, 0.8125, 1.3125, 1.8125, 2.3125, 2.8125, 3.3125, 3.8125,
+      (5,8): 4.3125, 4.8125, 5.3125, 5.8125, 6.3125, 6.8125, 7.3125, 7.8125,
+      (6,0): 10, 0.875, 1.375, 1.875, 2.375, 2.875, 3.375, 3.875, 4.375,
+      (6,9): 4.875, 5.375, 5.875, 6.375, 6.875, 7.375, 7.875,
+      (7,0): 9, 0.9375, 1.4375, 1.9375, 2.4375, 2.9375, 3.4375, 3.9375,
+      (7,8): 4.4375, 4.9375, 5.4375, 5.9375, 6.4375, 6.9375, 7.4375, 7.9375
+      }
+      ATTRIBUTE "DS16BITS" {
+         DATATYPE  H5T_FLOAT_BFLOAT16LE
+         DATASPACE  SIMPLE { ( 128 ) / ( 128 ) }
+         DATA {
+         (0): 16, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6, 6.5, 7,
+         (15): 7.5, 15, 0.5625, 1.0625, 1.5625, 2.0625, 2.5625, 3.0625,
+         (23): 3.5625, 4.0625, 4.5625, 5.0625, 5.5625, 6.0625, 6.5625,
+         (30): 7.0625, 7.5625, 14, 0.625, 1.125, 1.625, 2.125, 2.625, 3.125,
+         (39): 3.625, 4.125, 4.625, 5.125, 5.625, 6.125, 6.625, 7.125, 7.625,
+         (48): 13, 0.6875, 1.1875, 1.6875, 2.1875, 2.6875, 3.1875, 3.6875,
+         (56): 4.1875, 4.6875, 5.1875, 5.6875, 6.1875, 6.6875, 7.1875,
+         (63): 7.6875, 12, 0.75, 1.25, 1.75, 2.25, 2.75, 3.25, 3.75, 4.25,
+         (73): 4.75, 5.25, 5.75, 6.25, 6.75, 7.25, 7.75, 11, 0.8125, 1.3125,
+         (83): 1.8125, 2.3125, 2.8125, 3.3125, 3.8125, 4.3125, 4.8125,
+         (90): 5.3125, 5.8125, 6.3125, 6.8125, 7.3125, 7.8125, 10, 0.875,
+         (98): 1.375, 1.875, 2.375, 2.875, 3.375, 3.875, 4.375, 4.875, 5.375,
+         (107): 5.875, 6.375, 6.875, 7.375, 7.875, 9, 0.9375, 1.4375, 1.9375,
+         (116): 2.4375, 2.9375, 3.4375, 3.9375, 4.4375, 4.9375, 5.4375,
+         (123): 5.9375, 6.4375, 6.9375, 7.4375, 7.9375
+         }
+      }
+   }
+}
+}
diff --git a/tools/test/h5dump/expected/tbfloat16_be.ddl b/tools/test/h5dump/expected/tbfloat16_be.ddl
new file mode 100644
index 00000000000..837613407bf
--- /dev/null
+++ b/tools/test/h5dump/expected/tbfloat16_be.ddl
@@ -0,0 +1,46 @@
+HDF5 "tbfloat16_be.h5" {
+GROUP "/" {
+   DATASET "DS16BITS" {
+      DATATYPE  H5T_FLOAT_BFLOAT16BE
+      DATASPACE  SIMPLE { ( 8, 16 ) / ( 8, 16 ) }
+      DATA {
+      (0,0): 16, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6, 6.5, 7, 7.5,
+      (1,0): 15, 0.5625, 1.0625, 1.5625, 2.0625, 2.5625, 3.0625, 3.5625,
+      (1,8): 4.0625, 4.5625, 5.0625, 5.5625, 6.0625, 6.5625, 7.0625, 7.5625,
+      (2,0): 14, 0.625, 1.125, 1.625, 2.125, 2.625, 3.125, 3.625, 4.125,
+      (2,9): 4.625, 5.125, 5.625, 6.125, 6.625, 7.125, 7.625,
+      (3,0): 13, 0.6875, 1.1875, 1.6875, 2.1875, 2.6875, 3.1875, 3.6875,
+      (3,8): 4.1875, 4.6875, 5.1875, 5.6875, 6.1875, 6.6875, 7.1875, 7.6875,
+      (4,0): 12, 0.75, 1.25, 1.75, 2.25, 2.75, 3.25, 3.75, 4.25, 4.75, 5.25,
+      (4,11): 5.75, 6.25, 6.75, 7.25, 7.75,
+      (5,0): 11, 0.8125, 1.3125, 1.8125, 2.3125, 2.8125, 3.3125, 3.8125,
+      (5,8): 4.3125, 4.8125, 5.3125, 5.8125, 6.3125, 6.8125, 7.3125, 7.8125,
+      (6,0): 10, 0.875, 1.375, 1.875, 2.375, 2.875, 3.375, 3.875, 4.375,
+      (6,9): 4.875, 5.375, 5.875, 6.375, 6.875, 7.375, 7.875,
+      (7,0): 9, 0.9375, 1.4375, 1.9375, 2.4375, 2.9375, 3.4375, 3.9375,
+      (7,8): 4.4375, 4.9375, 5.4375, 5.9375, 6.4375, 6.9375, 7.4375, 7.9375
+      }
+      ATTRIBUTE "DS16BITS" {
+         DATATYPE  H5T_FLOAT_BFLOAT16BE
+         DATASPACE  SIMPLE { ( 128 ) / ( 128 ) }
+         DATA {
+         (0): 16, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6, 6.5, 7,
+         (15): 7.5, 15, 0.5625, 1.0625, 1.5625, 2.0625, 2.5625, 3.0625,
+         (23): 3.5625, 4.0625, 4.5625, 5.0625, 5.5625, 6.0625, 6.5625,
+         (30): 7.0625, 7.5625, 14, 0.625, 1.125, 1.625, 2.125, 2.625, 3.125,
+         (39): 3.625, 4.125, 4.625, 5.125, 5.625, 6.125, 6.625, 7.125, 7.625,
+         (48): 13, 0.6875, 1.1875, 1.6875, 2.1875, 2.6875, 3.1875, 3.6875,
+         (56): 4.1875, 4.6875, 5.1875, 5.6875, 6.1875, 6.6875, 7.1875,
+         (63): 7.6875, 12, 0.75, 1.25, 1.75, 2.25, 2.75, 3.25, 3.75, 4.25,
+         (73): 4.75, 5.25, 5.75, 6.25, 6.75, 7.25, 7.75, 11, 0.8125, 1.3125,
+         (83): 1.8125, 2.3125, 2.8125, 3.3125, 3.8125, 4.3125, 4.8125,
+         (90): 5.3125, 5.8125, 6.3125, 6.8125, 7.3125, 7.8125, 10, 0.875,
+         (98): 1.375, 1.875, 2.375, 2.875, 3.375, 3.875, 4.375, 4.875, 5.375,
+         (107): 5.875, 6.375, 6.875, 7.375, 7.875, 9, 0.9375, 1.4375, 1.9375,
+         (116): 2.4375, 2.9375, 3.4375, 3.9375, 4.4375, 4.9375, 5.4375,
+         (123): 5.9375, 6.4375, 6.9375, 7.4375, 7.9375
+         }
+      }
+   }
+}
+}
diff --git a/tools/test/h5dump/expected/xml/tbfloat16.h5.xml b/tools/test/h5dump/expected/xml/tbfloat16.h5.xml
new file mode 100644
index 00000000000..97697edd112
--- /dev/null
+++ b/tools/test/h5dump/expected/xml/tbfloat16.h5.xml
@@ -0,0 +1,302 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<hdf5:HDF5-File xmlns:hdf5="http://hdfgroup.org/HDF5/XML/schema/HDF5-File.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://hdfgroup.org/HDF5/XML/schema/HDF5-File http://www.hdfgroup.org/HDF5/XML/schema/HDF5-File.xsd">
+<hdf5:RootGroup OBJ-XID="xid_96" H5Path="/">
+   <hdf5:Dataset Name="DS16BITS" OBJ-XID="xid_800" H5Path= "/DS16BITS" Parents="xid_96" H5ParentPaths="/">
+      <hdf5:StorageLayout>
+         <hdf5:ContiguousLayout/>
+      </hdf5:StorageLayout>
+      <hdf5:FillValueInfo FillTime="FillIfSet" AllocationTime="Late">
+         <hdf5:FillValue>
+            <hdf5:NoFill/>
+         </hdf5:FillValue>
+      </hdf5:FillValueInfo>
+      <hdf5:Dataspace>
+         <hdf5:SimpleDataspace Ndims="2">
+            <hdf5:Dimension  DimSize="8" MaxDimSize="8"/>
+            <hdf5:Dimension  DimSize="16" MaxDimSize="16"/>
+         </hdf5:SimpleDataspace>
+      </hdf5:Dataspace>
+      <hdf5:DataType>
+         <hdf5:AtomicType>
+            <hdf5:FloatType ByteOrder="LE" Size="2" SignBitLocation="15" ExponentBits="8" ExponentLocation="7" MantissaBits="7" MantissaLocation="0" />
+         </hdf5:AtomicType>
+      </hdf5:DataType>
+      <hdf5:Attribute Name="DS16BITS">
+         <hdf5:Dataspace>
+            <hdf5:SimpleDataspace Ndims="1">
+               <hdf5:Dimension  DimSize="128" MaxDimSize="128"/>
+            </hdf5:SimpleDataspace>
+         </hdf5:Dataspace>
+         <hdf5:DataType>
+            <hdf5:AtomicType>
+               <hdf5:FloatType ByteOrder="LE" Size="2" SignBitLocation="15" ExponentBits="8" ExponentLocation="7" MantissaBits="7" MantissaLocation="0" />
+            </hdf5:AtomicType>
+         </hdf5:DataType>
+         <hdf5:Data>
+            <hdf5:DataFromFile>
+            16
+            0.5
+            1
+            1.5
+            2
+            2.5
+            3
+            3.5
+            4
+            4.5
+            5
+            5.5
+            6
+            6.5
+            7
+            7.5
+            15
+            0.5625
+            1.0625
+            1.5625
+            2.0625
+            2.5625
+            3.0625
+            3.5625
+            4.0625
+            4.5625
+            5.0625
+            5.5625
+            6.0625
+            6.5625
+            7.0625
+            7.5625
+            14
+            0.625
+            1.125
+            1.625
+            2.125
+            2.625
+            3.125
+            3.625
+            4.125
+            4.625
+            5.125
+            5.625
+            6.125
+            6.625
+            7.125
+            7.625
+            13
+            0.6875
+            1.1875
+            1.6875
+            2.1875
+            2.6875
+            3.1875
+            3.6875
+            4.1875
+            4.6875
+            5.1875
+            5.6875
+            6.1875
+            6.6875
+            7.1875
+            7.6875
+            12
+            0.75
+            1.25
+            1.75
+            2.25
+            2.75
+            3.25
+            3.75
+            4.25
+            4.75
+            5.25
+            5.75
+            6.25
+            6.75
+            7.25
+            7.75
+            11
+            0.8125
+            1.3125
+            1.8125
+            2.3125
+            2.8125
+            3.3125
+            3.8125
+            4.3125
+            4.8125
+            5.3125
+            5.8125
+            6.3125
+            6.8125
+            7.3125
+            7.8125
+            10
+            0.875
+            1.375
+            1.875
+            2.375
+            2.875
+            3.375
+            3.875
+            4.375
+            4.875
+            5.375
+            5.875
+            6.375
+            6.875
+            7.375
+            7.875
+            9
+            0.9375
+            1.4375
+            1.9375
+            2.4375
+            2.9375
+            3.4375
+            3.9375
+            4.4375
+            4.9375
+            5.4375
+            5.9375
+            6.4375
+            6.9375
+            7.4375
+            7.9375
+            </hdf5:DataFromFile>
+         </hdf5:Data>
+      </hdf5:Attribute>
+      <hdf5:Data>
+         <hdf5:DataFromFile>
+         16
+         0.5
+         1
+         1.5
+         2
+         2.5
+         3
+         3.5
+         4
+         4.5
+         5
+         5.5
+         6
+         6.5
+         7
+         7.5
+         15
+         0.5625
+         1.0625
+         1.5625
+         2.0625
+         2.5625
+         3.0625
+         3.5625
+         4.0625
+         4.5625
+         5.0625
+         5.5625
+         6.0625
+         6.5625
+         7.0625
+         7.5625
+         14
+         0.625
+         1.125
+         1.625
+         2.125
+         2.625
+         3.125
+         3.625
+         4.125
+         4.625
+         5.125
+         5.625
+         6.125
+         6.625
+         7.125
+         7.625
+         13
+         0.6875
+         1.1875
+         1.6875
+         2.1875
+         2.6875
+         3.1875
+         3.6875
+         4.1875
+         4.6875
+         5.1875
+         5.6875
+         6.1875
+         6.6875
+         7.1875
+         7.6875
+         12
+         0.75
+         1.25
+         1.75
+         2.25
+         2.75
+         3.25
+         3.75
+         4.25
+         4.75
+         5.25
+         5.75
+         6.25
+         6.75
+         7.25
+         7.75
+         11
+         0.8125
+         1.3125
+         1.8125
+         2.3125
+         2.8125
+         3.3125
+         3.8125
+         4.3125
+         4.8125
+         5.3125
+         5.8125
+         6.3125
+         6.8125
+         7.3125
+         7.8125
+         10
+         0.875
+         1.375
+         1.875
+         2.375
+         2.875
+         3.375
+         3.875
+         4.375
+         4.875
+         5.375
+         5.875
+         6.375
+         6.875
+         7.375
+         7.875
+         9
+         0.9375
+         1.4375
+         1.9375
+         2.4375
+         2.9375
+         3.4375
+         3.9375
+         4.4375
+         4.9375
+         5.4375
+         5.9375
+         6.4375
+         6.9375
+         7.4375
+         7.9375
+         </hdf5:DataFromFile>
+      </hdf5:Data>
+   </hdf5:Dataset>
+</hdf5:RootGroup>
+</hdf5:HDF5-File>
diff --git a/tools/test/h5dump/expected/xml/tbfloat16_be.h5.xml b/tools/test/h5dump/expected/xml/tbfloat16_be.h5.xml
new file mode 100644
index 00000000000..38a66bb52b3
--- /dev/null
+++ b/tools/test/h5dump/expected/xml/tbfloat16_be.h5.xml
@@ -0,0 +1,302 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<hdf5:HDF5-File xmlns:hdf5="http://hdfgroup.org/HDF5/XML/schema/HDF5-File.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://hdfgroup.org/HDF5/XML/schema/HDF5-File http://www.hdfgroup.org/HDF5/XML/schema/HDF5-File.xsd">
+<hdf5:RootGroup OBJ-XID="xid_96" H5Path="/">
+   <hdf5:Dataset Name="DS16BITS" OBJ-XID="xid_800" H5Path= "/DS16BITS" Parents="xid_96" H5ParentPaths="/">
+      <hdf5:StorageLayout>
+         <hdf5:ContiguousLayout/>
+      </hdf5:StorageLayout>
+      <hdf5:FillValueInfo FillTime="FillIfSet" AllocationTime="Late">
+         <hdf5:FillValue>
+            <hdf5:NoFill/>
+         </hdf5:FillValue>
+      </hdf5:FillValueInfo>
+      <hdf5:Dataspace>
+         <hdf5:SimpleDataspace Ndims="2">
+            <hdf5:Dimension  DimSize="8" MaxDimSize="8"/>
+            <hdf5:Dimension  DimSize="16" MaxDimSize="16"/>
+         </hdf5:SimpleDataspace>
+      </hdf5:Dataspace>
+      <hdf5:DataType>
+         <hdf5:AtomicType>
+            <hdf5:FloatType ByteOrder="BE" Size="2" SignBitLocation="15" ExponentBits="8" ExponentLocation="7" MantissaBits="7" MantissaLocation="0" />
+         </hdf5:AtomicType>
+      </hdf5:DataType>
+      <hdf5:Attribute Name="DS16BITS">
+         <hdf5:Dataspace>
+            <hdf5:SimpleDataspace Ndims="1">
+               <hdf5:Dimension  DimSize="128" MaxDimSize="128"/>
+            </hdf5:SimpleDataspace>
+         </hdf5:Dataspace>
+         <hdf5:DataType>
+            <hdf5:AtomicType>
+               <hdf5:FloatType ByteOrder="BE" Size="2" SignBitLocation="15" ExponentBits="8" ExponentLocation="7" MantissaBits="7" MantissaLocation="0" />
+            </hdf5:AtomicType>
+         </hdf5:DataType>
+         <hdf5:Data>
+            <hdf5:DataFromFile>
+            16
+            0.5
+            1
+            1.5
+            2
+            2.5
+            3
+            3.5
+            4
+            4.5
+            5
+            5.5
+            6
+            6.5
+            7
+            7.5
+            15
+            0.5625
+            1.0625
+            1.5625
+            2.0625
+            2.5625
+            3.0625
+            3.5625
+            4.0625
+            4.5625
+            5.0625
+            5.5625
+            6.0625
+            6.5625
+            7.0625
+            7.5625
+            14
+            0.625
+            1.125
+            1.625
+            2.125
+            2.625
+            3.125
+            3.625
+            4.125
+            4.625
+            5.125
+            5.625
+            6.125
+            6.625
+            7.125
+            7.625
+            13
+            0.6875
+            1.1875
+            1.6875
+            2.1875
+            2.6875
+            3.1875
+            3.6875
+            4.1875
+            4.6875
+            5.1875
+            5.6875
+            6.1875
+            6.6875
+            7.1875
+            7.6875
+            12
+            0.75
+            1.25
+            1.75
+            2.25
+            2.75
+            3.25
+            3.75
+            4.25
+            4.75
+            5.25
+            5.75
+            6.25
+            6.75
+            7.25
+            7.75
+            11
+            0.8125
+            1.3125
+            1.8125
+            2.3125
+            2.8125
+            3.3125
+            3.8125
+            4.3125
+            4.8125
+            5.3125
+            5.8125
+            6.3125
+            6.8125
+            7.3125
+            7.8125
+            10
+            0.875
+            1.375
+            1.875
+            2.375
+            2.875
+            3.375
+            3.875
+            4.375
+            4.875
+            5.375
+            5.875
+            6.375
+            6.875
+            7.375
+            7.875
+            9
+            0.9375
+            1.4375
+            1.9375
+            2.4375
+            2.9375
+            3.4375
+            3.9375
+            4.4375
+            4.9375
+            5.4375
+            5.9375
+            6.4375
+            6.9375
+            7.4375
+            7.9375
+            </hdf5:DataFromFile>
+         </hdf5:Data>
+      </hdf5:Attribute>
+      <hdf5:Data>
+         <hdf5:DataFromFile>
+         16
+         0.5
+         1
+         1.5
+         2
+         2.5
+         3
+         3.5
+         4
+         4.5
+         5
+         5.5
+         6
+         6.5
+         7
+         7.5
+         15
+         0.5625
+         1.0625
+         1.5625
+         2.0625
+         2.5625
+         3.0625
+         3.5625
+         4.0625
+         4.5625
+         5.0625
+         5.5625
+         6.0625
+         6.5625
+         7.0625
+         7.5625
+         14
+         0.625
+         1.125
+         1.625
+         2.125
+         2.625
+         3.125
+         3.625
+         4.125
+         4.625
+         5.125
+         5.625
+         6.125
+         6.625
+         7.125
+         7.625
+         13
+         0.6875
+         1.1875
+         1.6875
+         2.1875
+         2.6875
+         3.1875
+         3.6875
+         4.1875
+         4.6875
+         5.1875
+         5.6875
+         6.1875
+         6.6875
+         7.1875
+         7.6875
+         12
+         0.75
+         1.25
+         1.75
+         2.25
+         2.75
+         3.25
+         3.75
+         4.25
+         4.75
+         5.25
+         5.75
+         6.25
+         6.75
+         7.25
+         7.75
+         11
+         0.8125
+         1.3125
+         1.8125
+         2.3125
+         2.8125
+         3.3125
+         3.8125
+         4.3125
+         4.8125
+         5.3125
+         5.8125
+         6.3125
+         6.8125
+         7.3125
+         7.8125
+         10
+         0.875
+         1.375
+         1.875
+         2.375
+         2.875
+         3.375
+         3.875
+         4.375
+         4.875
+         5.375
+         5.875
+         6.375
+         6.875
+         7.375
+         7.875
+         9
+         0.9375
+         1.4375
+         1.9375
+         2.4375
+         2.9375
+         3.4375
+         3.9375
+         4.4375
+         4.9375
+         5.4375
+         5.9375
+         6.4375
+         6.9375
+         7.4375
+         7.9375
+         </hdf5:DataFromFile>
+      </hdf5:Data>
+   </hdf5:Dataset>
+</hdf5:RootGroup>
+</hdf5:HDF5-File>
diff --git a/tools/test/h5dump/h5dumpgentest.c b/tools/test/h5dump/h5dumpgentest.c
index 618689be4d4..3e80b66f518 100644
--- a/tools/test/h5dump/h5dumpgentest.c
+++ b/tools/test/h5dump/h5dumpgentest.c
@@ -118,17 +118,18 @@
 #define FILE95 "tcomplex.h5"
 #define FILE96 "tcomplex_be.h5"
 #endif
-#define FILE97   "trefer_attr.h5"
-#define FILE98   "tattr4_be.h5"
-#define FILE99   "tno-subset.h5"
-#define F99_DSET "AHFINDERDIRECT::ah_centroid_t[0] it=0 tl=0"
-#define FILE100  "trefer_compat.h5"
-#define FILE101  "trefer_grp.h5"
-#define FILE102  "trefer_obj_del.h5"
-#define FILE103  "trefer_obj.h5"
-#define FILE104  "trefer_param.h5"
-#define FILE105  "trefer_reg.h5"
-#define FILE106  "trefer_reg_1d.h5"
+#define FILE97  "tbfloat16.h5"
+#define FILE98  "tbfloat16_be.h5"
+#define FILE99  "trefer_attr.h5"
+#define FILE100 "tattr4_be.h5"
+#define FILE101 "tno-subset.h5"
+#define FILE102 "trefer_compat.h5"
+#define FILE103 "trefer_grp.h5"
+#define FILE104 "trefer_obj_del.h5"
+#define FILE105 "trefer_obj.h5"
+#define FILE106 "trefer_param.h5"
+#define FILE107 "trefer_reg.h5"
+#define FILE108 "trefer_reg_1d.h5"
 
 #define ONION_TEST_FIXNAME_SIZE 1024
 #define ONION_TEST_PAGE_SIZE    (uint32_t)32
@@ -435,6 +436,19 @@ typedef struct s1_t {
 #define F96_ATTR_FC      "AttributeFloatComplex"
 #endif
 
+/* "FILE97" macros */
+#define F97_XDIM    8
+#define F97_YDIM    16
+#define F97_DATASET "DS16BITS"
+
+/* "FILE98" macros */
+#define F98_XDIM    8
+#define F98_YDIM    16
+#define F98_DATASET "DS16BITS"
+
+/* "FILE101" macros */
+#define F101_DSET "AHFINDERDIRECT::ah_centroid_t[0] it=0 tl=0"
+
 void
 gent_group(void)
 {
@@ -12250,16 +12264,20 @@ gent_float16(void)
 
     H5Awrite(attr, H5T_IEEE_F16LE, aset16);
 
-    H5Aclose(attr);
-    H5Sclose(aspace);
-    H5Sclose(space);
-    H5Dclose(dataset);
-
 error:
     free(aset16);
     free(dset16);
 
-    H5Fclose(fid);
+    H5E_BEGIN_TRY
+    {
+        H5Tclose(tid);
+        H5Aclose(attr);
+        H5Sclose(aspace);
+        H5Sclose(space);
+        H5Dclose(dataset);
+        H5Fclose(fid);
+    }
+    H5E_END_TRY;
 }
 
 void
@@ -12320,16 +12338,20 @@ gent_float16_be(void)
 
     H5Awrite(attr, H5T_IEEE_F16LE, aset16);
 
-    H5Aclose(attr);
-    H5Sclose(aspace);
-    H5Sclose(space);
-    H5Dclose(dataset);
-
 error:
     free(aset16);
     free(dset16);
 
-    H5Fclose(fid);
+    H5E_BEGIN_TRY
+    {
+        H5Tclose(tid);
+        H5Aclose(attr);
+        H5Sclose(aspace);
+        H5Sclose(space);
+        H5Dclose(dataset);
+        H5Fclose(fid);
+    }
+    H5E_END_TRY;
 }
 #endif
 
@@ -12857,6 +12879,158 @@ gent_complex_be(void)
 }
 #endif
 
+void
+gent_bfloat16(void)
+{
+    hid_t   fid     = H5I_INVALID_HID;
+    hid_t   attr    = H5I_INVALID_HID;
+    hid_t   dataset = H5I_INVALID_HID;
+    hid_t   space   = H5I_INVALID_HID;
+    hid_t   aspace  = H5I_INVALID_HID;
+    hsize_t dims[2], adims[1];
+
+    /*
+     * bfloat16 keeps approximately the same range as the IEEE 32-bit
+     * floating point format while sacrificing precision. Since the
+     * data for these testing files isn't particular interesting or
+     * precise, just use float for the memory type (though it's
+     * possible it may not be the IEEE format). While GCC and Clang
+     * have support for a __bf16 type at this point, there's no native
+     * support for the type in HDF5 yet.
+     */
+    struct {
+        float arr[F97_XDIM][F97_YDIM];
+    } *dset16;
+
+    float *aset16 = NULL;
+    float  val;
+
+    dset16 = malloc(sizeof(*dset16));
+
+    aset16 = calloc(F97_XDIM * F97_YDIM, sizeof(float));
+
+    fid = H5Fcreate(FILE97, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+    /* Dataset of 16-bit little-endian bfloat16 */
+    dims[0] = F97_XDIM;
+    dims[1] = F97_YDIM;
+    space   = H5Screate_simple(2, dims, NULL);
+    dataset =
+        H5Dcreate2(fid, F97_DATASET, H5T_FLOAT_BFLOAT16LE, space, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+
+    val = (float)F97_YDIM;
+    for (size_t i = 0; i < dims[0]; i++) {
+        dset16->arr[i][0]   = val;
+        aset16[i * dims[1]] = dset16->arr[i][0];
+
+        for (size_t j = 1; j < dims[1]; j++) {
+            dset16->arr[i][j]       = (float)(j * dims[0] + i) / (float)F97_YDIM;
+            aset16[i * dims[1] + j] = dset16->arr[i][j];
+        }
+
+        val -= (float)1;
+    }
+
+    H5Dwrite(dataset, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset16);
+
+    /* Attribute of 16-bit little-endian bfloat16 */
+    adims[0] = F97_XDIM * F97_YDIM;
+    aspace   = H5Screate_simple(1, adims, NULL);
+    attr     = H5Acreate2(dataset, F97_DATASET, H5T_FLOAT_BFLOAT16LE, aspace, H5P_DEFAULT, H5P_DEFAULT);
+
+    H5Awrite(attr, H5T_NATIVE_FLOAT, aset16);
+
+error:
+    free(aset16);
+    free(dset16);
+
+    H5E_BEGIN_TRY
+    {
+        H5Aclose(attr);
+        H5Sclose(aspace);
+        H5Sclose(space);
+        H5Dclose(dataset);
+        H5Fclose(fid);
+    }
+    H5E_END_TRY;
+}
+
+void
+gent_bfloat16_be(void)
+{
+    hid_t   fid     = H5I_INVALID_HID;
+    hid_t   attr    = H5I_INVALID_HID;
+    hid_t   dataset = H5I_INVALID_HID;
+    hid_t   space   = H5I_INVALID_HID;
+    hid_t   aspace  = H5I_INVALID_HID;
+    hsize_t dims[2], adims[1];
+
+    /*
+     * bfloat16 keeps approximately the same range as the IEEE 32-bit
+     * floating point format while sacrificing precision. Since the
+     * data for these testing files isn't particular interesting or
+     * precise, just use float for the memory type (though it's
+     * possible it may not be the IEEE format). While GCC and Clang
+     * have support for a __bf16 type at this point, there's no native
+     * support for the type in HDF5 yet.
+     */
+    struct {
+        float arr[F98_XDIM][F98_YDIM];
+    } *dset16;
+
+    float *aset16 = NULL;
+    float  val;
+
+    dset16 = malloc(sizeof(*dset16));
+
+    aset16 = calloc(F98_XDIM * F98_YDIM, sizeof(float));
+
+    fid = H5Fcreate(FILE98, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+    /* Dataset of 16-bit big-endian bfloat16 */
+    dims[0] = F98_XDIM;
+    dims[1] = F98_YDIM;
+    space   = H5Screate_simple(2, dims, NULL);
+    dataset =
+        H5Dcreate2(fid, F98_DATASET, H5T_FLOAT_BFLOAT16BE, space, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+
+    val = (float)F98_YDIM;
+    for (size_t i = 0; i < dims[0]; i++) {
+        dset16->arr[i][0]   = val;
+        aset16[i * dims[1]] = dset16->arr[i][0];
+
+        for (size_t j = 1; j < dims[1]; j++) {
+            dset16->arr[i][j]       = (float)(j * dims[0] + i) / (float)F98_YDIM;
+            aset16[i * dims[1] + j] = dset16->arr[i][j];
+        }
+
+        val -= (float)1;
+    }
+
+    H5Dwrite(dataset, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset16);
+
+    /* Attribute of 16-bit big-endian bfloat16 */
+    adims[0] = F98_XDIM * F98_YDIM;
+    aspace   = H5Screate_simple(1, adims, NULL);
+    attr     = H5Acreate2(dataset, F98_DATASET, H5T_FLOAT_BFLOAT16BE, aspace, H5P_DEFAULT, H5P_DEFAULT);
+
+    H5Awrite(attr, H5T_NATIVE_FLOAT, aset16);
+
+error:
+    free(aset16);
+    free(dset16);
+
+    H5E_BEGIN_TRY
+    {
+        H5Aclose(attr);
+        H5Sclose(aspace);
+        H5Sclose(space);
+        H5Dclose(dataset);
+        H5Fclose(fid);
+    }
+    H5E_END_TRY;
+}
+
 void
 gent_trefer_attr(void)
 {
@@ -12879,7 +13053,7 @@ gent_trefer_attr(void)
     unsigned int  attr2_data[4] = {1, 4, 7, 10};
     unsigned int  attr3_data[4] = {2, 5, 8, 11};
 
-    file_id = H5Fcreate(FILE97, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+    file_id = H5Fcreate(FILE99, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
 
     group_id = H5Gcreate2(file_id, "Group1", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
 
@@ -12953,7 +13127,7 @@ gent_tattr4_be(void)
     float   data_value        = 0.0f;
     char    attr_name[10]     = {0};
 
-    file_id = H5Fcreate(FILE98, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+    file_id = H5Fcreate(FILE100, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
 
     dataspace_id = H5Screate_simple(1, dims, NULL);
 
@@ -12995,10 +13169,10 @@ gent_tno_subset(void)
     hsize_t dims[2]      = {1, 1};
     int     data[1][1]   = {{0}};
 
-    file_id      = H5Fcreate(FILE99, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+    file_id      = H5Fcreate(FILE101, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
     dataspace_id = H5Screate_simple(2, dims, NULL);
     dataset_id =
-        H5Dcreate2(file_id, F99_DSET, H5T_STD_I32LE, dataspace_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+        H5Dcreate2(file_id, F101_DSET, H5T_STD_I32LE, dataspace_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
     H5Dwrite(dataset_id, H5T_STD_I32LE, H5S_ALL, H5S_ALL, H5P_DEFAULT, data);
 
     H5Dclose(dataset_id);
@@ -13033,7 +13207,7 @@ gent_trefer_compat(void)
     memset(data1, 0, sizeof(data1));
     memset(data2, 0, sizeof(data2));
 
-    file_id = H5Fcreate(FILE100, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+    file_id = H5Fcreate(FILE102, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
 
     group_id = H5Gcreate2(file_id, "Group1", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
 
@@ -13105,7 +13279,7 @@ gent_trefer_grp(void)
     hid_t     space_id  = H5I_INVALID_HID;
     H5R_ref_t ref;
 
-    file_id = H5Fcreate(FILE101, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+    file_id = H5Fcreate(FILE103, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
 
     group_id  = H5Gcreate2(file_id, "group", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
     group3_id = H5Gcreate2(group_id, "group3", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
@@ -13133,7 +13307,7 @@ gent_trefer_obj_del(void)
     hid_t     space_id = H5I_INVALID_HID;
     H5R_ref_t ref;
 
-    file_id = H5Fcreate(FILE102, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+    file_id = H5Fcreate(FILE104, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
 
     space_id = H5Screate(H5S_SCALAR);
 
@@ -13179,7 +13353,7 @@ gent_trefer_obj(void)
     H5R_ref_t       ref_data5[1];
     hdset_reg_ref_t ref_data6[1];
 
-    file_id = H5Fcreate(FILE103, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+    file_id = H5Fcreate(FILE105, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
 
     group_id = H5Gcreate2(file_id, "Group1", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
 
@@ -13249,7 +13423,7 @@ gent_trefer_param(void)
     uint8_t   data2[4] = {0, 0, 0, 0};
     H5R_ref_t ref_data[4];
 
-    file_id = H5Fcreate(FILE104, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+    file_id = H5Fcreate(FILE106, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
 
     group_id = H5Gcreate2(file_id, "Group1", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
 
@@ -13313,7 +13487,7 @@ gent_trefer_reg(void)
         for (j = 0; j < 10; j++, n += 3)
             data2[i][j] = (uint8_t)(n % 256);
 
-    file_id = H5Fcreate(FILE105, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+    file_id = H5Fcreate(FILE107, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
 
     space2_id = H5Screate_simple(2, dims2, NULL);
     dset2_id =
@@ -13373,7 +13547,7 @@ gent_trefer_reg_1d(void)
     hsize_t       block[1]  = {2};
     hsize_t       coord[10] = {16, 22, 38, 41, 52, 63, 70, 89, 97, 3};
 
-    file_id = H5Fcreate(FILE106, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+    file_id = H5Fcreate(FILE108, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
 
     for (int i = 0; i < 100; i++) {
         data[i] = (unsigned char)(i * 3 % 256);
diff --git a/tools/test/h5dump/h5dumpgentest.h b/tools/test/h5dump/h5dumpgentest.h
index 1fba3b23c93..6733100598b 100644
--- a/tools/test/h5dump/h5dumpgentest.h
+++ b/tools/test/h5dump/h5dumpgentest.h
@@ -125,6 +125,9 @@ void gent_float16_be(void);
 void gent_complex(void);
 void gent_complex_be(void);
 
+void gent_bfloat16(void);
+void gent_bfloat16_be(void);
+
 void gent_trefer_attr(void);
 void gent_tattr4_be(void);
 void gent_tno_subset(void);
@@ -137,4 +140,4 @@ void gent_trefer_reg(void);
 void gent_trefer_reg_1d(void);
 
 int gent_test_reference_external(void);
-#endif /* H5DUMP_GENTEST_H */
\ No newline at end of file
+#endif /* H5DUMP_GENTEST_H */
diff --git a/tools/test/h5gentest.c b/tools/test/h5gentest.c
index 15fa2d34b08..40ffa4f9719 100644
--- a/tools/test/h5gentest.c
+++ b/tools/test/h5gentest.c
@@ -263,6 +263,9 @@ gen_h5dump_files(void)
     gent_complex_be();
 #endif
 
+    gent_bfloat16();
+    gent_bfloat16_be();
+
     gent_trefer_attr();
     gent_tattr4_be();
     gent_tno_subset();
@@ -555,6 +558,7 @@ main(int argc, char *argv[])
                     break;
                 case 'l':
                     run_h5ls = true;
+                    break;
                 default:
                     continue;
             }
diff --git a/tools/test/h5ls/CMakeTests.cmake b/tools/test/h5ls/CMakeTests.cmake
index 9fa2ae9a36a..68552a2cbb7 100644
--- a/tools/test/h5ls/CMakeTests.cmake
+++ b/tools/test/h5ls/CMakeTests.cmake
@@ -29,6 +29,8 @@ set (LIST_HDF5_TEST_FILES
     tarray1.h5
     tattr2.h5
     tattrreg.h5
+    tbfloat16.h5
+    tbfloat16_be.h5
     tcomplex.h5
     tcomplex_be.h5
     tcompound.h5
@@ -66,6 +68,8 @@ set (LIST_OTHER_TEST_FILES
     tattr2.ls
     tattrreg_le.ls
     tattrreg_be.ls
+    tbfloat16.ls
+    tbfloat16_be.ls
     tcomp-1.ls
     tcomplex.ls
     tcomplex_be.ls
@@ -471,6 +475,10 @@ else ()
   ADD_H5_TEST (tfloat16_be_nosupport RESULT_CODE 0 -w80 -v tfloat16_be.h5)
 endif ()
 
+# tests for bfloat16 type
+ADD_H5_TEST (tbfloat16 RESULT_CODE 0 -w80 -v tbfloat16.h5)
+ADD_H5_TEST (tbfloat16_be RESULT_CODE 0 -w80 -v tbfloat16_be.h5)
+
 # tests for complex numbers
 if (${${HDF_PREFIX}_HAVE_COMPLEX_NUMBERS})
   # If support is available for complex numbers, the second test
diff --git a/tools/test/h5ls/expected/tbfloat16.ls b/tools/test/h5ls/expected/tbfloat16.ls
new file mode 100644
index 00000000000..0b18aa3b2df
--- /dev/null
+++ b/tools/test/h5ls/expected/tbfloat16.ls
@@ -0,0 +1,8 @@
+Opened "tbfloat16.h5" with sec2 driver.
+DS16BITS                 Dataset {8/8, 16/16}
+    Attribute: DS16BITS {128}
+        Type:      bfloat16 16-bit little-endian float
+    Location:  1:800
+    Links:     1
+    Storage:   256 logical bytes, 256 allocated bytes, 100.00% utilization
+    Type:      bfloat16 16-bit little-endian float
diff --git a/tools/test/h5ls/expected/tbfloat16_be.ls b/tools/test/h5ls/expected/tbfloat16_be.ls
new file mode 100644
index 00000000000..c2c2d797cd3
--- /dev/null
+++ b/tools/test/h5ls/expected/tbfloat16_be.ls
@@ -0,0 +1,8 @@
+Opened "tbfloat16_be.h5" with sec2 driver.
+DS16BITS                 Dataset {8/8, 16/16}
+    Attribute: DS16BITS {128}
+        Type:      bfloat16 16-bit big-endian float
+    Location:  1:800
+    Links:     1
+    Storage:   256 logical bytes, 256 allocated bytes, 100.00% utilization
+    Type:      bfloat16 16-bit big-endian float
diff --git a/tools/test/testfiles/tbfloat16.h5 b/tools/test/testfiles/tbfloat16.h5
new file mode 100644
index 00000000000..89764b99d81
Binary files /dev/null and b/tools/test/testfiles/tbfloat16.h5 differ
diff --git a/tools/test/testfiles/tbfloat16_be.h5 b/tools/test/testfiles/tbfloat16_be.h5
new file mode 100644
index 00000000000..34ad1428b3d
Binary files /dev/null and b/tools/test/testfiles/tbfloat16_be.h5 differ