diff --git a/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/ByteOrderCodec.h b/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/ByteOrderCodec.h
index 0ca638967a..f81b335d05 100644
--- a/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/ByteOrderCodec.h
+++ b/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/ByteOrderCodec.h
@@ -22,9 +22,9 @@
 #endif
 
 #if __cplusplus >= 201103L
-#  define SBE_CONST_KIND constexpr
+#  define SBE_CONSTEXPR constexpr
 #else
-#  define SBE_CONST_KIND const
+#  define SBE_CONSTEXPR
 #endif
 
 #include <sbe/sbe.h>
diff --git a/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/FrameCodec.h b/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/FrameCodec.h
index b5648f28ad..624b49f23d 100644
--- a/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/FrameCodec.h
+++ b/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/FrameCodec.h
@@ -22,9 +22,9 @@
 #endif
 
 #if __cplusplus >= 201103L
-#  define SBE_CONST_KIND constexpr
+#  define SBE_CONSTEXPR constexpr
 #else
-#  define SBE_CONST_KIND const
+#  define SBE_CONSTEXPR
 #endif
 
 #include <sbe/sbe.h>
@@ -107,34 +107,29 @@ class FrameCodec
         return *this;
     }
 
-    static SBE_CONST_KIND std::uint16_t SbeBlockLength{(std::uint16_t)12};
-    static const std::uint16_t sbeBlockLength(void)
+    static SBE_CONSTEXPR const std::uint16_t sbeBlockLength(void)
     {
-        return SbeBlockLength;
+        return (std::uint16_t)12;
     }
 
-    static SBE_CONST_KIND std::uint16_t SbeTemplateId{(std::uint16_t)1};
-    static const std::uint16_t sbeTemplateId(void)
+    static SBE_CONSTEXPR const std::uint16_t sbeTemplateId(void)
     {
-        return SbeTemplateId;
+        return (std::uint16_t)1;
     }
 
-    static SBE_CONST_KIND std::uint16_t SbeSchemaId{(std::uint16_t)1};
-    static const std::uint16_t sbeSchemaId(void)
+    static SBE_CONSTEXPR const std::uint16_t sbeSchemaId(void)
     {
-        return SbeSchemaId;
+        return (std::uint16_t)1;
     }
 
-    static SBE_CONST_KIND std::uint16_t SbeSchemaVersion{(std::uint16_t)0};
-    static const std::uint16_t sbeSchemaVersion(void)
+    static SBE_CONSTEXPR const std::uint16_t sbeSchemaVersion(void)
     {
-        return SbeSchemaVersion;
+        return (std::uint16_t)0;
     }
 
-    static SBE_CONST_KIND char SbeSemanticType[] = "";
-    static const char *sbeSemanticType(void)
+    static SBE_CONSTEXPR const char * sbeSemanticType(void)
     {
-        return SbeSemanticType;
+        return "";
     }
 
     std::uint64_t offset(void) const
@@ -185,12 +180,12 @@ class FrameCodec
         return m_actingVersion;
     }
 
-    static const std::uint16_t irIdId(void)
+    static SBE_CONSTEXPR const std::uint16_t irIdId(void)
     {
         return 1;
     }
 
-    static const std::uint64_t irIdSinceVersion(void)
+    static SBE_CONSTEXPR const std::uint64_t irIdSinceVersion(void)
     {
          return 0;
     }
@@ -213,17 +208,17 @@ class FrameCodec
         return "";
     }
 
-    static const std::int32_t irIdNullValue()
+    static SBE_CONSTEXPR const std::int32_t irIdNullValue()
     {
         return SBE_NULLVALUE_INT32;
     }
 
-    static const std::int32_t irIdMinValue()
+    static SBE_CONSTEXPR const std::int32_t irIdMinValue()
     {
         return -2147483647;
     }
 
-    static const std::int32_t irIdMaxValue()
+    static SBE_CONSTEXPR const std::int32_t irIdMaxValue()
     {
         return 2147483647;
     }
@@ -239,12 +234,12 @@ class FrameCodec
         return *this;
     }
 
-    static const std::uint16_t irVersionId(void)
+    static SBE_CONSTEXPR const std::uint16_t irVersionId(void)
     {
         return 2;
     }
 
-    static const std::uint64_t irVersionSinceVersion(void)
+    static SBE_CONSTEXPR const std::uint64_t irVersionSinceVersion(void)
     {
          return 0;
     }
@@ -267,17 +262,17 @@ class FrameCodec
         return "";
     }
 
-    static const std::int32_t irVersionNullValue()
+    static SBE_CONSTEXPR const std::int32_t irVersionNullValue()
     {
         return SBE_NULLVALUE_INT32;
     }
 
-    static const std::int32_t irVersionMinValue()
+    static SBE_CONSTEXPR const std::int32_t irVersionMinValue()
     {
         return -2147483647;
     }
 
-    static const std::int32_t irVersionMaxValue()
+    static SBE_CONSTEXPR const std::int32_t irVersionMaxValue()
     {
         return 2147483647;
     }
@@ -293,12 +288,12 @@ class FrameCodec
         return *this;
     }
 
-    static const std::uint16_t schemaVersionId(void)
+    static SBE_CONSTEXPR const std::uint16_t schemaVersionId(void)
     {
         return 3;
     }
 
-    static const std::uint64_t schemaVersionSinceVersion(void)
+    static SBE_CONSTEXPR const std::uint64_t schemaVersionSinceVersion(void)
     {
          return 0;
     }
@@ -321,17 +316,17 @@ class FrameCodec
         return "";
     }
 
-    static const std::int32_t schemaVersionNullValue()
+    static SBE_CONSTEXPR const std::int32_t schemaVersionNullValue()
     {
         return SBE_NULLVALUE_INT32;
     }
 
-    static const std::int32_t schemaVersionMinValue()
+    static SBE_CONSTEXPR const std::int32_t schemaVersionMinValue()
     {
         return -2147483647;
     }
 
-    static const std::int32_t schemaVersionMaxValue()
+    static SBE_CONSTEXPR const std::int32_t schemaVersionMaxValue()
     {
         return 2147483647;
     }
@@ -364,7 +359,7 @@ class FrameCodec
         return "UTF-8";
     }
 
-    static const std::uint64_t packageNameSinceVersion(void)
+    static SBE_CONSTEXPR const std::uint64_t packageNameSinceVersion(void)
     {
          return 0;
     }
@@ -374,13 +369,13 @@ class FrameCodec
         return (m_actingVersion >= packageNameSinceVersion()) ? true : false;
     }
 
-    static const std::uint16_t packageNameId(void)
+    static SBE_CONSTEXPR const std::uint16_t packageNameId(void)
     {
         return 4;
     }
 
 
-    static const std::uint64_t packageNameHeaderLength()
+    static SBE_CONSTEXPR const std::uint64_t packageNameHeaderLength()
     {
         return 2;
     }
@@ -467,7 +462,7 @@ class FrameCodec
         return "UTF-8";
     }
 
-    static const std::uint64_t namespaceNameSinceVersion(void)
+    static SBE_CONSTEXPR const std::uint64_t namespaceNameSinceVersion(void)
     {
          return 0;
     }
@@ -477,13 +472,13 @@ class FrameCodec
         return (m_actingVersion >= namespaceNameSinceVersion()) ? true : false;
     }
 
-    static const std::uint16_t namespaceNameId(void)
+    static SBE_CONSTEXPR const std::uint16_t namespaceNameId(void)
     {
         return 5;
     }
 
 
-    static const std::uint64_t namespaceNameHeaderLength()
+    static SBE_CONSTEXPR const std::uint64_t namespaceNameHeaderLength()
     {
         return 2;
     }
@@ -570,7 +565,7 @@ class FrameCodec
         return "UTF-8";
     }
 
-    static const std::uint64_t semanticVersionSinceVersion(void)
+    static SBE_CONSTEXPR const std::uint64_t semanticVersionSinceVersion(void)
     {
          return 0;
     }
@@ -580,13 +575,13 @@ class FrameCodec
         return (m_actingVersion >= semanticVersionSinceVersion()) ? true : false;
     }
 
-    static const std::uint16_t semanticVersionId(void)
+    static SBE_CONSTEXPR const std::uint16_t semanticVersionId(void)
     {
         return 6;
     }
 
 
-    static const std::uint64_t semanticVersionHeaderLength()
+    static SBE_CONSTEXPR const std::uint64_t semanticVersionHeaderLength()
     {
         return 2;
     }
@@ -656,11 +651,6 @@ class FrameCodec
         return *this;
     }
 };
-SBE_CONST_KIND std::uint16_t FrameCodec::SbeBlockLength;
-SBE_CONST_KIND std::uint16_t FrameCodec::SbeTemplateId;
-SBE_CONST_KIND std::uint16_t FrameCodec::SbeSchemaId;
-SBE_CONST_KIND std::uint16_t FrameCodec::SbeSchemaVersion;
-SBE_CONST_KIND char FrameCodec::SbeSemanticType[];
 };
 };
 };
diff --git a/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/MessageHeader.h b/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/MessageHeader.h
index 5dbf982b21..7b7b66e67b 100644
--- a/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/MessageHeader.h
+++ b/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/MessageHeader.h
@@ -22,9 +22,9 @@
 #endif
 
 #if __cplusplus >= 201103L
-#  define SBE_CONST_KIND constexpr
+#  define SBE_CONSTEXPR constexpr
 #else
-#  define SBE_CONST_KIND const
+#  define SBE_CONSTEXPR
 #endif
 
 #include <sbe/sbe.h>
@@ -99,23 +99,23 @@ class MessageHeader
         return *this;
     }
 
-    static const std::uint64_t encodedLength(void)
+    static SBE_CONSTEXPR const std::uint64_t encodedLength(void)
     {
         return 8;
     }
 
 
-    static const std::uint16_t blockLengthNullValue()
+    static SBE_CONSTEXPR const std::uint16_t blockLengthNullValue()
     {
         return SBE_NULLVALUE_UINT16;
     }
 
-    static const std::uint16_t blockLengthMinValue()
+    static SBE_CONSTEXPR const std::uint16_t blockLengthMinValue()
     {
         return (std::uint16_t)0;
     }
 
-    static const std::uint16_t blockLengthMaxValue()
+    static SBE_CONSTEXPR const std::uint16_t blockLengthMaxValue()
     {
         return (std::uint16_t)65534;
     }
@@ -131,17 +131,17 @@ class MessageHeader
         return *this;
     }
 
-    static const std::uint16_t templateIdNullValue()
+    static SBE_CONSTEXPR const std::uint16_t templateIdNullValue()
     {
         return SBE_NULLVALUE_UINT16;
     }
 
-    static const std::uint16_t templateIdMinValue()
+    static SBE_CONSTEXPR const std::uint16_t templateIdMinValue()
     {
         return (std::uint16_t)0;
     }
 
-    static const std::uint16_t templateIdMaxValue()
+    static SBE_CONSTEXPR const std::uint16_t templateIdMaxValue()
     {
         return (std::uint16_t)65534;
     }
@@ -157,17 +157,17 @@ class MessageHeader
         return *this;
     }
 
-    static const std::uint16_t schemaIdNullValue()
+    static SBE_CONSTEXPR const std::uint16_t schemaIdNullValue()
     {
         return SBE_NULLVALUE_UINT16;
     }
 
-    static const std::uint16_t schemaIdMinValue()
+    static SBE_CONSTEXPR const std::uint16_t schemaIdMinValue()
     {
         return (std::uint16_t)0;
     }
 
-    static const std::uint16_t schemaIdMaxValue()
+    static SBE_CONSTEXPR const std::uint16_t schemaIdMaxValue()
     {
         return (std::uint16_t)65534;
     }
@@ -183,17 +183,17 @@ class MessageHeader
         return *this;
     }
 
-    static const std::uint16_t versionNullValue()
+    static SBE_CONSTEXPR const std::uint16_t versionNullValue()
     {
         return SBE_NULLVALUE_UINT16;
     }
 
-    static const std::uint16_t versionMinValue()
+    static SBE_CONSTEXPR const std::uint16_t versionMinValue()
     {
         return (std::uint16_t)0;
     }
 
-    static const std::uint16_t versionMaxValue()
+    static SBE_CONSTEXPR const std::uint16_t versionMaxValue()
     {
         return (std::uint16_t)65534;
     }
diff --git a/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/PresenceCodec.h b/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/PresenceCodec.h
index 7f84ec4466..ceb521ee8c 100644
--- a/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/PresenceCodec.h
+++ b/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/PresenceCodec.h
@@ -22,9 +22,9 @@
 #endif
 
 #if __cplusplus >= 201103L
-#  define SBE_CONST_KIND constexpr
+#  define SBE_CONSTEXPR constexpr
 #else
-#  define SBE_CONST_KIND const
+#  define SBE_CONSTEXPR
 #endif
 
 #include <sbe/sbe.h>
diff --git a/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/PrimitiveTypeCodec.h b/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/PrimitiveTypeCodec.h
index 536ea7c03b..d722c02acd 100644
--- a/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/PrimitiveTypeCodec.h
+++ b/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/PrimitiveTypeCodec.h
@@ -22,9 +22,9 @@
 #endif
 
 #if __cplusplus >= 201103L
-#  define SBE_CONST_KIND constexpr
+#  define SBE_CONSTEXPR constexpr
 #else
-#  define SBE_CONST_KIND const
+#  define SBE_CONSTEXPR
 #endif
 
 #include <sbe/sbe.h>
diff --git a/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/SignalCodec.h b/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/SignalCodec.h
index 2f406e5454..447c36d3b6 100644
--- a/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/SignalCodec.h
+++ b/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/SignalCodec.h
@@ -22,9 +22,9 @@
 #endif
 
 #if __cplusplus >= 201103L
-#  define SBE_CONST_KIND constexpr
+#  define SBE_CONSTEXPR constexpr
 #else
-#  define SBE_CONST_KIND const
+#  define SBE_CONSTEXPR
 #endif
 
 #include <sbe/sbe.h>
diff --git a/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/TokenCodec.h b/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/TokenCodec.h
index afc4ee1c92..ea1c0da2c2 100644
--- a/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/TokenCodec.h
+++ b/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/TokenCodec.h
@@ -22,9 +22,9 @@
 #endif
 
 #if __cplusplus >= 201103L
-#  define SBE_CONST_KIND constexpr
+#  define SBE_CONSTEXPR constexpr
 #else
-#  define SBE_CONST_KIND const
+#  define SBE_CONSTEXPR
 #endif
 
 #include <sbe/sbe.h>
@@ -107,34 +107,29 @@ class TokenCodec
         return *this;
     }
 
-    static SBE_CONST_KIND std::uint16_t SbeBlockLength{(std::uint16_t)24};
-    static const std::uint16_t sbeBlockLength(void)
+    static SBE_CONSTEXPR const std::uint16_t sbeBlockLength(void)
     {
-        return SbeBlockLength;
+        return (std::uint16_t)24;
     }
 
-    static SBE_CONST_KIND std::uint16_t SbeTemplateId{(std::uint16_t)2};
-    static const std::uint16_t sbeTemplateId(void)
+    static SBE_CONSTEXPR const std::uint16_t sbeTemplateId(void)
     {
-        return SbeTemplateId;
+        return (std::uint16_t)2;
     }
 
-    static SBE_CONST_KIND std::uint16_t SbeSchemaId{(std::uint16_t)1};
-    static const std::uint16_t sbeSchemaId(void)
+    static SBE_CONSTEXPR const std::uint16_t sbeSchemaId(void)
     {
-        return SbeSchemaId;
+        return (std::uint16_t)1;
     }
 
-    static SBE_CONST_KIND std::uint16_t SbeSchemaVersion{(std::uint16_t)0};
-    static const std::uint16_t sbeSchemaVersion(void)
+    static SBE_CONSTEXPR const std::uint16_t sbeSchemaVersion(void)
     {
-        return SbeSchemaVersion;
+        return (std::uint16_t)0;
     }
 
-    static SBE_CONST_KIND char SbeSemanticType[] = "";
-    static const char *sbeSemanticType(void)
+    static SBE_CONSTEXPR const char * sbeSemanticType(void)
     {
-        return SbeSemanticType;
+        return "";
     }
 
     std::uint64_t offset(void) const
@@ -185,12 +180,12 @@ class TokenCodec
         return m_actingVersion;
     }
 
-    static const std::uint16_t tokenOffsetId(void)
+    static SBE_CONSTEXPR const std::uint16_t tokenOffsetId(void)
     {
         return 11;
     }
 
-    static const std::uint64_t tokenOffsetSinceVersion(void)
+    static SBE_CONSTEXPR const std::uint64_t tokenOffsetSinceVersion(void)
     {
          return 0;
     }
@@ -213,17 +208,17 @@ class TokenCodec
         return "";
     }
 
-    static const std::int32_t tokenOffsetNullValue()
+    static SBE_CONSTEXPR const std::int32_t tokenOffsetNullValue()
     {
         return SBE_NULLVALUE_INT32;
     }
 
-    static const std::int32_t tokenOffsetMinValue()
+    static SBE_CONSTEXPR const std::int32_t tokenOffsetMinValue()
     {
         return -2147483647;
     }
 
-    static const std::int32_t tokenOffsetMaxValue()
+    static SBE_CONSTEXPR const std::int32_t tokenOffsetMaxValue()
     {
         return 2147483647;
     }
@@ -239,12 +234,12 @@ class TokenCodec
         return *this;
     }
 
-    static const std::uint16_t tokenSizeId(void)
+    static SBE_CONSTEXPR const std::uint16_t tokenSizeId(void)
     {
         return 12;
     }
 
-    static const std::uint64_t tokenSizeSinceVersion(void)
+    static SBE_CONSTEXPR const std::uint64_t tokenSizeSinceVersion(void)
     {
          return 0;
     }
@@ -267,17 +262,17 @@ class TokenCodec
         return "";
     }
 
-    static const std::int32_t tokenSizeNullValue()
+    static SBE_CONSTEXPR const std::int32_t tokenSizeNullValue()
     {
         return SBE_NULLVALUE_INT32;
     }
 
-    static const std::int32_t tokenSizeMinValue()
+    static SBE_CONSTEXPR const std::int32_t tokenSizeMinValue()
     {
         return -2147483647;
     }
 
-    static const std::int32_t tokenSizeMaxValue()
+    static SBE_CONSTEXPR const std::int32_t tokenSizeMaxValue()
     {
         return 2147483647;
     }
@@ -293,12 +288,12 @@ class TokenCodec
         return *this;
     }
 
-    static const std::uint16_t fieldIdId(void)
+    static SBE_CONSTEXPR const std::uint16_t fieldIdId(void)
     {
         return 13;
     }
 
-    static const std::uint64_t fieldIdSinceVersion(void)
+    static SBE_CONSTEXPR const std::uint64_t fieldIdSinceVersion(void)
     {
          return 0;
     }
@@ -321,17 +316,17 @@ class TokenCodec
         return "";
     }
 
-    static const std::int32_t fieldIdNullValue()
+    static SBE_CONSTEXPR const std::int32_t fieldIdNullValue()
     {
         return SBE_NULLVALUE_INT32;
     }
 
-    static const std::int32_t fieldIdMinValue()
+    static SBE_CONSTEXPR const std::int32_t fieldIdMinValue()
     {
         return -2147483647;
     }
 
-    static const std::int32_t fieldIdMaxValue()
+    static SBE_CONSTEXPR const std::int32_t fieldIdMaxValue()
     {
         return 2147483647;
     }
@@ -347,12 +342,12 @@ class TokenCodec
         return *this;
     }
 
-    static const std::uint16_t tokenVersionId(void)
+    static SBE_CONSTEXPR const std::uint16_t tokenVersionId(void)
     {
         return 14;
     }
 
-    static const std::uint64_t tokenVersionSinceVersion(void)
+    static SBE_CONSTEXPR const std::uint64_t tokenVersionSinceVersion(void)
     {
          return 0;
     }
@@ -375,17 +370,17 @@ class TokenCodec
         return "";
     }
 
-    static const std::int32_t tokenVersionNullValue()
+    static SBE_CONSTEXPR const std::int32_t tokenVersionNullValue()
     {
         return SBE_NULLVALUE_INT32;
     }
 
-    static const std::int32_t tokenVersionMinValue()
+    static SBE_CONSTEXPR const std::int32_t tokenVersionMinValue()
     {
         return -2147483647;
     }
 
-    static const std::int32_t tokenVersionMaxValue()
+    static SBE_CONSTEXPR const std::int32_t tokenVersionMaxValue()
     {
         return 2147483647;
     }
@@ -401,12 +396,12 @@ class TokenCodec
         return *this;
     }
 
-    static const std::uint16_t componentTokenCountId(void)
+    static SBE_CONSTEXPR const std::uint16_t componentTokenCountId(void)
     {
         return 15;
     }
 
-    static const std::uint64_t componentTokenCountSinceVersion(void)
+    static SBE_CONSTEXPR const std::uint64_t componentTokenCountSinceVersion(void)
     {
          return 0;
     }
@@ -429,17 +424,17 @@ class TokenCodec
         return "";
     }
 
-    static const std::int32_t componentTokenCountNullValue()
+    static SBE_CONSTEXPR const std::int32_t componentTokenCountNullValue()
     {
         return SBE_NULLVALUE_INT32;
     }
 
-    static const std::int32_t componentTokenCountMinValue()
+    static SBE_CONSTEXPR const std::int32_t componentTokenCountMinValue()
     {
         return -2147483647;
     }
 
-    static const std::int32_t componentTokenCountMaxValue()
+    static SBE_CONSTEXPR const std::int32_t componentTokenCountMaxValue()
     {
         return 2147483647;
     }
@@ -455,12 +450,12 @@ class TokenCodec
         return *this;
     }
 
-    static const std::uint16_t signalId(void)
+    static SBE_CONSTEXPR const std::uint16_t signalId(void)
     {
         return 16;
     }
 
-    static const std::uint64_t signalSinceVersion(void)
+    static SBE_CONSTEXPR const std::uint64_t signalSinceVersion(void)
     {
          return 0;
     }
@@ -494,12 +489,12 @@ class TokenCodec
         return *this;
     }
 
-    static const std::uint16_t primitiveTypeId(void)
+    static SBE_CONSTEXPR const std::uint16_t primitiveTypeId(void)
     {
         return 17;
     }
 
-    static const std::uint64_t primitiveTypeSinceVersion(void)
+    static SBE_CONSTEXPR const std::uint64_t primitiveTypeSinceVersion(void)
     {
          return 0;
     }
@@ -533,12 +528,12 @@ class TokenCodec
         return *this;
     }
 
-    static const std::uint16_t byteOrderId(void)
+    static SBE_CONSTEXPR const std::uint16_t byteOrderId(void)
     {
         return 18;
     }
 
-    static const std::uint64_t byteOrderSinceVersion(void)
+    static SBE_CONSTEXPR const std::uint64_t byteOrderSinceVersion(void)
     {
          return 0;
     }
@@ -572,12 +567,12 @@ class TokenCodec
         return *this;
     }
 
-    static const std::uint16_t presenceId(void)
+    static SBE_CONSTEXPR const std::uint16_t presenceId(void)
     {
         return 19;
     }
 
-    static const std::uint64_t presenceSinceVersion(void)
+    static SBE_CONSTEXPR const std::uint64_t presenceSinceVersion(void)
     {
          return 0;
     }
@@ -628,7 +623,7 @@ class TokenCodec
         return "UTF-8";
     }
 
-    static const std::uint64_t nameSinceVersion(void)
+    static SBE_CONSTEXPR const std::uint64_t nameSinceVersion(void)
     {
          return 0;
     }
@@ -638,13 +633,13 @@ class TokenCodec
         return (m_actingVersion >= nameSinceVersion()) ? true : false;
     }
 
-    static const std::uint16_t nameId(void)
+    static SBE_CONSTEXPR const std::uint16_t nameId(void)
     {
         return 20;
     }
 
 
-    static const std::uint64_t nameHeaderLength()
+    static SBE_CONSTEXPR const std::uint64_t nameHeaderLength()
     {
         return 2;
     }
@@ -731,7 +726,7 @@ class TokenCodec
         return "UTF-8";
     }
 
-    static const std::uint64_t constValueSinceVersion(void)
+    static SBE_CONSTEXPR const std::uint64_t constValueSinceVersion(void)
     {
          return 0;
     }
@@ -741,13 +736,13 @@ class TokenCodec
         return (m_actingVersion >= constValueSinceVersion()) ? true : false;
     }
 
-    static const std::uint16_t constValueId(void)
+    static SBE_CONSTEXPR const std::uint16_t constValueId(void)
     {
         return 21;
     }
 
 
-    static const std::uint64_t constValueHeaderLength()
+    static SBE_CONSTEXPR const std::uint64_t constValueHeaderLength()
     {
         return 2;
     }
@@ -834,7 +829,7 @@ class TokenCodec
         return "UTF-8";
     }
 
-    static const std::uint64_t minValueSinceVersion(void)
+    static SBE_CONSTEXPR const std::uint64_t minValueSinceVersion(void)
     {
          return 0;
     }
@@ -844,13 +839,13 @@ class TokenCodec
         return (m_actingVersion >= minValueSinceVersion()) ? true : false;
     }
 
-    static const std::uint16_t minValueId(void)
+    static SBE_CONSTEXPR const std::uint16_t minValueId(void)
     {
         return 22;
     }
 
 
-    static const std::uint64_t minValueHeaderLength()
+    static SBE_CONSTEXPR const std::uint64_t minValueHeaderLength()
     {
         return 2;
     }
@@ -937,7 +932,7 @@ class TokenCodec
         return "UTF-8";
     }
 
-    static const std::uint64_t maxValueSinceVersion(void)
+    static SBE_CONSTEXPR const std::uint64_t maxValueSinceVersion(void)
     {
          return 0;
     }
@@ -947,13 +942,13 @@ class TokenCodec
         return (m_actingVersion >= maxValueSinceVersion()) ? true : false;
     }
 
-    static const std::uint16_t maxValueId(void)
+    static SBE_CONSTEXPR const std::uint16_t maxValueId(void)
     {
         return 23;
     }
 
 
-    static const std::uint64_t maxValueHeaderLength()
+    static SBE_CONSTEXPR const std::uint64_t maxValueHeaderLength()
     {
         return 2;
     }
@@ -1040,7 +1035,7 @@ class TokenCodec
         return "UTF-8";
     }
 
-    static const std::uint64_t nullValueSinceVersion(void)
+    static SBE_CONSTEXPR const std::uint64_t nullValueSinceVersion(void)
     {
          return 0;
     }
@@ -1050,13 +1045,13 @@ class TokenCodec
         return (m_actingVersion >= nullValueSinceVersion()) ? true : false;
     }
 
-    static const std::uint16_t nullValueId(void)
+    static SBE_CONSTEXPR const std::uint16_t nullValueId(void)
     {
         return 24;
     }
 
 
-    static const std::uint64_t nullValueHeaderLength()
+    static SBE_CONSTEXPR const std::uint64_t nullValueHeaderLength()
     {
         return 2;
     }
@@ -1143,7 +1138,7 @@ class TokenCodec
         return "UTF-8";
     }
 
-    static const std::uint64_t characterEncodingSinceVersion(void)
+    static SBE_CONSTEXPR const std::uint64_t characterEncodingSinceVersion(void)
     {
          return 0;
     }
@@ -1153,13 +1148,13 @@ class TokenCodec
         return (m_actingVersion >= characterEncodingSinceVersion()) ? true : false;
     }
 
-    static const std::uint16_t characterEncodingId(void)
+    static SBE_CONSTEXPR const std::uint16_t characterEncodingId(void)
     {
         return 25;
     }
 
 
-    static const std::uint64_t characterEncodingHeaderLength()
+    static SBE_CONSTEXPR const std::uint64_t characterEncodingHeaderLength()
     {
         return 2;
     }
@@ -1246,7 +1241,7 @@ class TokenCodec
         return "UTF-8";
     }
 
-    static const std::uint64_t epochSinceVersion(void)
+    static SBE_CONSTEXPR const std::uint64_t epochSinceVersion(void)
     {
          return 0;
     }
@@ -1256,13 +1251,13 @@ class TokenCodec
         return (m_actingVersion >= epochSinceVersion()) ? true : false;
     }
 
-    static const std::uint16_t epochId(void)
+    static SBE_CONSTEXPR const std::uint16_t epochId(void)
     {
         return 26;
     }
 
 
-    static const std::uint64_t epochHeaderLength()
+    static SBE_CONSTEXPR const std::uint64_t epochHeaderLength()
     {
         return 2;
     }
@@ -1349,7 +1344,7 @@ class TokenCodec
         return "UTF-8";
     }
 
-    static const std::uint64_t timeUnitSinceVersion(void)
+    static SBE_CONSTEXPR const std::uint64_t timeUnitSinceVersion(void)
     {
          return 0;
     }
@@ -1359,13 +1354,13 @@ class TokenCodec
         return (m_actingVersion >= timeUnitSinceVersion()) ? true : false;
     }
 
-    static const std::uint16_t timeUnitId(void)
+    static SBE_CONSTEXPR const std::uint16_t timeUnitId(void)
     {
         return 27;
     }
 
 
-    static const std::uint64_t timeUnitHeaderLength()
+    static SBE_CONSTEXPR const std::uint64_t timeUnitHeaderLength()
     {
         return 2;
     }
@@ -1452,7 +1447,7 @@ class TokenCodec
         return "UTF-8";
     }
 
-    static const std::uint64_t semanticTypeSinceVersion(void)
+    static SBE_CONSTEXPR const std::uint64_t semanticTypeSinceVersion(void)
     {
          return 0;
     }
@@ -1462,13 +1457,13 @@ class TokenCodec
         return (m_actingVersion >= semanticTypeSinceVersion()) ? true : false;
     }
 
-    static const std::uint16_t semanticTypeId(void)
+    static SBE_CONSTEXPR const std::uint16_t semanticTypeId(void)
     {
         return 28;
     }
 
 
-    static const std::uint64_t semanticTypeHeaderLength()
+    static SBE_CONSTEXPR const std::uint64_t semanticTypeHeaderLength()
     {
         return 2;
     }
@@ -1555,7 +1550,7 @@ class TokenCodec
         return "UTF-8";
     }
 
-    static const std::uint64_t descriptionSinceVersion(void)
+    static SBE_CONSTEXPR const std::uint64_t descriptionSinceVersion(void)
     {
          return 0;
     }
@@ -1565,13 +1560,13 @@ class TokenCodec
         return (m_actingVersion >= descriptionSinceVersion()) ? true : false;
     }
 
-    static const std::uint16_t descriptionId(void)
+    static SBE_CONSTEXPR const std::uint16_t descriptionId(void)
     {
         return 29;
     }
 
 
-    static const std::uint64_t descriptionHeaderLength()
+    static SBE_CONSTEXPR const std::uint64_t descriptionHeaderLength()
     {
         return 2;
     }
@@ -1641,11 +1636,6 @@ class TokenCodec
         return *this;
     }
 };
-SBE_CONST_KIND std::uint16_t TokenCodec::SbeBlockLength;
-SBE_CONST_KIND std::uint16_t TokenCodec::SbeTemplateId;
-SBE_CONST_KIND std::uint16_t TokenCodec::SbeSchemaId;
-SBE_CONST_KIND std::uint16_t TokenCodec::SbeSchemaVersion;
-SBE_CONST_KIND char TokenCodec::SbeSemanticType[];
 };
 };
 };
diff --git a/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/VarDataEncoding.h b/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/VarDataEncoding.h
index 49dacba1a6..9f63004644 100644
--- a/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/VarDataEncoding.h
+++ b/sbe-tool/src/main/cpp/uk_co_real_logic_sbe_ir_generated/VarDataEncoding.h
@@ -22,9 +22,9 @@
 #endif
 
 #if __cplusplus >= 201103L
-#  define SBE_CONST_KIND constexpr
+#  define SBE_CONSTEXPR constexpr
 #else
-#  define SBE_CONST_KIND const
+#  define SBE_CONSTEXPR
 #endif
 
 #include <sbe/sbe.h>
@@ -100,23 +100,23 @@ class VarDataEncoding
         return *this;
     }
 
-    static const std::uint64_t encodedLength(void)
+    static SBE_CONSTEXPR const std::uint64_t encodedLength(void)
     {
         return -1;
     }
 
 
-    static const std::uint16_t lengthNullValue()
+    static SBE_CONSTEXPR const std::uint16_t lengthNullValue()
     {
         return SBE_NULLVALUE_UINT16;
     }
 
-    static const std::uint16_t lengthMinValue()
+    static SBE_CONSTEXPR const std::uint16_t lengthMinValue()
     {
         return (std::uint16_t)0;
     }
 
-    static const std::uint16_t lengthMaxValue()
+    static SBE_CONSTEXPR const std::uint16_t lengthMaxValue()
     {
         return (std::uint16_t)65534;
     }
@@ -132,17 +132,17 @@ class VarDataEncoding
         return *this;
     }
 
-    static const std::uint8_t varDataNullValue()
+    static SBE_CONSTEXPR const std::uint8_t varDataNullValue()
     {
         return SBE_NULLVALUE_UINT8;
     }
 
-    static const std::uint8_t varDataMinValue()
+    static SBE_CONSTEXPR const std::uint8_t varDataMinValue()
     {
         return (std::uint8_t)0;
     }
 
-    static const std::uint8_t varDataMaxValue()
+    static SBE_CONSTEXPR const std::uint8_t varDataMaxValue()
     {
         return (std::uint8_t)254;
     }
diff --git a/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/cpp/CppGenerator.java b/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/cpp/CppGenerator.java
index c2d14ebd50..5be2b3a76e 100644
--- a/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/cpp/CppGenerator.java
+++ b/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/cpp/CppGenerator.java
@@ -146,7 +146,6 @@ public void generate() throws IOException
                 out.append(sb);
                 out.append(generateVarData(className, varData, BASE_INDENT));
                 out.append("};\n");
-                out.append(generateStaticDefinitions(className));
                 out.append(CppUtil.closingBraces(ir.namespaces().length) + "#endif\n");
             }
         }
@@ -257,11 +256,11 @@ private static void generateGroupClassHeader(
             numInGroupToken.encoding().applicableMaxValue().longValue()));
 
         sb.append(String.format(
-            indent + "    static SBE_CONST_KIND std::uint64_t sbeHeaderSize()\n" +
+            indent + "    static SBE_CONSTEXPR const std::uint64_t sbeHeaderSize()\n" +
             indent + "    {\n" +
             indent + "        return %1$d;\n" +
             indent + "    }\n\n" +
-            indent + "    static SBE_CONST_KIND std::uint64_t sbeBlockLength()\n" +
+            indent + "    static SBE_CONSTEXPR const std::uint64_t sbeBlockLength()\n" +
             indent + "    {\n" +
             indent + "        return %2$d;\n" +
             indent + "    }\n\n" +
@@ -338,7 +337,7 @@ private static CharSequence generateGroupProperty(
 
         sb.append(String.format(
             "\n" +
-            indent + "    static SBE_CONST_KIND std::uint16_t %1$sId(void)\n" +
+            indent + "    static SBE_CONSTEXPR const std::uint16_t %1$sId(void)\n" +
             indent + "    {\n" +
             indent + "        return %2$d;\n" +
             indent + "    }\n\n",
@@ -520,7 +519,7 @@ private void generateVarDataDescriptors(
         ));
 
         sb.append(String.format(
-            indent + "    static SBE_CONST_KIND std::uint64_t %1$sSinceVersion(void)\n" +
+            indent + "    static SBE_CONSTEXPR const std::uint64_t %1$sSinceVersion(void)\n" +
             indent + "    {\n" +
             indent + "         return %2$d;\n" +
             indent + "    }\n\n" +
@@ -528,7 +527,7 @@ private void generateVarDataDescriptors(
             indent + "    {\n" +
             indent + "        return (m_actingVersion >= %1$sSinceVersion()) ? true : false;\n" +
             indent + "    }\n\n" +
-            indent + "    static SBE_CONST_KIND std::uint16_t %1$sId(void)\n" +
+            indent + "    static SBE_CONSTEXPR const std::uint16_t %1$sId(void)\n" +
             indent + "    {\n" +
             indent + "        return %3$d;\n" +
             indent + "    }\n\n",
@@ -539,7 +538,7 @@ private void generateVarDataDescriptors(
 
         sb.append(String.format(
             "\n" +
-            indent + "    static SBE_CONST_KIND std::uint64_t %sHeaderLength()\n" +
+            indent + "    static SBE_CONSTEXPR const std::uint64_t %sHeaderLength()\n" +
             indent + "    {\n" +
             indent + "        return %d;\n" +
             indent + "    }\n",
@@ -845,9 +844,9 @@ private static CharSequence generateFileHeader(
             "#  include <cstring>\n" +
             "#endif\n\n" +
             "#if __cplusplus >= 201103L\n" +
-            "#  define SBE_CONST_KIND constexpr\n" +
+            "#  define SBE_CONSTEXPR constexpr\n" +
             "#else\n" +
-            "#  define SBE_CONST_KIND const\n" +
+            "#  define SBE_CONSTEXPR\n" +
             "#endif\n\n" +
             "#include <sbe/sbe.h>\n\n",
             String.join("_", namespaces).toUpperCase(),
@@ -885,32 +884,6 @@ private static CharSequence generateClassDeclaration(final String className)
         );
     }
 
-    private String generateStaticDefinitions(final String className)
-    {
-        return
-            generateStaticDefinition(
-                className, "SbeBlockLength", cppTypeName(ir.headerStructure().blockLengthType()), false) +
-            generateStaticDefinition(
-                className, "SbeTemplateId", cppTypeName(ir.headerStructure().templateIdType()), false) +
-            generateStaticDefinition(
-                className, "SbeSchemaId", cppTypeName(ir.headerStructure().schemaIdType()), false) +
-            generateStaticDefinition(
-                className, "SbeSchemaVersion", cppTypeName(ir.headerStructure().schemaVersionType()), false) +
-            generateStaticDefinition(className, "SbeSemanticType", "char", true);
-    }
-
-    private static String generateStaticDefinition(
-        final String className, final String memberName, final String memberType, boolean isArray)
-    {
-        return String.format(
-            "SBE_CONST_KIND %3$s %1$s::%2$s%4$s;\n",
-            className,
-            memberName,
-            memberType,
-            (isArray ? "[]" : "")
-        );
-    }
-
     private static CharSequence generateEnumDeclaration(final String name)
     {
         return "class " + name + "\n{\npublic:\n\n";
@@ -998,7 +971,7 @@ private CharSequence generatePrimitiveFieldMetaData(final String propertyName, f
 
         sb.append(String.format(
             "\n" +
-            indent + "    static SBE_CONST_KIND %1$s %2$sNullValue()\n" +
+            indent + "    static SBE_CONSTEXPR const %1$s %2$sNullValue()\n" +
             indent + "    {\n" +
             indent + "        return %3$s;\n" +
             indent + "    }\n",
@@ -1009,7 +982,7 @@ private CharSequence generatePrimitiveFieldMetaData(final String propertyName, f
 
         sb.append(String.format(
             "\n" +
-            indent + "    static SBE_CONST_KIND %1$s %2$sMinValue()\n" +
+            indent + "    static SBE_CONSTEXPR const %1$s %2$sMinValue()\n" +
             indent + "    {\n" +
             indent + "        return %3$s;\n" +
             indent + "    }\n",
@@ -1020,7 +993,7 @@ private CharSequence generatePrimitiveFieldMetaData(final String propertyName, f
 
         sb.append(String.format(
             "\n" +
-            indent + "    static SBE_CONST_KIND %1$s %2$sMaxValue()\n" +
+            indent + "    static SBE_CONSTEXPR const %1$s %2$sMaxValue()\n" +
             indent + "    {\n" +
             indent + "        return %3$s;\n" +
             indent + "    }\n",
@@ -1079,7 +1052,7 @@ private CharSequence generateArrayProperty(
 
         sb.append(String.format(
             "\n" +
-            indent + "    static SBE_CONST_KIND std::uint64_t %1$sLength(void)\n" +
+            indent + "    static SBE_CONSTEXPR const std::uint64_t %1$sLength(void)\n" +
             indent + "    {\n" +
             indent + "        return %2$d;\n" +
             indent + "    }\n\n",
@@ -1225,7 +1198,7 @@ private CharSequence generateConstPropertyMethods(final String propertyName, fin
 
         sb.append(String.format(
             "\n" +
-            indent + "    static SBE_CONST_KIND std::uint64_t %1$sLength(void)\n" +
+            indent + "    static SBE_CONSTEXPR const std::uint64_t %1$sLength(void)\n" +
             indent + "    {\n" +
             indent + "        return %2$d;\n" +
             indent + "    }\n\n",
@@ -1324,7 +1297,7 @@ private static CharSequence generateFixedFlyweightCode(final String className, f
             "        reset(buffer, offset, bufferLength, actingVersion);\n" +
             "        return *this;\n" +
             "    }\n\n" +
-            "    static SBE_CONST_KIND std::uint64_t encodedLength(void)\n" +
+            "    static SBE_CONSTEXPR const std::uint64_t encodedLength(void)\n" +
             "    {\n" +
             "        return %2$s;\n" +
             "    }\n\n",
@@ -1405,30 +1378,25 @@ private CharSequence generateMessageFlyweightCode(final String className, final
             "    }\n\n" +
             "public:\n\n" +
             "%11$s" +
-            "    static SBE_CONST_KIND %1$s SbeBlockLength{%2$s};\n" +
-            "    static const %1$s sbeBlockLength(void)\n" +
+            "    static SBE_CONSTEXPR const %1$s sbeBlockLength(void)\n" +
             "    {\n" +
-            "        return SbeBlockLength;\n" +
+            "        return %2$s;\n" +
             "    }\n\n" +
-            "    static SBE_CONST_KIND %3$s SbeTemplateId{%4$s};\n" +
-            "    static const %3$s sbeTemplateId(void)\n" +
+            "    static SBE_CONSTEXPR const %3$s sbeTemplateId(void)\n" +
             "    {\n" +
-            "        return SbeTemplateId;\n" +
+            "        return %4$s;\n" +
             "    }\n\n" +
-            "    static SBE_CONST_KIND %5$s SbeSchemaId{%6$s};\n" +
-            "    static const %5$s sbeSchemaId(void)\n" +
+            "    static SBE_CONSTEXPR const %5$s sbeSchemaId(void)\n" +
             "    {\n" +
-            "        return SbeSchemaId;\n" +
+            "        return %6$s;\n" +
             "    }\n\n" +
-            "    static SBE_CONST_KIND %7$s SbeSchemaVersion{%8$s};\n" +
-            "    static const %7$s sbeSchemaVersion(void)\n" +
+            "    static SBE_CONSTEXPR const %7$s sbeSchemaVersion(void)\n" +
             "    {\n" +
-            "        return SbeSchemaVersion;\n" +
+            "        return %8$s;\n" +
             "    }\n\n" +
-            "    static SBE_CONST_KIND char SbeSemanticType[] = \"%9$s\";\n" +
-            "    static const char *sbeSemanticType(void)\n" +
+            "    static SBE_CONSTEXPR const char * sbeSemanticType(void)\n" +
             "    {\n" +
-            "        return SbeSemanticType;\n" +
+            "        return \"%9$s\";\n" +
             "    }\n\n" +
             "    std::uint64_t offset(void) const\n" +
             "    {\n" +
@@ -1498,7 +1466,7 @@ private CharSequence generateFields(final String containingClassName, final List
 
                 sb.append(String.format(
                     "\n" +
-                    indent + "    static SBE_CONST_KIND std::uint16_t %1$sId(void)\n" +
+                    indent + "    static SBE_CONSTEXPR const std::uint16_t %1$sId(void)\n" +
                     indent + "    {\n" +
                     indent + "        return %2$d;\n" +
                     indent + "    }\n\n",
@@ -1507,7 +1475,7 @@ private CharSequence generateFields(final String containingClassName, final List
                 ));
 
                 sb.append(String.format(
-                    indent + "    static SBE_CONST_KIND std::uint64_t %1$sSinceVersion(void)\n" +
+                    indent + "    static SBE_CONSTEXPR const std::uint64_t %1$sSinceVersion(void)\n" +
                     indent + "    {\n" +
                     indent + "         return %2$d;\n" +
                     indent + "    }\n\n" +