diff --git a/include/flatbuffers/idl.h b/include/flatbuffers/idl.h
index 7b04d0b50..04aef22cc 100644
--- a/include/flatbuffers/idl.h
+++ b/include/flatbuffers/idl.h
@@ -1057,10 +1057,6 @@ class Parser : public ParserState {
 
 // Utility functions for multiple generators:
 
-extern std::string MakeCamel(const std::string &in, bool first = true);
-
-extern std::string MakeScreamingCamel(const std::string &in);
-
 // Generate text (JSON) from a given FlatBuffer, and a given Parser
 // object that has been populated with the corresponding schema.
 // If ident_step is 0, no indentation will be generated. Additionally,
diff --git a/include/flatbuffers/util.h b/include/flatbuffers/util.h
index 690e63d30..a847dc00e 100644
--- a/include/flatbuffers/util.h
+++ b/include/flatbuffers/util.h
@@ -685,6 +685,26 @@ bool ReadEnvironmentVariable(const char *var_name,
 // MSVC specific: Send all assert reports to STDOUT to prevent CI hangs.
 void SetupDefaultCRTReportMode();
 
+enum class Case {
+  kUnknown = 0,
+  // TheQuickBrownFox
+  kUpperCamel = 1,
+  // theQuickBrownFox
+  kLowerCamel = 2,
+  // the_quick_brown_fox
+  kSnake = 3,
+  // THE_QUICK_BROWN_FOX
+  kScreamingSnake = 4,
+  // THEQUICKBROWNFOX
+  kAllUpper = 5,
+  // thequickbrownfox
+  kAllLower = 6,
+};
+
+// Convert the `input` string of case `input_case` to the specified `output_case`.
+std::string ConvertCase(const std::string &input, Case output_case,
+                    Case input_case = Case::kSnake);
+
 }  // namespace flatbuffers
 
 #endif  // FLATBUFFERS_UTIL_H_
diff --git a/src/bfbs_gen.h b/src/bfbs_gen.h
index f525d3ffd..12aafb376 100644
--- a/src/bfbs_gen.h
+++ b/src/bfbs_gen.h
@@ -93,20 +93,6 @@ static bool IsVector(const reflection::BaseType base_type) {
   return base_type == reflection::Vector;
 }
 
-static std::string MakeCamelCase(const std::string &in,
-                                 bool uppercase_first = true) {
-  std::string s;
-  for (size_t i = 0; i < in.length(); i++) {
-    if (!i && uppercase_first)
-      s += static_cast<char>(::toupper(static_cast<unsigned char>(in[0])));
-    else if (in[i] == '_' && i + 1 < in.length())
-      s += static_cast<char>(::toupper(static_cast<unsigned char>(in[++i])));
-    else
-      s += in[i];
-  }
-  return s;
-}
-
 static std::string Denamespace(const flatbuffers::String *name,
                                std::string &ns) {
   const size_t pos = name->str().find_last_of('.');
diff --git a/src/bfbs_gen_lua.cpp b/src/bfbs_gen_lua.cpp
index e5628830f..868bb14ed 100644
--- a/src/bfbs_gen_lua.cpp
+++ b/src/bfbs_gen_lua.cpp
@@ -150,7 +150,8 @@ class LuaBfbsGenerator : public BaseBfbsGenerator {
         if (field->deprecated()) { return; }
 
         const std::string field_name = NormalizeName(field->name());
-        const std::string field_name_camel_case = MakeCamelCase(field_name);
+        const std::string field_name_camel_case =
+            ConvertCase(field_name, Case::kUpperCamel);
         const r::BaseType base_type = field->type()->base_type();
 
         // Generate some fixed strings so we don't repeat outselves later.
@@ -346,18 +347,19 @@ class LuaBfbsGenerator : public BaseBfbsGenerator {
           const std::string field_name = NormalizeName(field->name());
 
           code += "function " + object_name + ".Add" +
-                  MakeCamelCase(field_name) + "(builder, " +
-                  MakeCamelCase(field_name, false) + ")\n";
+                  ConvertCase(field_name, Case::kUpperCamel) + "(builder, " +
+                  ConvertCase(field_name, Case::kLowerCamel) + ")\n";
           code += "  builder:Prepend" + GenerateMethod(field) + "Slot(" +
                   NumToString(field->id()) + ", " +
-                  MakeCamelCase(field_name, false) + ", " +
+                  ConvertCase(field_name, Case::kLowerCamel) + ", " +
                   DefaultValue(field) + ")\n";
           code += "end\n";
           code += "\n";
 
           if (IsVector(field->type()->base_type())) {
             code += "function " + object_name + ".Start" +
-                    MakeCamelCase(field_name) + "Vector(builder, numElems)\n";
+                    ConvertCase(field_name, Case::kUpperCamel) +
+                    "Vector(builder, numElems)\n";
 
             const int32_t element_size = field->type()->element_size();
             int32_t alignment = 0;
@@ -407,7 +409,8 @@ class LuaBfbsGenerator : public BaseBfbsGenerator {
             field_object, prefix + NormalizeName(field->name()) + "_");
       } else {
         signature +=
-            ", " + prefix + MakeCamelCase(NormalizeName(field->name()), false);
+            ", " + prefix +
+            ConvertCase(NormalizeName(field->name()), Case::kLowerCamel);
       }
     });
     return signature;
@@ -432,7 +435,8 @@ class LuaBfbsGenerator : public BaseBfbsGenerator {
             field_object, prefix + NormalizeName(field->name()) + "_");
       } else {
         code += "  builder:Prepend" + GenerateMethod(field) + "(" + prefix +
-                MakeCamelCase(NormalizeName(field->name()), false) + ")\n";
+                ConvertCase(NormalizeName(field->name()), Case::kLowerCamel) +
+                ")\n";
       }
     });
 
@@ -441,7 +445,9 @@ class LuaBfbsGenerator : public BaseBfbsGenerator {
 
   std::string GenerateMethod(const r::Field *field) const {
     const r::BaseType base_type = field->type()->base_type();
-    if (IsScalar(base_type)) { return MakeCamelCase(GenerateType(base_type)); }
+    if (IsScalar(base_type)) {
+      return ConvertCase(GenerateType(base_type), Case::kUpperCamel);
+    }
     if (IsStructOrTable(base_type)) { return "Struct"; }
     return "UOffsetTRelative";
   }
@@ -454,7 +460,9 @@ class LuaBfbsGenerator : public BaseBfbsGenerator {
       case r::Vector: return GenerateGetter(type, true);
       default:
         return "self.view:Get(flatbuffers.N." +
-               MakeCamelCase(GenerateType(type, element_type)) + ", ";
+               ConvertCase(GenerateType(type, element_type),
+                           Case::kUpperCamel) +
+               ", ";
     }
   }
 
diff --git a/src/idl_gen_cpp.cpp b/src/idl_gen_cpp.cpp
index b7f9a6e5d..bfe2a289e 100644
--- a/src/idl_gen_cpp.cpp
+++ b/src/idl_gen_cpp.cpp
@@ -248,10 +248,10 @@ class CppGenerator : public BaseGenerator {
       name.erase(name.length() - union_suffix_len, union_suffix_len);
     }
     if (opts_.cpp_object_api_field_case_style == IDLOptions::CaseStyle_Upper)
-      name = MakeCamel(name, true); /* upper */
+      name = ConvertCase(name, Case::kUpperCamel);
     else if (opts_.cpp_object_api_field_case_style ==
              IDLOptions::CaseStyle_Lower)
-      name = MakeCamel(name, false); /* lower */
+      name = ConvertCase(name, Case::kLowerCamel);
     // restore the union field type suffix
     if (is_union_type) name.append(UnionTypeFieldSuffix(), union_suffix_len);
     return EscapeKeyword(name);
diff --git a/src/idl_gen_csharp.cpp b/src/idl_gen_csharp.cpp
index 4639e4995..cb605defd 100644
--- a/src/idl_gen_csharp.cpp
+++ b/src/idl_gen_csharp.cpp
@@ -191,7 +191,7 @@ class CSharpGenerator : public BaseGenerator {
   }
 
   std::string Name(const FieldDef &field) const {
-    std::string name = MakeCamel(field.name, true);
+    std::string name = ConvertCase(field.name, Case::kUpperCamel);
     return EscapeKeyword(name);
   }
 
@@ -452,7 +452,7 @@ class CSharpGenerator : public BaseGenerator {
         if (type.base_type == BASE_TYPE_BOOL) {
           getter = "0!=" + getter;
         } else if (GenTypeBasic(type, false) != "byte") {
-          getter += MakeCamel(GenTypeBasic(type, false));
+          getter += ConvertCase(GenTypeBasic(type, false), Case::kUpperCamel);
         }
         return getter;
       }
@@ -468,7 +468,7 @@ class CSharpGenerator : public BaseGenerator {
     auto dest_cast = DestinationCast(type);
     auto getter = data_buffer + ".Get";
     if (GenTypeBasic(type, false) != "byte") {
-      getter += MakeCamel(GenTypeBasic(type, false));
+      getter += ConvertCase(GenTypeBasic(type, false), Case::kUpperCamel);
     }
     getter = dest_cast + getter + "(" + GenOffsetGetter(key_field, num) + ")" +
              dest_mask;
@@ -482,7 +482,7 @@ class CSharpGenerator : public BaseGenerator {
       std::string setter = "__p.bb.Put";
       if (GenTypeBasic(type, false) != "byte" &&
           type.base_type != BASE_TYPE_BOOL) {
-        setter += MakeCamel(GenTypeBasic(type, false));
+        setter += ConvertCase(GenTypeBasic(type, false), Case::kUpperCamel);
       }
       return setter;
     } else {
@@ -492,8 +492,9 @@ class CSharpGenerator : public BaseGenerator {
 
   // Returns the method name for use with add/put calls.
   std::string GenMethod(const Type &type) const {
-    return IsScalar(type.base_type) ? MakeCamel(GenTypeBasic(type, false))
-                                    : (IsStruct(type) ? "Struct" : "Offset");
+    return IsScalar(type.base_type)
+               ? ConvertCase(GenTypeBasic(type, false), Case::kUpperCamel)
+               : (IsStruct(type) ? "Struct" : "Offset");
   }
 
   // Recursively generate arguments for a constructor, to deal with nested
@@ -1026,7 +1027,7 @@ class CSharpGenerator : public BaseGenerator {
             underlying_type.base_type == BASE_TYPE_BOOL
                 ? "(byte)(" + EscapeKeyword(field.name) + " ? 1 : 0)"
                 : EscapeKeyword(field.name);
-        auto mutator_prefix = MakeCamel("mutate", true);
+        auto mutator_prefix = "Mutate";
         // A vector mutator also needs the index of the vector element it should
         // mutate.
         auto mutator_params = (is_series ? "(int j, " : "(") +
@@ -1061,9 +1062,10 @@ class CSharpGenerator : public BaseGenerator {
       }
       if (parser_.opts.java_primitive_has_method &&
           IsScalar(field.value.type.base_type) && !struct_def.fixed) {
-        auto vt_offset_constant = "  public static final int VT_" +
-                                  MakeScreamingCamel(field.name) + " = " +
-                                  NumToString(field.value.offset) + ";";
+        auto vt_offset_constant =
+            "  public static final int VT_" +
+            ConvertCase(field.name, Case::kScreamingSnake) + " = " +
+            NumToString(field.value.offset) + ";";
 
         code += vt_offset_constant;
         code += "\n";
@@ -1184,7 +1186,7 @@ class CSharpGenerator : public BaseGenerator {
         code += Name(field);
         code += "(FlatBufferBuilder builder, ";
         code += GenTypeBasic(field.value.type);
-        auto argname = MakeCamel(field.name, false);
+        auto argname = ConvertCase(field.name, Case::kLowerCamel);
         if (!IsScalar(field.value.type.base_type)) argname += "Offset";
         if (field.IsScalarOptional()) { code += "?"; }
         code += " " + EscapeKeyword(argname) + ") { builder.Add";
@@ -1987,7 +1989,7 @@ class CSharpGenerator : public BaseGenerator {
           }
           code += "] = _o";
           for (size_t i = 0, j = 0; i < array_lengths.size(); ++i) {
-            code += "." + MakeCamel(array_lengths[i].name, true);
+            code += "." + ConvertCase(array_lengths[i].name, Case::kUpperCamel);
             if (array_lengths[i].length <= 0) continue;
             code += "[idx" + NumToString(j++) + "]";
           }
@@ -1998,7 +2000,7 @@ class CSharpGenerator : public BaseGenerator {
         } else {
           code += "_o";
           for (size_t i = 0; i < array_lengths.size(); ++i) {
-            code += "." + MakeCamel(array_lengths[i].name, true);
+            code += "." + ConvertCase(array_lengths[i].name, Case::kUpperCamel);
           }
           code += ";";
         }
diff --git a/src/idl_gen_dart.cpp b/src/idl_gen_dart.cpp
index bf8209763..ec655bff1 100644
--- a/src/idl_gen_dart.cpp
+++ b/src/idl_gen_dart.cpp
@@ -154,10 +154,12 @@ class DartGenerator : public BaseGenerator {
 
   static std::string EscapeKeyword(const std::string &name) {
     for (size_t i = 0; i < sizeof(keywords) / sizeof(keywords[0]); i++) {
-      if (name == keywords[i]) { return MakeCamel(name + "_", false); }
+      if (name == keywords[i]) {
+        return ConvertCase(name + "_", Case::kLowerCamel);
+      }
     }
 
-    return MakeCamel(name, false);
+    return ConvertCase(name, Case::kLowerCamel);
   }
 
   void GenerateEnums(namespace_code_map *namespace_code) {
@@ -520,7 +522,7 @@ class DartGenerator : public BaseGenerator {
          it != non_deprecated_fields.end(); ++it) {
       const FieldDef &field = *it->second;
 
-      std::string field_name = MakeCamel(field.name, false);
+      std::string field_name = ConvertCase(field.name, Case::kLowerCamel);
       std::string defaultValue = getDefaultValue(field.value);
       std::string type_name =
           GenDartTypeName(field.value.type, struct_def.defined_namespace, field,
@@ -571,7 +573,7 @@ class DartGenerator : public BaseGenerator {
          it != non_deprecated_fields.end(); ++it) {
       const FieldDef &field = *it->second;
 
-      std::string field_name = MakeCamel(field.name, false);
+      std::string field_name = ConvertCase(field.name, Case::kLowerCamel);
       if (!constructor_args.empty()) constructor_args += ",\n";
       constructor_args += "      " + field_name + ": ";
 
@@ -664,7 +666,7 @@ class DartGenerator : public BaseGenerator {
       auto pair = *it;
       auto &field = *pair.second;
 
-      std::string field_name = MakeCamel(field.name, false);
+      std::string field_name = ConvertCase(field.name, Case::kLowerCamel);
       std::string defaultValue = getDefaultValue(field.value);
       bool isNullable = defaultValue.empty() && !struct_def.fixed;
       std::string type_name =
@@ -737,8 +739,8 @@ class DartGenerator : public BaseGenerator {
          it != non_deprecated_fields.end(); ++it) {
       auto pair = *it;
       auto &field = *pair.second;
-      code +=
-          MakeCamel(field.name, false) + ": $" + MakeCamel(field.name, false);
+      code += ConvertCase(field.name, Case::kLowerCamel) + ": $" +
+              ConvertCase(field.name, Case::kLowerCamel);
       if (it != non_deprecated_fields.end() - 1) { code += ", "; }
     }
     code += "}';\n";
@@ -878,21 +880,23 @@ class DartGenerator : public BaseGenerator {
       auto offset = pair.first;
 
       if (IsScalar(field.value.type.base_type)) {
-        code += "  int add" + MakeCamel(field.name) + "(";
+        code += "  int add" + ConvertCase(field.name, Case::kUpperCamel) + "(";
         code += GenDartTypeName(field.value.type, struct_def.defined_namespace,
                                 field);
-        code += "? " + MakeCamel(field.name, false) + ") {\n";
+        code += "? " + ConvertCase(field.name, Case::kLowerCamel) + ") {\n";
         code += "    fbBuilder.add" + GenType(field.value.type) + "(" +
                 NumToString(offset) + ", ";
-        code += MakeCamel(field.name, false);
+        code += ConvertCase(field.name, Case::kLowerCamel);
         if (field.value.type.enum_def) { code += "?.value"; }
         code += ");\n";
       } else if (IsStruct(field.value.type)) {
-        code += "  int add" + MakeCamel(field.name) + "(int offset) {\n";
+        code += "  int add" + ConvertCase(field.name, Case::kUpperCamel) +
+                "(int offset) {\n";
         code +=
             "    fbBuilder.addStruct(" + NumToString(offset) + ", offset);\n";
       } else {
-        code += "  int add" + MakeCamel(field.name) + "Offset(int? offset) {\n";
+        code += "  int add" + ConvertCase(field.name, Case::kUpperCamel) +
+                "Offset(int? offset) {\n";
         code +=
             "    fbBuilder.addOffset(" + NumToString(offset) + ", offset);\n";
       }
@@ -922,7 +926,7 @@ class DartGenerator : public BaseGenerator {
       code += "  final " +
               GenDartTypeName(field.value.type, struct_def.defined_namespace,
                               field, !struct_def.fixed, "ObjectBuilder") +
-              " _" + MakeCamel(field.name, false) + ";\n";
+              " _" + ConvertCase(field.name, Case::kLowerCamel) + ";\n";
     }
     code += "\n";
     code += "  " + builder_name + "(";
@@ -938,7 +942,7 @@ class DartGenerator : public BaseGenerator {
         code += (struct_def.fixed ? "required " : "") +
                 GenDartTypeName(field.value.type, struct_def.defined_namespace,
                                 field, !struct_def.fixed, "ObjectBuilder") +
-                " " + MakeCamel(field.name, false) + ",\n";
+                " " + ConvertCase(field.name, Case::kLowerCamel) + ",\n";
       }
       code += "  })\n";
       code += "      : ";
@@ -947,8 +951,8 @@ class DartGenerator : public BaseGenerator {
         auto pair = *it;
         auto &field = *pair.second;
 
-        code += "_" + MakeCamel(field.name, false) + " = " +
-                MakeCamel(field.name, false);
+        code += "_" + ConvertCase(field.name, Case::kLowerCamel) + " = " +
+                ConvertCase(field.name, Case::kLowerCamel);
         if (it == non_deprecated_fields.end() - 1) {
           code += ";\n\n";
         } else {
@@ -988,9 +992,10 @@ class DartGenerator : public BaseGenerator {
       if (IsScalar(field.value.type.base_type) || IsStruct(field.value.type))
         continue;
 
-      std::string offset_name = MakeCamel(field.name, false) + "Offset";
-      std::string field_name =
-          (prependUnderscore ? "_" : "") + MakeCamel(field.name, false);
+      std::string offset_name =
+          ConvertCase(field.name, Case::kLowerCamel) + "Offset";
+      std::string field_name = (prependUnderscore ? "_" : "") +
+                               ConvertCase(field.name, Case::kLowerCamel);
 
       // custom handling for fixed-sized struct in pack()
       if (pack && IsVector(field.value.type) &&
@@ -1000,7 +1005,7 @@ class DartGenerator : public BaseGenerator {
         code += "    if (" + field_name + " != null) {\n";
         code +=
             "      for (var e in " + field_name + "!) { e.pack(fbBuilder); }\n";
-        code += "      " + MakeCamel(field.name, false) +
+        code += "      " + ConvertCase(field.name, Case::kLowerCamel) +
                 "Offset = fbBuilder.endStructVector(" + field_name +
                 "!.length);\n";
         code += "    }\n";
@@ -1096,8 +1101,8 @@ class DartGenerator : public BaseGenerator {
       auto &field = *pair.second;
       auto offset = pair.first;
 
-      std::string field_name =
-          (prependUnderscore ? "_" : "") + MakeCamel(field.name, false);
+      std::string field_name = (prependUnderscore ? "_" : "") +
+                               ConvertCase(field.name, Case::kLowerCamel);
 
       if (IsScalar(field.value.type.base_type)) {
         code += "    fbBuilder.add" + GenType(field.value.type) + "(" +
@@ -1114,7 +1119,7 @@ class DartGenerator : public BaseGenerator {
         code += "    }\n";
       } else {
         code += "    fbBuilder.addOffset(" + NumToString(offset) + ", " +
-                MakeCamel(field.name, false) + "Offset);\n";
+                ConvertCase(field.name, Case::kLowerCamel) + "Offset);\n";
       }
     }
     code += "    return fbBuilder.endTable();\n";
diff --git a/src/idl_gen_go.cpp b/src/idl_gen_go.cpp
index ec69d3a8f..edadda83d 100644
--- a/src/idl_gen_go.cpp
+++ b/src/idl_gen_go.cpp
@@ -48,10 +48,12 @@ static const char *const g_golang_keywords[] = {
 static std::string GoIdentity(const std::string &name) {
   for (size_t i = 0;
        i < sizeof(g_golang_keywords) / sizeof(g_golang_keywords[0]); i++) {
-    if (name == g_golang_keywords[i]) { return MakeCamel(name + "_", false); }
+    if (name == g_golang_keywords[i]) {
+      return ConvertCase(name + "_", Case::kLowerCamel);
+    }
   }
 
-  return MakeCamel(name, false);
+  return ConvertCase(name, Case::kLowerCamel);
 }
 
 class GoGenerator : public BaseGenerator {
@@ -315,7 +317,7 @@ class GoGenerator : public BaseGenerator {
     std::string &code = *code_ptr;
 
     GenReceiver(struct_def, code_ptr);
-    code += " " + MakeCamel(field.name) + "Length(";
+    code += " " + ConvertCase(field.name, Case::kUpperCamel) + "Length(";
     code += ") int " + OffsetPrefix(field);
     code += "\t\treturn rcv._tab.VectorLen(o)\n\t}\n";
     code += "\treturn 0\n}\n\n";
@@ -327,7 +329,7 @@ class GoGenerator : public BaseGenerator {
     std::string &code = *code_ptr;
 
     GenReceiver(struct_def, code_ptr);
-    code += " " + MakeCamel(field.name) + "Bytes(";
+    code += " " + ConvertCase(field.name, Case::kUpperCamel) + "Bytes(";
     code += ") []byte " + OffsetPrefix(field);
     code += "\t\treturn rcv._tab.ByteVector(o + rcv._tab.Pos)\n\t}\n";
     code += "\treturn nil\n}\n\n";
@@ -339,7 +341,7 @@ class GoGenerator : public BaseGenerator {
     std::string &code = *code_ptr;
     std::string getter = GenGetter(field.value.type);
     GenReceiver(struct_def, code_ptr);
-    code += " " + MakeCamel(field.name);
+    code += " " + ConvertCase(field.name, Case::kUpperCamel);
     code += "() " + TypeName(field) + " {\n";
     code += "\treturn " +
             CastToEnum(field.value.type,
@@ -354,7 +356,7 @@ class GoGenerator : public BaseGenerator {
     std::string &code = *code_ptr;
     std::string getter = GenGetter(field.value.type);
     GenReceiver(struct_def, code_ptr);
-    code += " " + MakeCamel(field.name);
+    code += " " + ConvertCase(field.name, Case::kUpperCamel);
     code += "() " + TypeName(field) + " ";
     code += OffsetPrefix(field);
     if (field.IsScalarOptional()) {
@@ -377,7 +379,7 @@ class GoGenerator : public BaseGenerator {
                               const FieldDef &field, std::string *code_ptr) {
     std::string &code = *code_ptr;
     GenReceiver(struct_def, code_ptr);
-    code += " " + MakeCamel(field.name);
+    code += " " + ConvertCase(field.name, Case::kUpperCamel);
     code += "(obj *" + TypeName(field);
     code += ") *" + TypeName(field);
     code += " {\n";
@@ -396,7 +398,7 @@ class GoGenerator : public BaseGenerator {
                              std::string *code_ptr) {
     std::string &code = *code_ptr;
     GenReceiver(struct_def, code_ptr);
-    code += " " + MakeCamel(field.name);
+    code += " " + ConvertCase(field.name, Case::kUpperCamel);
     code += "(obj *";
     code += TypeName(field);
     code += ") *" + TypeName(field) + " " + OffsetPrefix(field);
@@ -418,7 +420,7 @@ class GoGenerator : public BaseGenerator {
                       std::string *code_ptr) {
     std::string &code = *code_ptr;
     GenReceiver(struct_def, code_ptr);
-    code += " " + MakeCamel(field.name);
+    code += " " + ConvertCase(field.name, Case::kUpperCamel);
     code += "() " + TypeName(field) + " ";
     code += OffsetPrefix(field) + "\t\treturn " + GenGetter(field.value.type);
     code += "(o + rcv._tab.Pos)\n\t}\n\treturn nil\n";
@@ -430,7 +432,7 @@ class GoGenerator : public BaseGenerator {
                      std::string *code_ptr) {
     std::string &code = *code_ptr;
     GenReceiver(struct_def, code_ptr);
-    code += " " + MakeCamel(field.name) + "(";
+    code += " " + ConvertCase(field.name, Case::kUpperCamel) + "(";
     code += "obj " + GenTypePointer(field.value.type) + ") bool ";
     code += OffsetPrefix(field);
     code += "\t\t" + GenGetter(field.value.type);
@@ -446,7 +448,7 @@ class GoGenerator : public BaseGenerator {
     auto vectortype = field.value.type.VectorType();
 
     GenReceiver(struct_def, code_ptr);
-    code += " " + MakeCamel(field.name);
+    code += " " + ConvertCase(field.name, Case::kUpperCamel);
     code += "(obj *" + TypeName(field);
     code += ", j int) bool " + OffsetPrefix(field);
     code += "\t\tx := rcv._tab.Vector(o)\n";
@@ -469,7 +471,7 @@ class GoGenerator : public BaseGenerator {
     auto vectortype = field.value.type.VectorType();
 
     GenReceiver(struct_def, code_ptr);
-    code += " " + MakeCamel(field.name);
+    code += " " + ConvertCase(field.name, Case::kUpperCamel);
     code += "(j int) " + TypeName(field) + " ";
     code += OffsetPrefix(field);
     code += "\t\ta := rcv._tab.Vector(o)\n";
@@ -573,7 +575,8 @@ class GoGenerator : public BaseGenerator {
   void BuildFieldOfTable(const StructDef &struct_def, const FieldDef &field,
                          const size_t offset, std::string *code_ptr) {
     std::string &code = *code_ptr;
-    code += "func " + struct_def.name + "Add" + MakeCamel(field.name);
+    code += "func " + struct_def.name + "Add" +
+            ConvertCase(field.name, Case::kUpperCamel);
     code += "(builder *flatbuffers.Builder, ";
     code += GoIdentity(field.name) + " ";
     if (!IsScalar(field.value.type.base_type) && (!struct_def.fixed)) {
@@ -611,7 +614,7 @@ class GoGenerator : public BaseGenerator {
                           std::string *code_ptr) {
     std::string &code = *code_ptr;
     code += "func " + struct_def.name + "Start";
-    code += MakeCamel(field.name);
+    code += ConvertCase(field.name, Case::kUpperCamel);
     code += "Vector(builder *flatbuffers.Builder, numElems int) ";
     code += "flatbuffers.UOffsetT {\n\treturn builder.StartVector(";
     auto vector_type = field.value.type.VectorType();
@@ -683,10 +686,11 @@ class GoGenerator : public BaseGenerator {
   void MutateScalarFieldOfStruct(const StructDef &struct_def,
                                  const FieldDef &field, std::string *code_ptr) {
     std::string &code = *code_ptr;
-    std::string type = MakeCamel(GenTypeBasic(field.value.type));
+    std::string type =
+        ConvertCase(GenTypeBasic(field.value.type), Case::kUpperCamel);
     std::string setter = "rcv._tab.Mutate" + type;
     GenReceiver(struct_def, code_ptr);
-    code += " Mutate" + MakeCamel(field.name);
+    code += " Mutate" + ConvertCase(field.name, Case::kUpperCamel);
     code += "(n " + GenTypeGet(field.value.type) + ") bool {\n\treturn " + setter;
     code += "(rcv._tab.Pos+flatbuffers.UOffsetT(";
     code += NumToString(field.value.offset) + "), ";
@@ -697,10 +701,11 @@ class GoGenerator : public BaseGenerator {
   void MutateScalarFieldOfTable(const StructDef &struct_def,
                                 const FieldDef &field, std::string *code_ptr) {
     std::string &code = *code_ptr;
-    std::string type = MakeCamel(GenTypeBasic(field.value.type));
+    std::string type =
+        ConvertCase(GenTypeBasic(field.value.type), Case::kUpperCamel);
     std::string setter = "rcv._tab.Mutate" + type + "Slot";
     GenReceiver(struct_def, code_ptr);
-    code += " Mutate" + MakeCamel(field.name);
+    code += " Mutate" + ConvertCase(field.name, Case::kUpperCamel);
     code += "(n " + GenTypeGet(field.value.type) + ") bool {\n\treturn ";
     code += setter + "(" + NumToString(field.value.offset) + ", ";
     code += CastToBaseType(field.value.type, "n") + ")\n";
@@ -713,10 +718,10 @@ class GoGenerator : public BaseGenerator {
                                         std::string *code_ptr) {
     std::string &code = *code_ptr;
     auto vectortype = field.value.type.VectorType();
-    std::string type = MakeCamel(GenTypeBasic(vectortype));
+    std::string type = ConvertCase(GenTypeBasic(vectortype), Case::kUpperCamel);
     std::string setter = "rcv._tab.Mutate" + type;
     GenReceiver(struct_def, code_ptr);
-    code += " Mutate" + MakeCamel(field.name);
+    code += " Mutate" + ConvertCase(field.name, Case::kUpperCamel);
     code += "(j int, n " + TypeName(field) + ") bool ";
     code += OffsetPrefix(field);
     code += "\t\ta := rcv._tab.Vector(o)\n";
@@ -819,7 +824,7 @@ class GoGenerator : public BaseGenerator {
           field.value.type.enum_def != nullptr &&
           field.value.type.enum_def->is_union)
         continue;
-      code += "\t" + MakeCamel(field.name) + " ";
+      code += "\t" + ConvertCase(field.name, Case::kUpperCamel) + " ";
       if (field.IsScalarOptional()) {
         code += "*";
       }
@@ -901,53 +906,66 @@ class GoGenerator : public BaseGenerator {
       if (field.deprecated) continue;
       if (IsScalar(field.value.type.base_type)) continue;
 
-      std::string offset = MakeCamel(field.name, false) + "Offset";
+      std::string offset =
+          ConvertCase(field.name, Case::kLowerCamel) + "Offset";
 
       if (IsString(field.value.type)) {
         code += "\t" + offset + " := builder.CreateString(t." +
-                MakeCamel(field.name) + ")\n";
+                ConvertCase(field.name, Case::kUpperCamel) + ")\n";
       } else if (IsVector(field.value.type) &&
                  field.value.type.element == BASE_TYPE_UCHAR &&
                  field.value.type.enum_def == nullptr) {
         code += "\t" + offset + " := flatbuffers.UOffsetT(0)\n";
-        code += "\tif t." + MakeCamel(field.name) + " != nil {\n";
+        code += "\tif t." + ConvertCase(field.name, Case::kUpperCamel) +
+                " != nil {\n";
         code += "\t\t" + offset + " = builder.CreateByteString(t." +
-                MakeCamel(field.name) + ")\n";
+                ConvertCase(field.name, Case::kUpperCamel) + ")\n";
         code += "\t}\n";
       } else if (IsVector(field.value.type)) {
         code += "\t" + offset + " := flatbuffers.UOffsetT(0)\n";
-        code += "\tif t." + MakeCamel(field.name) + " != nil {\n";
-        std::string length = MakeCamel(field.name, false) + "Length";
-        std::string offsets = MakeCamel(field.name, false) + "Offsets";
-        code += "\t\t" + length + " := len(t." + MakeCamel(field.name) + ")\n";
+        code += "\tif t." + ConvertCase(field.name, Case::kUpperCamel) +
+                " != nil {\n";
+        std::string length =
+            ConvertCase(field.name, Case::kLowerCamel) + "Length";
+        std::string offsets =
+            ConvertCase(field.name, Case::kLowerCamel) + "Offsets";
+        code += "\t\t" + length + " := len(t." +
+                ConvertCase(field.name, Case::kUpperCamel) + ")\n";
         if (field.value.type.element == BASE_TYPE_STRING) {
           code += "\t\t" + offsets + " := make([]flatbuffers.UOffsetT, " +
                   length + ")\n";
           code += "\t\tfor j := 0; j < " + length + "; j++ {\n";
           code += "\t\t\t" + offsets + "[j] = builder.CreateString(t." +
-                  MakeCamel(field.name) + "[j])\n";
+                  ConvertCase(field.name, Case::kUpperCamel) + "[j])\n";
           code += "\t\t}\n";
         } else if (field.value.type.element == BASE_TYPE_STRUCT &&
                    !field.value.type.struct_def->fixed) {
           code += "\t\t" + offsets + " := make([]flatbuffers.UOffsetT, " +
                   length + ")\n";
           code += "\t\tfor j := 0; j < " + length + "; j++ {\n";
-          code += "\t\t\t" + offsets + "[j] = t." + MakeCamel(field.name) +
+          code += "\t\t\t" + offsets + "[j] = t." +
+                  ConvertCase(field.name, Case::kUpperCamel) +
                   "[j].Pack(builder)\n";
           code += "\t\t}\n";
         }
-        code += "\t\t" + struct_def.name + "Start" + MakeCamel(field.name) +
+        code += "\t\t" + struct_def.name + "Start" +
+                ConvertCase(field.name, Case::kUpperCamel) +
                 "Vector(builder, " + length + ")\n";
         code += "\t\tfor j := " + length + " - 1; j >= 0; j-- {\n";
         if (IsScalar(field.value.type.element)) {
-          code += "\t\t\tbuilder.Prepend" +
-                  MakeCamel(GenTypeBasic(field.value.type.VectorType())) + "(" +
-                  CastToBaseType(field.value.type.VectorType(),
-                                 "t." + MakeCamel(field.name) + "[j]") +
-                  ")\n";
+          code +=
+              "\t\t\tbuilder.Prepend" +
+              ConvertCase(GenTypeBasic(field.value.type.VectorType()),
+                          Case::kUpperCamel) +
+              "(" +
+              CastToBaseType(
+                  field.value.type.VectorType(),
+                  "t." + ConvertCase(field.name, Case::kUpperCamel) + "[j]") +
+              ")\n";
         } else if (field.value.type.element == BASE_TYPE_STRUCT &&
                    field.value.type.struct_def->fixed) {
-          code += "\t\t\tt." + MakeCamel(field.name) + "[j].Pack(builder)\n";
+          code += "\t\t\tt." + ConvertCase(field.name, Case::kUpperCamel) +
+                  "[j].Pack(builder)\n";
         } else {
           code += "\t\t\tbuilder.PrependUOffsetT(" + offsets + "[j])\n";
         }
@@ -956,11 +974,11 @@ class GoGenerator : public BaseGenerator {
         code += "\t}\n";
       } else if (field.value.type.base_type == BASE_TYPE_STRUCT) {
         if (field.value.type.struct_def->fixed) continue;
-        code += "\t" + offset + " := t." + MakeCamel(field.name) +
-                ".Pack(builder)\n";
+        code += "\t" + offset + " := t." +
+                ConvertCase(field.name, Case::kUpperCamel) + ".Pack(builder)\n";
       } else if (field.value.type.base_type == BASE_TYPE_UNION) {
-        code += "\t" + offset + " := t." + MakeCamel(field.name) +
-                ".Pack(builder)\n";
+        code += "\t" + offset + " := t." +
+                ConvertCase(field.name, Case::kUpperCamel) + ".Pack(builder)\n";
         code += "\t\n";
       } else {
         FLATBUFFERS_ASSERT(0);
@@ -972,17 +990,21 @@ class GoGenerator : public BaseGenerator {
       const FieldDef &field = **it;
       if (field.deprecated) continue;
 
-      std::string offset = MakeCamel(field.name, false) + "Offset";
+      std::string offset =
+          ConvertCase(field.name, Case::kLowerCamel) + "Offset";
       if (IsScalar(field.value.type.base_type)) {
         std::string prefix;
         if (field.IsScalarOptional()) {
-          code += "\tif t." + MakeCamel(field.name) + " != nil {\n\t";
+          code += "\tif t." + ConvertCase(field.name, Case::kUpperCamel) +
+                  " != nil {\n\t";
           prefix = "*";
         }
         if (field.value.type.enum_def == nullptr ||
             !field.value.type.enum_def->is_union) {
-          code += "\t" + struct_def.name + "Add" + MakeCamel(field.name) +
-                  "(builder, " + prefix + "t." + MakeCamel(field.name) + ")\n";
+          code += "\t" + struct_def.name + "Add" +
+                  ConvertCase(field.name, Case::kUpperCamel) + "(builder, " +
+                  prefix + "t." + ConvertCase(field.name, Case::kUpperCamel) +
+                  ")\n";
         }
         if (field.IsScalarOptional()) {
           code += "\t}\n";
@@ -990,18 +1012,23 @@ class GoGenerator : public BaseGenerator {
       } else {
         if (field.value.type.base_type == BASE_TYPE_STRUCT &&
             field.value.type.struct_def->fixed) {
-          code += "\t" + offset + " := t." + MakeCamel(field.name) +
+          code += "\t" + offset + " := t." +
+                  ConvertCase(field.name, Case::kUpperCamel) +
                   ".Pack(builder)\n";
         } else if (field.value.type.enum_def != nullptr &&
                    field.value.type.enum_def->is_union) {
-          code += "\tif t." + MakeCamel(field.name) + " != nil {\n";
+          code += "\tif t." + ConvertCase(field.name, Case::kUpperCamel) +
+                  " != nil {\n";
           code += "\t\t" + struct_def.name + "Add" +
-                  MakeCamel(field.name + UnionTypeFieldSuffix()) +
-                  "(builder, t." + MakeCamel(field.name) + ".Type)\n";
+                  ConvertCase(field.name + UnionTypeFieldSuffix(),
+                              Case::kUpperCamel) +
+                  "(builder, t." + ConvertCase(field.name, Case::kUpperCamel) +
+                  ".Type)\n";
           code += "\t}\n";
         }
-        code += "\t" + struct_def.name + "Add" + MakeCamel(field.name) +
-                "(builder, " + offset + ")\n";
+        code += "\t" + struct_def.name + "Add" +
+                ConvertCase(field.name, Case::kUpperCamel) + "(builder, " +
+                offset + ")\n";
       }
     }
     code += "\treturn " + struct_def.name + "End(builder)\n";
@@ -1018,8 +1045,9 @@ class GoGenerator : public BaseGenerator {
          it != struct_def.fields.vec.end(); ++it) {
       const FieldDef &field = **it;
       if (field.deprecated) continue;
-      std::string field_name_camel = MakeCamel(field.name);
-      std::string length = MakeCamel(field.name, false) + "Length";
+      std::string field_name_camel = ConvertCase(field.name, Case::kUpperCamel);
+      std::string length =
+          ConvertCase(field.name, Case::kLowerCamel) + "Length";
       if (IsScalar(field.value.type.base_type)) {
         if (field.value.type.enum_def != nullptr &&
             field.value.type.enum_def->is_union)
@@ -1062,13 +1090,15 @@ class GoGenerator : public BaseGenerator {
         code += "\tt." + field_name_camel + " = rcv." + field_name_camel +
                 "(nil).UnPack()\n";
       } else if (field.value.type.base_type == BASE_TYPE_UNION) {
-        std::string field_table = MakeCamel(field.name, false) + "Table";
+        std::string field_table =
+            ConvertCase(field.name, Case::kLowerCamel) + "Table";
         code += "\t" + field_table + " := flatbuffers.Table{}\n";
-        code +=
-            "\tif rcv." + MakeCamel(field.name) + "(&" + field_table + ") {\n";
+        code += "\tif rcv." + ConvertCase(field.name, Case::kUpperCamel) +
+                "(&" + field_table + ") {\n";
         code += "\t\tt." + field_name_camel + " = rcv." +
-                MakeCamel(field.name + UnionTypeFieldSuffix()) + "().UnPack(" +
-                field_table + ")\n";
+                ConvertCase(field.name + UnionTypeFieldSuffix(),
+                            Case::kUpperCamel) +
+                "().UnPack(" + field_table + ")\n";
         code += "\t}\n";
       } else {
         FLATBUFFERS_ASSERT(0);
@@ -1104,11 +1134,14 @@ class GoGenerator : public BaseGenerator {
          it != struct_def.fields.vec.end(); ++it) {
       const FieldDef &field = **it;
       if (field.value.type.base_type == BASE_TYPE_STRUCT) {
-        StructPackArgs(*field.value.type.struct_def,
-                       (nameprefix + MakeCamel(field.name) + ".").c_str(),
-                       code_ptr);
+        StructPackArgs(
+            *field.value.type.struct_def,
+            (nameprefix + ConvertCase(field.name, Case::kUpperCamel) + ".")
+                .c_str(),
+            code_ptr);
       } else {
-        code += std::string(", t.") + nameprefix + MakeCamel(field.name);
+        code += std::string(", t.") + nameprefix +
+                ConvertCase(field.name, Case::kUpperCamel);
       }
     }
   }
@@ -1123,11 +1156,12 @@ class GoGenerator : public BaseGenerator {
          it != struct_def.fields.vec.end(); ++it) {
       const FieldDef &field = **it;
       if (field.value.type.base_type == BASE_TYPE_STRUCT) {
-        code += "\tt." + MakeCamel(field.name) + " = rcv." +
-                MakeCamel(field.name) + "(nil).UnPack()\n";
+        code += "\tt." + ConvertCase(field.name, Case::kUpperCamel) +
+                " = rcv." + ConvertCase(field.name, Case::kUpperCamel) +
+                "(nil).UnPack()\n";
       } else {
-        code += "\tt." + MakeCamel(field.name) + " = rcv." +
-                MakeCamel(field.name) + "()\n";
+        code += "\tt." + ConvertCase(field.name, Case::kUpperCamel) +
+                " = rcv." + ConvertCase(field.name, Case::kUpperCamel) + "()\n";
       }
     }
     code += "}\n\n";
@@ -1181,14 +1215,16 @@ class GoGenerator : public BaseGenerator {
       case BASE_TYPE_STRING: return "rcv._tab.ByteVector";
       case BASE_TYPE_UNION: return "rcv._tab.Union";
       case BASE_TYPE_VECTOR: return GenGetter(type.VectorType());
-      default: return "rcv._tab.Get" + MakeCamel(GenTypeBasic(type));
+      default:
+        return "rcv._tab.Get" +
+               ConvertCase(GenTypeBasic(type), Case::kUpperCamel);
     }
   }
 
   // Returns the method name for use with add/put calls.
   std::string GenMethod(const FieldDef &field) {
     return IsScalar(field.value.type.base_type)
-               ? MakeCamel(GenTypeBasic(field.value.type))
+               ? ConvertCase(GenTypeBasic(field.value.type), Case::kUpperCamel)
                : (IsStruct(field.value.type) ? "Struct" : "UOffsetT");
   }
 
diff --git a/src/idl_gen_java.cpp b/src/idl_gen_java.cpp
index 01dce4a3b..ee0939120 100644
--- a/src/idl_gen_java.cpp
+++ b/src/idl_gen_java.cpp
@@ -375,7 +375,7 @@ class JavaGenerator : public BaseGenerator {
       code += "};\n\n";
       code += "  public static ";
       code += "String";
-      code += " " + MakeCamel("name", false);
+      code += " name";
       code += "(int e) { return names[e";
       if (enum_def.MinValue()->IsNonZero())
         code += " - " + enum_def.MinValue()->name;
@@ -399,7 +399,7 @@ class JavaGenerator : public BaseGenerator {
         if (type.base_type == BASE_TYPE_BOOL) {
           getter = "0!=" + getter;
         } else if (GenTypeBasic(type) != "byte") {
-          getter += MakeCamel(GenTypeBasic(type));
+          getter += ConvertCase(GenTypeBasic(type), Case::kUpperCamel);
         }
         return getter;
       }
@@ -415,7 +415,7 @@ class JavaGenerator : public BaseGenerator {
     auto dest_cast = DestinationCast(type);
     auto getter = data_buffer + ".get";
     if (GenTypeBasic(type) != "byte") {
-      getter += MakeCamel(GenTypeBasic(type));
+      getter += ConvertCase(GenTypeBasic(type), Case::kUpperCamel);
     }
     getter = dest_cast + getter + "(" + GenOffsetGetter(key_field, num) + ")" +
              dest_mask;
@@ -428,7 +428,7 @@ class JavaGenerator : public BaseGenerator {
     if (IsScalar(type.base_type)) {
       std::string setter = "bb.put";
       if (GenTypeBasic(type) != "byte" && type.base_type != BASE_TYPE_BOOL) {
-        setter += MakeCamel(GenTypeBasic(type));
+        setter += ConvertCase(GenTypeBasic(type), Case::kUpperCamel);
       }
       return setter;
     } else {
@@ -438,8 +438,9 @@ class JavaGenerator : public BaseGenerator {
 
   // Returns the method name for use with add/put calls.
   std::string GenMethod(const Type &type) const {
-    return IsScalar(type.base_type) ? MakeCamel(GenTypeBasic(type))
-                                    : (IsStruct(type) ? "Struct" : "Offset");
+    return IsScalar(type.base_type)
+               ? ConvertCase(GenTypeBasic(type), Case::kUpperCamel)
+               : (IsStruct(type) ? "Struct" : "Offset");
   }
 
   // Recursively generate arguments for a constructor, to deal with nested
@@ -467,7 +468,7 @@ class JavaGenerator : public BaseGenerator {
         for (size_t i = 0; i < array_cnt; i++) code += "[]";
         code += " ";
         code += nameprefix;
-        code += MakeCamel(field.name, false);
+        code += ConvertCase(field.name, Case::kLowerCamel);
       }
     }
   }
@@ -514,7 +515,8 @@ class JavaGenerator : public BaseGenerator {
           code += indent + "  builder.put";
           code += GenMethod(type) + "(";
           code += SourceCast(type);
-          auto argname = nameprefix + MakeCamel(field.name, false);
+          auto argname =
+              nameprefix + ConvertCase(field.name, Case::kLowerCamel);
           code += argname;
           size_t array_cnt = index + (IsArray(field_type) ? 1 : 0);
           for (size_t i = 0; in_array && i < array_cnt; i++) {
@@ -682,7 +684,7 @@ class JavaGenerator : public BaseGenerator {
           "  public " +
           (field.IsRequired() ? "" : GenNullableAnnotation(field.value.type)) +
           GenPureAnnotation(field.value.type) + type_name_dest + optional +
-          " " + MakeCamel(field.name, false);
+          " " + ConvertCase(field.name, Case::kLowerCamel);
       std::string obj = "obj";
 
       // Most field accessors need to retrieve and test the field offset first,
@@ -696,7 +698,7 @@ class JavaGenerator : public BaseGenerator {
       if (field.value.type.base_type == BASE_TYPE_STRUCT) {
         // Calls the accessor that takes an accessor object with a new object.
         code += method_start + "() { return ";
-        code += MakeCamel(field.name, false);
+        code += ConvertCase(field.name, Case::kLowerCamel);
         code += "(new ";
         code += type_name + "()); }\n";
       } else if (IsSeries(field.value.type) &&
@@ -704,7 +706,7 @@ class JavaGenerator : public BaseGenerator {
         // Accessors for vectors of structs also take accessor objects, this
         // generates a variant without that argument.
         code += method_start + "(int j) { return ";
-        code += MakeCamel(field.name, false);
+        code += ConvertCase(field.name, Case::kLowerCamel);
         code += "(new " + type_name + "(), j); }\n";
       }
 
@@ -804,7 +806,7 @@ class JavaGenerator : public BaseGenerator {
       code += member_suffix;
       code += "}\n";
       if (IsVector(field.value.type)) {
-        code += "  public int " + MakeCamel(field.name, false);
+        code += "  public int " + ConvertCase(field.name, Case::kLowerCamel);
         code += "Length";
         code += "()";
         code += offset_prefix;
@@ -821,7 +823,7 @@ class JavaGenerator : public BaseGenerator {
             if (key_field.key) {
               auto qualified_name = WrapInNameSpace(sd);
               code += "  public " + qualified_name + " ";
-              code += MakeCamel(field.name, false) + "ByKey(";
+              code += ConvertCase(field.name, Case::kLowerCamel) + "ByKey(";
               code += GenTypeNameDest(key_field.value.type) + " key)";
               code += offset_prefix;
               code += qualified_name + ".__lookup_by_key(";
@@ -830,7 +832,7 @@ class JavaGenerator : public BaseGenerator {
               code += "bb) : null; ";
               code += "}\n";
               code += "  public " + qualified_name + " ";
-              code += MakeCamel(field.name, false) + "ByKey(";
+              code += ConvertCase(field.name, Case::kLowerCamel) + "ByKey(";
               code += qualified_name + " obj, ";
               code += GenTypeNameDest(key_field.value.type) + " key)";
               code += offset_prefix;
@@ -848,7 +850,8 @@ class JavaGenerator : public BaseGenerator {
         std::string vector_type_name;
         const auto &element_base_type = field.value.type.VectorType().base_type;
         if (IsScalar(element_base_type)) {
-          vector_type_name = MakeCamel(type_name, true) + "Vector";
+          vector_type_name =
+              ConvertCase(type_name, Case::kUpperCamel) + "Vector";
         } else if (element_base_type == BASE_TYPE_STRING) {
           vector_type_name = "StringVector";
         } else if (element_base_type == BASE_TYPE_UNION) {
@@ -856,12 +859,12 @@ class JavaGenerator : public BaseGenerator {
         } else {
           vector_type_name = type_name + ".Vector";
         }
-        auto vector_method_start = GenNullableAnnotation(field.value.type) +
-                                   "  public " + vector_type_name + optional +
-                                   " " + MakeCamel(field.name, false) +
-                                   "Vector";
+        auto vector_method_start =
+            GenNullableAnnotation(field.value.type) + "  public " +
+            vector_type_name + optional + " " +
+            ConvertCase(field.name, Case::kLowerCamel) + "Vector";
         code += vector_method_start + "() { return ";
-        code += MakeCamel(field.name, false) + "Vector";
+        code += ConvertCase(field.name, Case::kLowerCamel) + "Vector";
         code += "(new " + vector_type_name + "()); }\n";
         code += vector_method_start + "(" + vector_type_name + " obj)";
         code += offset_prefix + conditional_cast + obj + ".__assign(";
@@ -877,7 +880,7 @@ class JavaGenerator : public BaseGenerator {
            IsScalar(field.value.type.VectorType().base_type)) ||
           IsString(field.value.type)) {
         code += "  public ByteBuffer ";
-        code += MakeCamel(field.name, false);
+        code += ConvertCase(field.name, Case::kLowerCamel);
         code += "AsByteBuffer() { return ";
         code += "__vector_as_bytebuffer(";
         code += NumToString(field.value.offset) + ", ";
@@ -886,7 +889,7 @@ class JavaGenerator : public BaseGenerator {
                                 : InlineSize(field.value.type.VectorType()));
         code += "); }\n";
         code += "  public ByteBuffer ";
-        code += MakeCamel(field.name, false);
+        code += ConvertCase(field.name, Case::kLowerCamel);
         code += "InByteBuffer(ByteBuffer _bb) { return ";
         code += "__vector_in_bytebuffer(_bb, ";
         code += NumToString(field.value.offset) + ", ";
@@ -898,8 +901,8 @@ class JavaGenerator : public BaseGenerator {
       // generate object accessors if is nested_flatbuffer
       if (field.nested_flatbuffer) {
         auto nested_type_name = WrapInNameSpace(*field.nested_flatbuffer);
-        auto nested_method_name =
-            MakeCamel(field.name, false) + "As" + field.nested_flatbuffer->name;
+        auto nested_method_name = ConvertCase(field.name, Case::kLowerCamel) +
+                                  "As" + field.nested_flatbuffer->name;
         auto get_nested_method_name = nested_method_name;
         code += "  public " + nested_type_name + " ";
         code += nested_method_name + "() { return ";
@@ -925,7 +928,7 @@ class JavaGenerator : public BaseGenerator {
         auto setter_parameter = underlying_type.base_type == BASE_TYPE_BOOL
                                     ? "(byte)(" + field.name + " ? 1 : 0)"
                                     : field.name;
-        auto mutator_prefix = MakeCamel("mutate", false);
+        auto mutator_prefix = "mutate";
         // A vector mutator also needs the index of the vector element it should
         // mutate.
         auto mutator_params = (is_series ? "(int j, " : "(") +
@@ -943,7 +946,7 @@ class JavaGenerator : public BaseGenerator {
         if (IsScalar(underlying_type.base_type) && !IsUnion(field.value.type)) {
           code += "  public ";
           code += struct_def.fixed ? "void " : "boolean ";
-          code += mutator_prefix + MakeCamel(field.name, true);
+          code += mutator_prefix + ConvertCase(field.name, Case::kUpperCamel);
           code += mutator_params;
           if (struct_def.fixed) {
             code += GenSetter(underlying_type) + "(" + setter_index + ", ";
@@ -959,9 +962,10 @@ class JavaGenerator : public BaseGenerator {
       }
       if (parser_.opts.java_primitive_has_method &&
           IsScalar(field.value.type.base_type) && !struct_def.fixed) {
-        auto vt_offset_constant = "  public static final int VT_" +
-                                  MakeScreamingCamel(field.name) + " = " +
-                                  NumToString(field.value.offset) + ";";
+        auto vt_offset_constant =
+            "  public static final int VT_" +
+            ConvertCase(field.name, Case::kScreamingSnake) + " = " +
+            NumToString(field.value.offset) + ";";
 
         code += vt_offset_constant;
         code += "\n";
@@ -1011,7 +1015,7 @@ class JavaGenerator : public BaseGenerator {
         for (auto it = struct_def.fields.vec.begin();
              it != struct_def.fields.vec.end(); ++it) {
           auto &field = **it;
-          auto field_name = MakeCamel(field.name, false);
+          auto field_name = ConvertCase(field.name, Case::kLowerCamel);
           if (field.deprecated) continue;
           code += ",\n      ";
           code += GenTypeBasic(DestinationType(field.value.type, false));
@@ -1027,8 +1031,8 @@ class JavaGenerator : public BaseGenerator {
           for (auto it = struct_def.fields.vec.rbegin();
                it != struct_def.fields.vec.rend(); ++it) {
             auto &field = **it;
-            auto field_name = MakeCamel(field.name, false);
-            auto method_name = MakeCamel(field.name, true);
+            auto field_name = ConvertCase(field.name, Case::kLowerCamel);
+            auto method_name = ConvertCase(field.name, Case::kUpperCamel);
             if (!field.deprecated &&
                 (!struct_def.sortbysize ||
                  size == SizeOf(field.value.type.base_type))) {
@@ -1060,10 +1064,10 @@ class JavaGenerator : public BaseGenerator {
         if (field.deprecated) continue;
         if (field.key) key_field = &field;
         code += "  public static void add";
-        code += MakeCamel(field.name);
+        code += ConvertCase(field.name, Case::kUpperCamel);
         code += "(FlatBufferBuilder builder, ";
         code += GenTypeBasic(DestinationType(field.value.type, false));
-        auto argname = MakeCamel(field.name, false);
+        auto argname = ConvertCase(field.name, Case::kLowerCamel);
         if (!IsScalar(field.value.type.base_type)) argname += "Offset";
         code += " " + argname + ") { builder.add";
         code += GenMethod(field.value.type) + "(";
@@ -1086,19 +1090,19 @@ class JavaGenerator : public BaseGenerator {
               // Handle byte[] and ByteBuffers separately for Java
               code += "  public static " + GenVectorOffsetType() + " ";
               code += "create";
-              code += MakeCamel(field.name);
+              code += ConvertCase(field.name, Case::kUpperCamel);
               code += "Vector(FlatBufferBuilder builder, byte[] data) ";
               code += "{ return builder.createByteVector(data); }\n";
 
               code += "  public static " + GenVectorOffsetType() + " ";
               code += "create";
-              code += MakeCamel(field.name);
+              code += ConvertCase(field.name, Case::kUpperCamel);
               code += "Vector(FlatBufferBuilder builder, ByteBuffer data) ";
               code += "{ return builder.createByteVector(data); }\n";
             } else {
               code += "  public static " + GenVectorOffsetType() + " ";
               code += "create";
-              code += MakeCamel(field.name);
+              code += ConvertCase(field.name, Case::kUpperCamel);
               code += "Vector(FlatBufferBuilder builder, ";
               code += GenTypeBasic(DestinationType(vector_type, false)) +
                       "[] data) ";
@@ -1120,7 +1124,7 @@ class JavaGenerator : public BaseGenerator {
           // Generate a method to start a vector, data to be added manually
           // after.
           code += "  public static void start";
-          code += MakeCamel(field.name);
+          code += ConvertCase(field.name, Case::kUpperCamel);
           code += "Vector(FlatBufferBuilder builder, int numElems) ";
           code += "{ builder.startVector(";
           code += NumToString(elem_size);
@@ -1206,7 +1210,7 @@ class JavaGenerator : public BaseGenerator {
 
   std::string GenOptionalScalarCheck(FieldDef &field) const {
     if (!field.IsScalarOptional()) return "";
-    return "  public boolean has" + MakeCamel(field.name, true) +
+    return "  public boolean has" + ConvertCase(field.name, Case::kUpperCamel) +
            "() { return 0 != __offset(" + NumToString(field.value.offset) +
            "); }\n";
   }
@@ -1273,7 +1277,7 @@ class JavaGenerator : public BaseGenerator {
   }
 
   std::string GenGetterFuncName_ObjectAPI(const std::string &field_name) const {
-    return "get" + MakeCamel(field_name, true);
+    return "get" + ConvertCase(field_name, Case::kUpperCamel);
   }
 
   void GenEnum_ObjectAPI(EnumDef &enum_def, std::string *code_ptr,
@@ -1344,7 +1348,7 @@ class JavaGenerator : public BaseGenerator {
   }
 
   std::string GenSetterFuncName_ObjectAPI(const std::string &field_name) const {
-    return "set" + MakeCamel(field_name, true);
+    return "set" + ConvertCase(field_name, Case::kUpperCamel);
   }
 
   std::string GenTypeName_ObjectAPI(const std::string &name,
@@ -1359,7 +1363,8 @@ class JavaGenerator : public BaseGenerator {
     auto &code = *code_ptr;
 
     std::string variable_type = type_name;
-    std::string variable_name = "_o" + MakeCamel(camel_name, true);
+    std::string variable_name =
+        "_o" + ConvertCase(camel_name, Case::kUpperCamel);
     std::string type_params = "";
     std::string value_params = "";
     std::string func_suffix = "()";
@@ -1408,7 +1413,7 @@ class JavaGenerator : public BaseGenerator {
     code += indent + "  default: break;\n";
     code += indent + "}\n";
     if (is_vector) {
-      code += indent + "_o" + MakeCamel(camel_name, true) +
+      code += indent + "_o" + ConvertCase(camel_name, Case::kUpperCamel) +
               "[_j] = " + variable_name + ";\n";
     }
   }
@@ -1433,8 +1438,8 @@ class JavaGenerator : public BaseGenerator {
       if (field.deprecated) continue;
       if (field.value.type.base_type == BASE_TYPE_UTYPE) continue;
       if (field.value.type.element == BASE_TYPE_UTYPE) continue;
-      auto camel_name = MakeCamel(field.name, false);
-      auto camel_name_with_first = MakeCamel(field.name, true);
+      auto camel_name = ConvertCase(field.name, Case::kLowerCamel);
+      auto camel_name_with_first = ConvertCase(field.name, Case::kUpperCamel);
       auto type_name =
           GenTypeGet_ObjectAPI(field.value.type, opts, false, true);
       if (field.IsScalarOptional())
@@ -1533,8 +1538,8 @@ class JavaGenerator : public BaseGenerator {
          it != struct_def.fields.vec.end(); ++it) {
       auto &field = **it;
       if (field.deprecated) continue;
-      auto camel_name = MakeCamel(field.name, false);
-      auto camel_name_with_first = MakeCamel(field.name, true);
+      auto camel_name = ConvertCase(field.name, Case::kLowerCamel);
+      auto camel_name_with_first = ConvertCase(field.name, Case::kUpperCamel);
       // pre
       switch (field.value.type.base_type) {
         case BASE_TYPE_STRUCT: {
@@ -1709,7 +1714,7 @@ class JavaGenerator : public BaseGenerator {
            it != struct_def.fields.vec.end(); ++it) {
         auto &field = **it;
         if (field.deprecated) continue;
-        auto camel_name = MakeCamel(field.name, false);
+        auto camel_name = ConvertCase(field.name, Case::kLowerCamel);
         switch (field.value.type.base_type) {
           case BASE_TYPE_STRUCT: {
             if (struct_def.fixed) {
@@ -1765,8 +1770,8 @@ class JavaGenerator : public BaseGenerator {
            it != struct_def.fields.vec.end(); ++it) {
         auto &field = **it;
         if (field.deprecated) continue;
-        auto camel_name = MakeCamel(field.name, false);
-        auto camel_name_with_first = MakeCamel(field.name, true);
+        auto camel_name = ConvertCase(field.name, Case::kLowerCamel);
+        auto camel_name_with_first = ConvertCase(field.name, Case::kUpperCamel);
         switch (field.value.type.base_type) {
           case BASE_TYPE_STRUCT: {
             if (field.value.type.struct_def->fixed) {
@@ -1841,7 +1846,7 @@ class JavaGenerator : public BaseGenerator {
         }
         std::string name;
         for (size_t i = 0; i < array_lengths.size(); ++i) {
-          name += "_" + MakeCamel(array_lengths[i].name, false);
+          name += "_" + ConvertCase(array_lengths[i].name, Case::kLowerCamel);
         }
         code += "    " + GenTypeBasic(field_type);
         if (array_only_lengths.size() > 0) {
@@ -1886,8 +1891,8 @@ class JavaGenerator : public BaseGenerator {
           code += " " + name + " = ";
           code += "_o";
           for (size_t i = 0; i < array_lengths.size(); ++i) {
-            code += "." + GenGetterFuncName_ObjectAPI(array_lengths[i].name) +
-                    "()";  // + MakeCamel(array_lengths[i].name);
+            code +=
+                "." + GenGetterFuncName_ObjectAPI(array_lengths[i].name) + "()";
           }
           code += ";";
         }
@@ -1908,10 +1913,10 @@ class JavaGenerator : public BaseGenerator {
       if (field_type.struct_def != nullptr) {
         GenStructPackCall_ObjectAPI(
             *field_type.struct_def, code_ptr,
-            prefix + MakeCamel(field.name, false) + "_");
+            prefix + ConvertCase(field.name, Case::kLowerCamel) + "_");
       } else {
         code += ",\n";
-        code += prefix + MakeCamel(field.name, false);
+        code += prefix + ConvertCase(field.name, Case::kLowerCamel);
       }
     }
   }
@@ -2046,7 +2051,7 @@ class JavaGenerator : public BaseGenerator {
           GenTypeGet_ObjectAPI(field.value.type, opts, false, true);
       if (field.IsScalarOptional())
         type_name = ConvertPrimitiveTypeToObjectWrapper_ObjectAPI(type_name);
-      auto camel_name = MakeCamel(field.name, false);
+      auto camel_name = ConvertCase(field.name, Case::kLowerCamel);
       code += "  private " + type_name + " " + camel_name + ";\n";
     }
     // Generate Java getters and setters
@@ -2061,7 +2066,7 @@ class JavaGenerator : public BaseGenerator {
           GenTypeGet_ObjectAPI(field.value.type, opts, false, true);
       if (field.IsScalarOptional())
         type_name = ConvertPrimitiveTypeToObjectWrapper_ObjectAPI(type_name);
-      auto camel_name = MakeCamel(field.name, false);
+      auto camel_name = ConvertCase(field.name, Case::kLowerCamel);
       code += "  public " + type_name + " " +
               GenGetterFuncName_ObjectAPI(field.name) + "() { return " +
               camel_name + "; }\n\n";
@@ -2084,7 +2089,7 @@ class JavaGenerator : public BaseGenerator {
       if (field.deprecated) continue;
       if (field.value.type.base_type == BASE_TYPE_UTYPE) continue;
       if (field.value.type.element == BASE_TYPE_UTYPE) continue;
-      code += "    this." + MakeCamel(field.name, false) + " = ";
+      code += "    this." + ConvertCase(field.name, Case::kLowerCamel) + " = ";
       auto type_name =
           GenTypeGet_ObjectAPI(field.value.type, opts, false, true);
       if (IsScalar(field.value.type.base_type)) {
diff --git a/src/idl_gen_kotlin.cpp b/src/idl_gen_kotlin.cpp
index 3977a3fed..fc55aebd8 100644
--- a/src/idl_gen_kotlin.cpp
+++ b/src/idl_gen_kotlin.cpp
@@ -46,10 +46,12 @@ static const char *keywords[] = {
 // Escape Keywords
 static std::string Esc(const std::string &name) {
   for (size_t i = 0; i < sizeof(keywords) / sizeof(keywords[0]); i++) {
-    if (name == keywords[i]) { return MakeCamel(name + "_", false); }
+    if (name == keywords[i]) {
+      return ConvertCase(name + "_", Case::kLowerCamel);
+    }
   }
 
-  return MakeCamel(name, false);
+  return ConvertCase(name, Case::kLowerCamel);
 }
 
 class KotlinGenerator : public BaseGenerator {
@@ -337,7 +339,8 @@ class KotlinGenerator : public BaseGenerator {
       case BASE_TYPE_UTYPE: return bb_var_name + ".get";
       case BASE_TYPE_BOOL: return "0.toByte() != " + bb_var_name + ".get";
       default:
-        return bb_var_name + ".get" + MakeCamel(GenTypeBasic(type.base_type));
+        return bb_var_name + ".get" +
+               ConvertCase(GenTypeBasic(type.base_type), Case::kUpperCamel);
     }
   }
 
@@ -357,7 +360,9 @@ class KotlinGenerator : public BaseGenerator {
         case BASE_TYPE_BOOL:
         case BASE_TYPE_NONE:
         case BASE_TYPE_UTYPE: return "bb.put";
-        default: return "bb.put" + MakeCamel(GenTypeBasic(type.base_type));
+        default:
+          return "bb.put" +
+                 ConvertCase(GenTypeBasic(type.base_type), Case::kUpperCamel);
       }
     }
     return "";
@@ -394,7 +399,7 @@ class KotlinGenerator : public BaseGenerator {
                       (nameprefix + (field.name + "_")).c_str());
       } else {
         writer += std::string(", ") + nameprefix + "\\";
-        writer += MakeCamel(field.name) + ": \\";
+        writer += ConvertCase(field.name, Case::kUpperCamel) + ": \\";
         writer += GenTypeBasic(field.value.type.base_type) + "\\";
       }
     }
@@ -421,8 +426,8 @@ class KotlinGenerator : public BaseGenerator {
                       (nameprefix + (field.name + "_")).c_str());
       } else {
         writer.SetValue("type", GenMethod(field.value.type));
-        writer.SetValue("argname",
-                        nameprefix + MakeCamel(Esc(field.name), false));
+        writer.SetValue("argname", nameprefix + ConvertCase(Esc(field.name),
+                                                            Case::kLowerCamel));
         writer.SetValue("cast", CastToSigned(field.value.type));
         writer += "builder.put{{type}}({{argname}}{{cast}})";
       }
@@ -656,7 +661,8 @@ class KotlinGenerator : public BaseGenerator {
   void GenerateCreateVectorField(FieldDef &field, CodeWriter &writer,
                                  const IDLOptions options) const {
     auto vector_type = field.value.type.VectorType();
-    auto method_name = "create" + MakeCamel(Esc(field.name)) + "Vector";
+    auto method_name =
+        "create" + ConvertCase(Esc(field.name), Case::kUpperCamel) + "Vector";
     auto params = "builder: FlatBufferBuilder, data: " +
                   GenTypeBasic(vector_type.base_type) + "Array";
     writer.SetValue("size", NumToString(InlineSize(vector_type)));
@@ -688,8 +694,9 @@ class KotlinGenerator : public BaseGenerator {
     writer.SetValue("align", NumToString(InlineAlignment(vector_type)));
 
     GenerateFunOneLine(
-        writer, "start" + MakeCamel(Esc(field.name) + "Vector", true), params,
-        "",
+        writer,
+        "start" + ConvertCase(Esc(field.name) + "Vector", Case::kUpperCamel),
+        params, "",
         [&]() {
           writer += "builder.startVector({{size}}, numElems, {{align}})";
         },
@@ -699,14 +706,16 @@ class KotlinGenerator : public BaseGenerator {
   void GenerateAddField(std::string field_pos, FieldDef &field,
                         CodeWriter &writer, const IDLOptions options) const {
     auto field_type = GenTypeBasic(field.value.type.base_type);
-    auto secondArg = MakeCamel(Esc(field.name), false) + ": " + field_type;
+    auto secondArg =
+        ConvertCase(Esc(field.name), Case::kLowerCamel) + ": " + field_type;
 
     GenerateFunOneLine(
-        writer, "add" + MakeCamel(Esc(field.name), true),
+        writer, "add" + ConvertCase(Esc(field.name), Case::kUpperCamel),
         "builder: FlatBufferBuilder, " + secondArg, "",
         [&]() {
           auto method = GenMethod(field.value.type);
-          writer.SetValue("field_name", MakeCamel(Esc(field.name), false));
+          writer.SetValue("field_name",
+                          ConvertCase(Esc(field.name), Case::kLowerCamel));
           writer.SetValue("method_name", method);
           writer.SetValue("pos", field_pos);
           writer.SetValue("default", GenFBBDefaultValue(field));
@@ -797,7 +806,7 @@ class KotlinGenerator : public BaseGenerator {
       for (auto it = fields_vec.begin(); it != fields_vec.end(); ++it) {
         auto &field = **it;
         if (field.deprecated) continue;
-        params << ", " << MakeCamel(Esc(field.name), false);
+        params << ", " << ConvertCase(Esc(field.name), Case::kLowerCamel);
         if (!IsScalar(field.value.type.base_type)) {
           params << "Offset: ";
         } else {
@@ -823,10 +832,11 @@ class KotlinGenerator : public BaseGenerator {
                 auto base_type_size = SizeOf(field.value.type.base_type);
                 if (!field.deprecated &&
                     (!sortbysize || size == base_type_size)) {
-                  writer.SetValue("camel_field_name",
-                                  MakeCamel(Esc(field.name), true));
-                  writer.SetValue("field_name",
-                                  MakeCamel(Esc(field.name), false));
+                  writer.SetValue(
+                      "camel_field_name",
+                      ConvertCase(Esc(field.name), Case::kUpperCamel));
+                  writer.SetValue("field_name", ConvertCase(Esc(field.name),
+                                                            Case::kLowerCamel));
 
                   // we wrap on null check for scalar optionals
                   writer += field.IsScalarOptional()
@@ -853,7 +863,7 @@ class KotlinGenerator : public BaseGenerator {
     // Check if a buffer has the identifier.
     if (parser_.root_struct_def_ != &struct_def || !file_identifier.length())
       return;
-    auto name = MakeCamel(Esc(struct_def.name), false);
+    auto name = ConvertCase(Esc(struct_def.name), Case::kLowerCamel);
     GenerateFunOneLine(
         writer, name + "BufferHasIdentifier", "_bb: ByteBuffer", "Boolean",
         [&]() {
@@ -872,7 +882,7 @@ class KotlinGenerator : public BaseGenerator {
 
       GenerateComment(field.doc_comment, writer, &comment_config);
 
-      auto field_name = MakeCamel(Esc(field.name), false);
+      auto field_name = ConvertCase(Esc(field.name), Case::kLowerCamel);
       auto field_type = GenTypeGet(field.value.type);
       auto field_default_value = GenDefaultValue(field);
       auto return_type = GetterReturnType(field);
@@ -1043,7 +1053,8 @@ class KotlinGenerator : public BaseGenerator {
             auto &kfield = **kit;
             if (kfield.key) {
               auto qualified_name = WrapInNameSpace(sd);
-              auto name = MakeCamel(Esc(field.name), false) + "ByKey";
+              auto name =
+                  ConvertCase(Esc(field.name), Case::kLowerCamel) + "ByKey";
               auto params = "key: " + GenTypeGet(kfield.value.type);
               auto rtype = qualified_name + "?";
               GenerateFun(writer, name, params, rtype, [&]() {
@@ -1136,7 +1147,7 @@ class KotlinGenerator : public BaseGenerator {
         auto underlying_type = value_base_type == BASE_TYPE_VECTOR
                                    ? value_type.VectorType()
                                    : value_type;
-        auto name = "mutate" + MakeCamel(Esc(field.name), true);
+        auto name = "mutate" + ConvertCase(Esc(field.name), Case::kUpperCamel);
         auto size = NumToString(InlineSize(underlying_type));
         auto params = Esc(field.name) + ": " + GenTypeGet(underlying_type);
         // A vector mutator also needs the index of the vector element it should
@@ -1339,8 +1350,8 @@ class KotlinGenerator : public BaseGenerator {
         out << StructConstructorParams(*field.value.type.struct_def,
                                        prefix + (Esc(field.name) + "_"));
       } else {
-        out << ", " << prefix << MakeCamel(Esc(field.name), false) << ": "
-            << GenTypeBasic(field.value.type.base_type);
+        out << ", " << prefix << ConvertCase(Esc(field.name), Case::kLowerCamel)
+            << ": " << GenTypeBasic(field.value.type.base_type);
       }
     }
     return out.str();
diff --git a/src/idl_gen_lobster.cpp b/src/idl_gen_lobster.cpp
index 6fdd6dc26..d801801b6 100644
--- a/src/idl_gen_lobster.cpp
+++ b/src/idl_gen_lobster.cpp
@@ -78,7 +78,7 @@ class LobsterGenerator : public BaseGenerator {
   // Returns the method name for use with add/put calls.
   std::string GenMethod(const Type &type) {
     return IsScalar(type.base_type)
-               ? MakeCamel(GenTypeBasic(type))
+               ? ConvertCase(GenTypeBasic(type), Case::kUpperCamel)
                : (IsStruct(type) ? "Struct" : "UOffsetTRelative");
   }
 
@@ -212,7 +212,7 @@ class LobsterGenerator : public BaseGenerator {
       if (field.deprecated) continue;
       if (IsVector(field.value.type)) {
         code += "def " + NormalizedName(struct_def) + "Start" +
-                MakeCamel(NormalizedName(field)) +
+                ConvertCase(NormalizedName(field), Case::kUpperCamel) +
                 "Vector(b_:flatbuffers_builder, n_:int):\n    b_.StartVector(";
         auto vector_type = field.value.type.VectorType();
         auto alignment = InlineAlignment(vector_type);
@@ -222,7 +222,7 @@ class LobsterGenerator : public BaseGenerator {
         if (vector_type.base_type != BASE_TYPE_STRUCT ||
             !vector_type.struct_def->fixed) {
           code += "def " + NormalizedName(struct_def) + "Create" +
-                  MakeCamel(NormalizedName(field)) +
+                  ConvertCase(NormalizedName(field), Case::kUpperCamel) +
                   "Vector(b_:flatbuffers_builder, v_:[" +
                   LobsterType(vector_type) + "]):\n    b_.StartVector(" +
                   NumToString(elem_size) + ", v_.length, " +
diff --git a/src/idl_gen_lua.cpp b/src/idl_gen_lua.cpp
index 9efc435e2..7be00154c 100644
--- a/src/idl_gen_lua.cpp
+++ b/src/idl_gen_lua.cpp
@@ -154,7 +154,8 @@ class LuaGenerator : public BaseGenerator {
     std::string &code = *code_ptr;
 
     GenReceiver(struct_def, code_ptr);
-    code += MakeCamel(NormalizedName(field)) + "Length()\n";
+    code +=
+        ConvertCase(NormalizedName(field), Case::kUpperCamel) + "Length()\n";
     code += OffsetPrefix(field);
     code +=
         std::string(Indent) + Indent + "return " + SelfData + ":VectorLen(o)\n";
@@ -169,7 +170,7 @@ class LuaGenerator : public BaseGenerator {
     std::string &code = *code_ptr;
     std::string getter = GenGetter(field.value.type);
     GenReceiver(struct_def, code_ptr);
-    code += MakeCamel(NormalizedName(field));
+    code += ConvertCase(NormalizedName(field), Case::kUpperCamel);
     code += "()\n";
     code += std::string(Indent) + "return " + getter;
     code += std::string(SelfDataPos) + " + " + NumToString(field.value.offset) +
@@ -183,7 +184,7 @@ class LuaGenerator : public BaseGenerator {
     std::string &code = *code_ptr;
     std::string getter = GenGetter(field.value.type);
     GenReceiver(struct_def, code_ptr);
-    code += MakeCamel(NormalizedName(field));
+    code += ConvertCase(NormalizedName(field), Case::kUpperCamel);
     code += "()\n";
     code += OffsetPrefix(field);
     getter += std::string("o + ") + SelfDataPos + ")";
@@ -207,7 +208,7 @@ class LuaGenerator : public BaseGenerator {
                               const FieldDef &field, std::string *code_ptr) {
     std::string &code = *code_ptr;
     GenReceiver(struct_def, code_ptr);
-    code += MakeCamel(NormalizedName(field));
+    code += ConvertCase(NormalizedName(field), Case::kUpperCamel);
     code += "(obj)\n";
     code += std::string(Indent) + "obj:Init(" + SelfDataBytes + ", " +
             SelfDataPos + " + ";
@@ -222,7 +223,7 @@ class LuaGenerator : public BaseGenerator {
                              std::string *code_ptr) {
     std::string &code = *code_ptr;
     GenReceiver(struct_def, code_ptr);
-    code += MakeCamel(NormalizedName(field));
+    code += ConvertCase(NormalizedName(field), Case::kUpperCamel);
     code += "()\n";
     code += OffsetPrefix(field);
     if (field.value.type.struct_def->fixed) {
@@ -246,7 +247,7 @@ class LuaGenerator : public BaseGenerator {
                       std::string *code_ptr) {
     std::string &code = *code_ptr;
     GenReceiver(struct_def, code_ptr);
-    code += MakeCamel(NormalizedName(field));
+    code += ConvertCase(NormalizedName(field), Case::kUpperCamel);
     code += "()\n";
     code += OffsetPrefix(field);
     code +=
@@ -261,7 +262,7 @@ class LuaGenerator : public BaseGenerator {
                      std::string *code_ptr) {
     std::string &code = *code_ptr;
     GenReceiver(struct_def, code_ptr);
-    code += MakeCamel(NormalizedName(field)) + "()\n";
+    code += ConvertCase(NormalizedName(field), Case::kUpperCamel) + "()\n";
     code += OffsetPrefix(field);
 
     // TODO(rw): this works and is not the good way to it:
@@ -292,7 +293,7 @@ class LuaGenerator : public BaseGenerator {
     auto vectortype = field.value.type.VectorType();
 
     GenReceiver(struct_def, code_ptr);
-    code += MakeCamel(NormalizedName(field));
+    code += ConvertCase(NormalizedName(field), Case::kUpperCamel);
     code += "(j)\n";
     code += OffsetPrefix(field);
     code +=
@@ -321,7 +322,7 @@ class LuaGenerator : public BaseGenerator {
     auto vectortype = field.value.type.VectorType();
 
     GenReceiver(struct_def, code_ptr);
-    code += MakeCamel(NormalizedName(field));
+    code += ConvertCase(NormalizedName(field), Case::kUpperCamel);
     code += "(j)\n";
     code += OffsetPrefix(field);
     code +=
@@ -344,7 +345,7 @@ class LuaGenerator : public BaseGenerator {
                                 const FieldDef &field, std::string *code_ptr) {
     std::string &code = *code_ptr;
     GenReceiver(struct_def, code_ptr);
-    code += MakeCamel(NormalizedName(field));
+    code += ConvertCase(NormalizedName(field), Case::kUpperCamel);
     code += "AsString(start, stop)\n";
     code += std::string(Indent) + "return " + SelfData + ":VectorAsString(" +
             NumToString(field.value.offset) + ", start, stop)\n";
@@ -377,7 +378,7 @@ class LuaGenerator : public BaseGenerator {
       } else {
         std::string &code = *code_ptr;
         code += std::string(", ") + nameprefix;
-        code += MakeCamel(NormalizedName(field), false);
+        code += ConvertCase(NormalizedName(field), Case::kLowerCamel);
       }
     }
   }
@@ -409,7 +410,8 @@ class LuaGenerator : public BaseGenerator {
       } else {
         code +=
             std::string(Indent) + "builder:Prepend" + GenMethod(field) + "(";
-        code += nameprefix + MakeCamel(NormalizedName(field), false) + ")\n";
+        code += nameprefix +
+                ConvertCase(NormalizedName(field), Case::kLowerCamel) + ")\n";
       }
     }
   }
@@ -435,9 +437,9 @@ class LuaGenerator : public BaseGenerator {
                          const size_t offset, std::string *code_ptr) {
     std::string &code = *code_ptr;
     code += "function " + NormalizedName(struct_def) + ".Add" +
-            MakeCamel(NormalizedName(field));
+            ConvertCase(NormalizedName(field), Case::kUpperCamel);
     code += "(builder, ";
-    code += MakeCamel(NormalizedName(field), false);
+    code += ConvertCase(NormalizedName(field), Case::kLowerCamel);
     code += ") ";
     code += "builder:Prepend";
     code += GenMethod(field) + "Slot(";
@@ -446,9 +448,9 @@ class LuaGenerator : public BaseGenerator {
     //    if (!IsScalar(field.value.type.base_type) && (!struct_def.fixed)) {
     //      code += "flatbuffers.N.UOffsetTFlags.py_type";
     //      code += "(";
-    //      code += MakeCamel(NormalizedName(field), false) + ")";
+    //      code += ConvertCase(NormalizedName(field), Case::kLowerCamel) + ")";
     //    } else {
-    code += MakeCamel(NormalizedName(field), false);
+    code += ConvertCase(NormalizedName(field), Case::kLowerCamel);
     //    }
     code += ", " + field.value.constant;
     code += ") end\n";
@@ -459,7 +461,7 @@ class LuaGenerator : public BaseGenerator {
                           std::string *code_ptr) {
     std::string &code = *code_ptr;
     code += "function " + NormalizedName(struct_def) + ".Start";
-    code += MakeCamel(NormalizedName(field));
+    code += ConvertCase(NormalizedName(field), Case::kUpperCamel);
     code += "Vector(builder, numElems) return builder:StartVector(";
     auto vector_type = field.value.type.VectorType();
     auto alignment = InlineAlignment(vector_type);
@@ -603,14 +605,14 @@ class LuaGenerator : public BaseGenerator {
       case BASE_TYPE_VECTOR: return GenGetter(type.VectorType());
       default:
         return std::string(SelfData) + ":Get(flatbuffers.N." +
-               MakeCamel(GenTypeGet(type)) + ", ";
+               ConvertCase(GenTypeGet(type), Case::kUpperCamel) + ", ";
     }
   }
 
   // Returns the method name for use with add/put calls.
   std::string GenMethod(const FieldDef &field) {
     return IsScalar(field.value.type.base_type)
-               ? MakeCamel(GenTypeBasic(field.value.type))
+               ? ConvertCase(GenTypeBasic(field.value.type), Case::kUpperCamel)
                : (IsStruct(field.value.type) ? "Struct" : "UOffsetTRelative");
   }
 
diff --git a/src/idl_gen_php.cpp b/src/idl_gen_php.cpp
index 602d229ee..5896935e6 100644
--- a/src/idl_gen_php.cpp
+++ b/src/idl_gen_php.cpp
@@ -181,7 +181,7 @@ class PhpGenerator : public BaseGenerator {
     code += Indent + " * @return int\n";
     code += Indent + " */\n";
     code += Indent + "public function get";
-    code += MakeCamel(field.name) + "Length()\n";
+    code += ConvertCase(field.name, Case::kUpperCamel) + "Length()\n";
     code += Indent + "{\n";
     code += Indent + Indent + "$o = $this->__offset(";
     code += NumToString(field.value.offset) + ");\n";
@@ -198,7 +198,7 @@ class PhpGenerator : public BaseGenerator {
     code += Indent + " * @return string\n";
     code += Indent + " */\n";
     code += Indent + "public function get";
-    code += MakeCamel(field.name) + "Bytes()\n";
+    code += ConvertCase(field.name, Case::kUpperCamel) + "Bytes()\n";
     code += Indent + "{\n";
     code += Indent + Indent + "return $this->__vector_as_bytes(";
     code += NumToString(field.value.offset) + ");\n";
@@ -216,12 +216,12 @@ class PhpGenerator : public BaseGenerator {
     code += GenTypeGet(field.value.type) + "\n";
     code += Indent + " */\n";
     code += Indent + "public function " + getter;
-    code += MakeCamel(field.name) + "()\n";
+    code += ConvertCase(field.name, Case::kUpperCamel) + "()\n";
     code += Indent + "{\n";
     code += Indent + Indent + "return ";
 
     code += "$this->bb->get";
-    code += MakeCamel(GenTypeGet(field.value.type));
+    code += ConvertCase(GenTypeGet(field.value.type), Case::kUpperCamel);
     code += "($this->bb_pos + ";
     code += NumToString(field.value.offset) + ")";
     code += ";\n";
@@ -237,14 +237,15 @@ class PhpGenerator : public BaseGenerator {
     code += Indent + " * @return " + GenTypeGet(field.value.type) + "\n";
     code += Indent + " */\n";
     code += Indent + "public function get";
-    code += MakeCamel(field.name);
+    code += ConvertCase(field.name, Case::kUpperCamel);
     code += "()\n";
     code += Indent + "{\n";
     code += Indent + Indent + "$o = $this->__offset(" +
             NumToString(field.value.offset) + ");\n" + Indent + Indent +
             "return $o != 0 ? ";
     code += "$this->bb->get";
-    code += MakeCamel(GenTypeGet(field.value.type)) + "($o + $this->bb_pos)";
+    code += ConvertCase(GenTypeGet(field.value.type), Case::kUpperCamel) +
+            "($o + $this->bb_pos)";
     code += " : " + GenDefaultValue(field.value) + ";\n";
     code += Indent + "}\n\n";
   }
@@ -258,7 +259,7 @@ class PhpGenerator : public BaseGenerator {
     code += Indent + " * @return " + GenTypeGet(field.value.type) + "\n";
     code += Indent + " */\n";
     code += Indent + "public function get";
-    code += MakeCamel(field.name) + "()\n";
+    code += ConvertCase(field.name, Case::kUpperCamel) + "()\n";
     code += Indent + "{\n";
     code += Indent + Indent + "$obj = new ";
     code += GenTypeGet(field.value.type) + "();\n";
@@ -274,11 +275,12 @@ class PhpGenerator : public BaseGenerator {
     std::string &code = *code_ptr;
 
     code += Indent + "public function get";
-    code += MakeCamel(field.name);
+    code += ConvertCase(field.name, Case::kUpperCamel);
     code += "()\n";
     code += Indent + "{\n";
     code += Indent + Indent + "$obj = new ";
-    code += MakeCamel(GenTypeGet(field.value.type)) + "();\n";
+    code +=
+        ConvertCase(GenTypeGet(field.value.type), Case::kUpperCamel) + "();\n";
     code += Indent + Indent + "$o = $this->__offset(" +
             NumToString(field.value.offset) + ");\n";
     code += Indent + Indent;
@@ -296,7 +298,7 @@ class PhpGenerator : public BaseGenerator {
   void GetStringField(const FieldDef &field, std::string *code_ptr) {
     std::string &code = *code_ptr;
     code += Indent + "public function get";
-    code += MakeCamel(field.name);
+    code += ConvertCase(field.name, Case::kUpperCamel);
     code += "()\n";
     code += Indent + "{\n";
     code += Indent + Indent + "$o = $this->__offset(" +
@@ -315,7 +317,7 @@ class PhpGenerator : public BaseGenerator {
     code += Indent + " * @return" + GenTypeBasic(field.value.type) + "\n";
     code += Indent + " */\n";
     code += Indent + "public function get";
-    code += MakeCamel(field.name) + "($obj)\n";
+    code += ConvertCase(field.name, Case::kUpperCamel) + "($obj)\n";
     code += Indent + "{\n";
     code += Indent + Indent + "$o = $this->__offset(" +
             NumToString(field.value.offset) + ");\n";
@@ -334,13 +336,14 @@ class PhpGenerator : public BaseGenerator {
     code += Indent + " * @return" + GenTypeBasic(field.value.type) + "\n";
     code += Indent + " */\n";
     code += Indent + "public function get";
-    code += MakeCamel(field.name);
+    code += ConvertCase(field.name, Case::kUpperCamel);
     code += "($j)\n";
     code += Indent + "{\n";
     code += Indent + Indent + "$o = $this->__offset(" +
             NumToString(field.value.offset) + ");\n";
     code += Indent + Indent + "$obj = new ";
-    code += MakeCamel(GenTypeGet(field.value.type)) + "();\n";
+    code +=
+        ConvertCase(GenTypeGet(field.value.type), Case::kUpperCamel) + "();\n";
 
     switch (field.value.type.base_type) {
       case BASE_TYPE_STRUCT:
@@ -395,7 +398,7 @@ class PhpGenerator : public BaseGenerator {
     code += Indent + " * @return " + GenTypeGet(field.value.type) + "\n";
     code += Indent + " */\n";
     code += Indent + "public function get";
-    code += MakeCamel(field.name);
+    code += ConvertCase(field.name, Case::kUpperCamel);
     code += "($j)\n";
     code += Indent + "{\n";
     code += Indent + Indent + "$o = $this->__offset(" +
@@ -408,7 +411,7 @@ class PhpGenerator : public BaseGenerator {
       code += GenDefaultValue(field.value) + ";\n";
     } else {
       code += Indent + Indent + "return $o != 0 ? $this->bb->get";
-      code += MakeCamel(GenTypeGet(field.value.type));
+      code += ConvertCase(GenTypeGet(field.value.type), Case::kUpperCamel);
       code += "($this->__vector($o) + $j * ";
       code += NumToString(InlineSize(vectortype)) + ") : ";
       code += GenDefaultValue(field.value) + ";\n";
@@ -427,7 +430,7 @@ class PhpGenerator : public BaseGenerator {
     code += Indent + " * @return " + GenTypeGet(field.value.type) + "\n";
     code += Indent + " */\n";
     code += Indent + "public function get";
-    code += MakeCamel(field.name);
+    code += ConvertCase(field.name, Case::kUpperCamel);
     code += "($j, $obj)\n";
     code += Indent + "{\n";
     code += Indent + Indent + "$o = $this->__offset(" +
@@ -455,7 +458,7 @@ class PhpGenerator : public BaseGenerator {
       } else {
         std::string &code = *code_ptr;
         code += std::string(", $") + nameprefix;
-        code += MakeCamel(field.name, false);
+        code += ConvertCase(field.name, Case::kLowerCamel);
       }
     }
   }
@@ -480,7 +483,8 @@ class PhpGenerator : public BaseGenerator {
                           (nameprefix + (field.name + "_")).c_str(), code_ptr);
       } else {
         code += Indent + Indent + "$builder->put" + GenMethod(field) + "($";
-        code += nameprefix + MakeCamel(field.name, false) + ");\n";
+        code +=
+            nameprefix + ConvertCase(field.name, Case::kLowerCamel) + ");\n";
       }
     }
   }
@@ -528,7 +532,8 @@ class PhpGenerator : public BaseGenerator {
       if (field.deprecated) continue;
 
       code += Indent + Indent + "self::add";
-      code += MakeCamel(field.name) + "($builder, $" + field.name + ");\n";
+      code += ConvertCase(field.name, Case::kUpperCamel) + "($builder, $" +
+              field.name + ");\n";
     }
 
     code += Indent + Indent + "$o = $builder->endObject();\n";
@@ -557,16 +562,16 @@ class PhpGenerator : public BaseGenerator {
     code += Indent + " * @return void\n";
     code += Indent + " */\n";
     code += Indent + "public static function ";
-    code += "add" + MakeCamel(field.name);
+    code += "add" + ConvertCase(field.name, Case::kUpperCamel);
     code += "(FlatBufferBuilder $builder, ";
-    code += "$" + MakeCamel(field.name, false);
+    code += "$" + ConvertCase(field.name, Case::kLowerCamel);
     code += ")\n";
     code += Indent + "{\n";
     code += Indent + Indent + "$builder->add";
     code += GenMethod(field) + "X(";
     code += NumToString(offset) + ", ";
 
-    code += "$" + MakeCamel(field.name, false);
+    code += "$" + ConvertCase(field.name, Case::kLowerCamel);
     code += ", ";
 
     if (field.value.type.base_type == BASE_TYPE_BOOL) {
@@ -591,7 +596,7 @@ class PhpGenerator : public BaseGenerator {
     code += Indent + " * @return int vector offset\n";
     code += Indent + " */\n";
     code += Indent + "public static function create";
-    code += MakeCamel(field.name);
+    code += ConvertCase(field.name, Case::kUpperCamel);
     code += "Vector(FlatBufferBuilder $builder, array $data)\n";
     code += Indent + "{\n";
     code += Indent + Indent + "$builder->startVector(";
@@ -603,7 +608,8 @@ class PhpGenerator : public BaseGenerator {
     if (IsScalar(field.value.type.VectorType().base_type)) {
       code += Indent + Indent + Indent;
       code += "$builder->put";
-      code += MakeCamel(GenTypeBasic(field.value.type.VectorType()));
+      code += ConvertCase(GenTypeBasic(field.value.type.VectorType()),
+                          Case::kUpperCamel);
       code += "($data[$i]);\n";
     } else {
       code += Indent + Indent + Indent;
@@ -619,7 +625,7 @@ class PhpGenerator : public BaseGenerator {
     code += Indent + " * @return void\n";
     code += Indent + " */\n";
     code += Indent + "public static function start";
-    code += MakeCamel(field.name);
+    code += ConvertCase(field.name, Case::kUpperCamel);
     code += "Vector(FlatBufferBuilder $builder, $numElems)\n";
     code += Indent + "{\n";
     code += Indent + Indent + "$builder->startVector(";
@@ -726,7 +732,7 @@ class PhpGenerator : public BaseGenerator {
       if (field.value.type.base_type == BASE_TYPE_UNION) {
         std::string &code = *code_ptr;
         code += Indent + "public static function add";
-        code += MakeCamel(field.name);
+        code += ConvertCase(field.name, Case::kUpperCamel);
         code += "(FlatBufferBuilder $builder, $offset)\n";
         code += Indent + "{\n";
         code += Indent + Indent + "$builder->addOffsetX(";
@@ -853,7 +859,7 @@ class PhpGenerator : public BaseGenerator {
   // Returns the method name for use with add/put calls.
   static std::string GenMethod(const FieldDef &field) {
     return IsScalar(field.value.type.base_type)
-               ? MakeCamel(GenTypeBasic(field.value.type))
+               ? ConvertCase(GenTypeBasic(field.value.type), Case::kUpperCamel)
                : (IsStruct(field.value.type) ? "Struct" : "Offset");
   }
 
diff --git a/src/idl_gen_python.cpp b/src/idl_gen_python.cpp
index 395c5b553..a085e8d8e 100644
--- a/src/idl_gen_python.cpp
+++ b/src/idl_gen_python.cpp
@@ -88,12 +88,12 @@ class PythonGenerator : public BaseGenerator {
 
   // Converts the name of a definition into upper Camel format.
   std::string MakeUpperCamel(const Definition &definition) const {
-    return MakeCamel(NormalizedName(definition), true);
+    return ConvertCase(NormalizedName(definition), Case::kUpperCamel);
   }
 
   // Converts the name of a definition into lower Camel format.
   std::string MakeLowerCamel(const Definition &definition) const {
-    auto name = MakeCamel(NormalizedName(definition), false);
+    auto name = ConvertCase(NormalizedName(definition), Case::kLowerCamel);
     name[0] = CharToLower(name[0]);
     return name;
   }
@@ -157,7 +157,8 @@ class PythonGenerator : public BaseGenerator {
     auto &code = *code_ptr;
 
     GenReceiver(struct_def, code_ptr);
-    code += MakeCamel(NormalizedName(field)) + "Length(self";
+    code +=
+        ConvertCase(NormalizedName(field), Case::kUpperCamel) + "Length(self";
     code += "):" + OffsetPrefix(field);
     code += Indent + Indent + Indent + "return self._tab.VectorLen(o)\n";
     code += Indent + Indent + "return 0\n\n";
@@ -169,7 +170,8 @@ class PythonGenerator : public BaseGenerator {
     auto &code = *code_ptr;
 
     GenReceiver(struct_def, code_ptr);
-    code += MakeCamel(NormalizedName(field)) + "IsNone(self";
+    code +=
+        ConvertCase(NormalizedName(field), Case::kUpperCamel) + "IsNone(self";
     code += "):";
     code += GenIndents(2) +
             "o = flatbuffers.number_types.UOffsetTFlags.py_type" +
@@ -184,7 +186,7 @@ class PythonGenerator : public BaseGenerator {
     auto &code = *code_ptr;
     std::string getter = GenGetter(field.value.type);
     GenReceiver(struct_def, code_ptr);
-    code += MakeCamel(NormalizedName(field));
+    code += ConvertCase(NormalizedName(field), Case::kUpperCamel);
     code += "(self): return " + getter;
     code += "self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(";
     code += NumToString(field.value.offset) + "))\n";
@@ -196,7 +198,7 @@ class PythonGenerator : public BaseGenerator {
     auto &code = *code_ptr;
     std::string getter = GenGetter(field.value.type);
     GenReceiver(struct_def, code_ptr);
-    code += MakeCamel(NormalizedName(field));
+    code += ConvertCase(NormalizedName(field), Case::kUpperCamel);
     code += "(self):";
     code += OffsetPrefix(field);
     getter += "o + self._tab.Pos)";
@@ -220,7 +222,7 @@ class PythonGenerator : public BaseGenerator {
                               const FieldDef &field, std::string *code_ptr) {
     auto &code = *code_ptr;
     GenReceiver(struct_def, code_ptr);
-    code += MakeCamel(NormalizedName(field));
+    code += ConvertCase(NormalizedName(field), Case::kUpperCamel);
     code += "(self, obj):\n";
     code += Indent + Indent + "obj.Init(self._tab.Bytes, self._tab.Pos + ";
     code += NumToString(field.value.offset) + ")";
@@ -233,7 +235,7 @@ class PythonGenerator : public BaseGenerator {
     auto &code = *code_ptr;
     const auto vec_type = field.value.type.VectorType();
     GenReceiver(struct_def, code_ptr);
-    code += MakeCamel(NormalizedName(field));
+    code += ConvertCase(NormalizedName(field), Case::kUpperCamel);
     if (IsStruct(vec_type)) {
       code += "(self, obj, i):\n";
       code += Indent + Indent + "obj.Init(self._tab.Bytes, self._tab.Pos + ";
@@ -257,7 +259,7 @@ class PythonGenerator : public BaseGenerator {
                              std::string *code_ptr) {
     auto &code = *code_ptr;
     GenReceiver(struct_def, code_ptr);
-    code += MakeCamel(NormalizedName(field));
+    code += ConvertCase(NormalizedName(field), Case::kUpperCamel);
     code += "(self):";
     code += OffsetPrefix(field);
     if (field.value.type.struct_def->fixed) {
@@ -282,7 +284,7 @@ class PythonGenerator : public BaseGenerator {
                       std::string *code_ptr) {
     auto &code = *code_ptr;
     GenReceiver(struct_def, code_ptr);
-    code += MakeCamel(NormalizedName(field));
+    code += ConvertCase(NormalizedName(field), Case::kUpperCamel);
     code += "(self):";
     code += OffsetPrefix(field);
     code += Indent + Indent + Indent + "return " + GenGetter(field.value.type);
@@ -295,7 +297,7 @@ class PythonGenerator : public BaseGenerator {
                      std::string *code_ptr) {
     auto &code = *code_ptr;
     GenReceiver(struct_def, code_ptr);
-    code += MakeCamel(NormalizedName(field)) + "(self):";
+    code += ConvertCase(NormalizedName(field), Case::kUpperCamel) + "(self):";
     code += OffsetPrefix(field);
 
     // TODO(rw): this works and is not the good way to it:
@@ -336,7 +338,7 @@ class PythonGenerator : public BaseGenerator {
     auto vectortype = field.value.type.VectorType();
 
     GenReceiver(struct_def, code_ptr);
-    code += MakeCamel(NormalizedName(field));
+    code += ConvertCase(NormalizedName(field), Case::kUpperCamel);
     code += "(self, j):" + OffsetPrefix(field);
     code += Indent + Indent + Indent + "x = self._tab.Vector(o)\n";
     code += Indent + Indent + Indent;
@@ -365,7 +367,7 @@ class PythonGenerator : public BaseGenerator {
     auto vectortype = field.value.type.VectorType();
 
     GenReceiver(struct_def, code_ptr);
-    code += MakeCamel(NormalizedName(field));
+    code += ConvertCase(NormalizedName(field), Case::kUpperCamel);
     code += "(self, j):";
     code += OffsetPrefix(field);
     code += Indent + Indent + Indent + "a = self._tab.Vector(o)\n";
@@ -394,13 +396,14 @@ class PythonGenerator : public BaseGenerator {
     if (!(IsScalar(vectortype.base_type))) { return; }
 
     GenReceiver(struct_def, code_ptr);
-    code += MakeCamel(NormalizedName(field)) + "AsNumpy(self):";
+    code += ConvertCase(NormalizedName(field), Case::kUpperCamel) +
+            "AsNumpy(self):";
     code += OffsetPrefix(field);
 
     code += Indent + Indent + Indent;
     code += "return ";
     code += "self._tab.GetVectorAsNumpy(flatbuffers.number_types.";
-    code += MakeCamel(GenTypeGet(field.value.type));
+    code += ConvertCase(GenTypeGet(field.value.type), Case::kUpperCamel);
     code += "Flags, o)\n";
 
     if (IsString(vectortype)) {
@@ -431,7 +434,8 @@ class PythonGenerator : public BaseGenerator {
 
     auto &code = *code_ptr;
     GenReceiver(struct_def, code_ptr);
-    code += MakeCamel(NormalizedName(field)) + "NestedRoot(self):";
+    code += ConvertCase(NormalizedName(field), Case::kUpperCamel) +
+            "NestedRoot(self):";
 
     code += OffsetPrefix(field);
 
@@ -479,7 +483,9 @@ class PythonGenerator : public BaseGenerator {
       } else {
         auto &code = *code_ptr;
         code += std::string(", ") + nameprefix;
-        if (has_field_name) { code += MakeCamel(NormalizedName(field), false); }
+        if (has_field_name) {
+          code += ConvertCase(NormalizedName(field), Case::kLowerCamel);
+        }
         code += namesuffix;
       }
     }
@@ -530,7 +536,8 @@ class PythonGenerator : public BaseGenerator {
         } else {
           code += IsArray(field_type) ? "    " : "";
           code += indent + "    builder.Prepend" + GenMethod(field) + "(";
-          code += nameprefix + MakeCamel(NormalizedName(field), false);
+          code += nameprefix +
+                  ConvertCase(NormalizedName(field), Case::kLowerCamel);
           size_t array_cnt = index + (IsArray(field_type) ? 1 : 0);
           for (size_t i = 0; in_array && i < array_cnt; i++) {
             code += "[_idx" + NumToString(i) + "-1]";
@@ -571,9 +578,9 @@ class PythonGenerator : public BaseGenerator {
 
     // Generate method with struct name.
     code += "def " + NormalizedName(struct_def) + "Add" +
-            MakeCamel(NormalizedName(field));
+            ConvertCase(NormalizedName(field), Case::kUpperCamel);
     code += "(builder, ";
-    code += MakeCamel(NormalizedName(field), false);
+    code += ConvertCase(NormalizedName(field), Case::kLowerCamel);
     code += "): ";
     code += "builder.Prepend";
     code += GenMethod(field) + "Slot(";
@@ -581,9 +588,9 @@ class PythonGenerator : public BaseGenerator {
     if (!IsScalar(field.value.type.base_type) && (!struct_def.fixed)) {
       code += "flatbuffers.number_types.UOffsetTFlags.py_type";
       code += "(";
-      code += MakeCamel(NormalizedName(field), false) + ")";
+      code += ConvertCase(NormalizedName(field), Case::kLowerCamel) + ")";
     } else {
-      code += MakeCamel(NormalizedName(field), false);
+      code += ConvertCase(NormalizedName(field), Case::kLowerCamel);
     }
     code += ", ";
     code += IsFloat(field.value.type.base_type)
@@ -593,14 +600,14 @@ class PythonGenerator : public BaseGenerator {
 
     if (!parser_.opts.one_file) {
       // Generate method without struct name.
-      code += "def Add" + MakeCamel(NormalizedName(field));
+      code += "def Add" + ConvertCase(NormalizedName(field), Case::kUpperCamel);
       code += "(builder, ";
-      code += MakeCamel(NormalizedName(field), false);
+      code += ConvertCase(NormalizedName(field), Case::kLowerCamel);
       code += "):\n";
       code += Indent + "return " + NormalizedName(struct_def) + "Add" +
-              MakeCamel(NormalizedName(field));
+              ConvertCase(NormalizedName(field), Case::kUpperCamel);
       code += "(builder, ";
-      code += MakeCamel(NormalizedName(field), false);
+      code += ConvertCase(NormalizedName(field), Case::kLowerCamel);
       code += ")\n";
     }
   }
@@ -612,7 +619,7 @@ class PythonGenerator : public BaseGenerator {
 
     // Generate method with struct name.
     code += "def " + NormalizedName(struct_def) + "Start";
-    code += MakeCamel(NormalizedName(field));
+    code += ConvertCase(NormalizedName(field), Case::kUpperCamel);
     code += "Vector(builder, numElems): return builder.StartVector(";
     auto vector_type = field.value.type.VectorType();
     auto alignment = InlineAlignment(vector_type);
@@ -624,10 +631,10 @@ class PythonGenerator : public BaseGenerator {
     if (!parser_.opts.one_file) {
       // Generate method without struct name.
       code += "def Start";
-      code += MakeCamel(NormalizedName(field));
+      code += ConvertCase(NormalizedName(field), Case::kUpperCamel);
       code += "Vector(builder, numElems):\n";
       code += Indent + "return " + NormalizedName(struct_def) + "Start";
-      code += MakeCamel(NormalizedName(field));
+      code += ConvertCase(NormalizedName(field), Case::kUpperCamel);
       code += "Vector(builder, numElems)\n";
     }
   }
@@ -656,7 +663,7 @@ class PythonGenerator : public BaseGenerator {
 
     // Generate method with struct and field name.
     code += "def " + NormalizedName(struct_def) + "Make";
-    code += MakeCamel(NormalizedName(field));
+    code += ConvertCase(NormalizedName(field), Case::kUpperCamel);
     code += "VectorFromBytes(builder, bytes):\n";
     code += Indent + "builder.StartVector(";
     auto vector_type = field.value.type.VectorType();
@@ -672,10 +679,11 @@ class PythonGenerator : public BaseGenerator {
 
     if (!parser_.opts.one_file) {
       // Generate method without struct and field name.
-      code += "def Make" + MakeCamel(NormalizedName(field)) +
+      code += "def Make" +
+              ConvertCase(NormalizedName(field), Case::kUpperCamel) +
               "VectorFromBytes(builder, bytes):\n";
       code += Indent + "return " + NormalizedName(struct_def) + "Make" +
-              MakeCamel(NormalizedName(field)) +
+              ConvertCase(NormalizedName(field), Case::kUpperCamel) +
               "VectorFromBytes(builder, bytes)\n";
     }
   }
@@ -1653,14 +1661,14 @@ class PythonGenerator : public BaseGenerator {
       case BASE_TYPE_VECTOR: return GenGetter(type.VectorType());
       default:
         return "self._tab.Get(flatbuffers.number_types." +
-               MakeCamel(GenTypeGet(type)) + "Flags, ";
+               ConvertCase(GenTypeGet(type), Case::kUpperCamel) + "Flags, ";
     }
   }
 
   // Returns the method name for use with add/put calls.
   std::string GenMethod(const FieldDef &field) {
     return (IsScalar(field.value.type.base_type) || IsArray(field.value.type))
-               ? MakeCamel(GenTypeBasic(field.value.type))
+               ? ConvertCase(GenTypeBasic(field.value.type), Case::kUpperCamel)
                : (IsStruct(field.value.type) ? "Struct" : "UOffsetTRelative");
   }
 
diff --git a/src/idl_gen_rust.cpp b/src/idl_gen_rust.cpp
index a00a07d3e..511689809 100644
--- a/src/idl_gen_rust.cpp
+++ b/src/idl_gen_rust.cpp
@@ -25,34 +25,17 @@ namespace flatbuffers {
 
 // Convert a camelCaseIdentifier or CamelCaseIdentifier to a
 // snake_case_identifier.
-std::string MakeSnakeCase(const std::string &in) {
-  std::string s;
-  for (size_t i = 0; i < in.length(); i++) {
-    if (i == 0) {
-      s += CharToLower(in[0]);
-    } else if (in[i] == '_') {
-      s += '_';
-    } else if (!islower(in[i])) {
-      // Prevent duplicate underscores for Upper_Snake_Case strings
-      // and UPPERCASE strings.
-      if (islower(in[i - 1])) { s += '_'; }
-      s += CharToLower(in[i]);
-    } else {
-      s += in[i];
-    }
-  }
-  return s;
+inline std::string MakeSnakeCase(const std::string &in) {
+  return ConvertCase(in, Case::kSnake, Case::kLowerCamel);
 }
 
 // Convert a string to all uppercase.
-std::string MakeUpper(const std::string &in) {
-  std::string s;
-  for (size_t i = 0; i < in.length(); i++) { s += CharToUpper(in[i]); }
-  return s;
+inline std::string MakeUpper(const std::string &in) {
+  return ConvertCase(in, Case::kAllUpper);
 }
 
 std::string UnionTypeFieldName(const FieldDef &field) {
-  return MakeSnakeCase(field.name + "_type");
+  return ConvertCase(field.name + "_type", Case::kSnake);
 }
 
 // Encapsulate all logical field types in this enum. This allows us to write
@@ -941,7 +924,8 @@ class RustGenerator : public BaseGenerator {
       auto &enum_val = **it;
       if (enum_val.union_type.base_type == BASE_TYPE_NONE) continue;
       code_.SetValue("VARIANT_NAME", Name(enum_val));
-      code_.SetValue("NATIVE_VARIANT", MakeCamel(Name(enum_val)));
+      code_.SetValue("NATIVE_VARIANT",
+                     ConvertCase(Name(enum_val), Case::kUpperCamel));
       code_.SetValue("U_ELEMENT_NAME", MakeSnakeCase(Name(enum_val)));
       code_.SetValue("U_ELEMENT_TABLE_TYPE",
                      NamespacedNativeName(*enum_val.union_type.struct_def));
diff --git a/src/idl_gen_swift.cpp b/src/idl_gen_swift.cpp
index b053a70ba..c3c322fca 100644
--- a/src/idl_gen_swift.cpp
+++ b/src/idl_gen_swift.cpp
@@ -651,7 +651,7 @@ class SwiftGenerator : public BaseGenerator {
     }
 
     auto camel_case_name =
-        MakeCamel(name, false) +
+        ConvertCase(name, Case::kLowerCamel) +
         (IsVector(field.value.type) || IsArray(field.value.type)
              ? "VectorOffset"
              : "Offset");
@@ -669,7 +669,8 @@ class SwiftGenerator : public BaseGenerator {
          field.value.type.struct_def->fixed) &&
         (IsVector(field.value.type) || IsArray(field.value.type))) {
       auto field_name = NameWrappedInNameSpace(*vectortype.struct_def);
-      code_ += "public static func startVectorOf" + MakeCamel(name, true) +
+      code_ += "public static func startVectorOf" +
+               ConvertCase(name, Case::kUpperCamel) +
                "(_ size: Int, in builder: inout "
                "FlatBufferBuilder) {";
       Indent();
@@ -746,7 +747,8 @@ class SwiftGenerator : public BaseGenerator {
       code_.SetValue("CONSTANT", "nil");
       code_ += GenReaderMainBody(is_required) + GenOffset() + required_reader +
                "{{ACCESS}}.readBuffer(of: {{VALUETYPE}}.self, at: o) }";
-      code_.SetValue("VALUENAME", "mutable" + MakeCamel(name));
+      code_.SetValue("VALUENAME",
+                     "mutable" + ConvertCase(name, Case::kUpperCamel));
       code_.SetValue("VALUETYPE", GenType(field.value.type) + Mutable());
       code_.SetValue("CONSTANT", "nil");
       code_ += GenReaderMainBody(is_required) + GenOffset() + required_reader +
@@ -834,7 +836,8 @@ class SwiftGenerator : public BaseGenerator {
       code_ +=
           "{{ACCESS}}.directRead(of: {{VALUETYPE}}.self, offset: "
           "{{ACCESS}}.vector(at: o) + index * {{SIZE}}) }";
-      code_.SetValue("VALUENAME", "mutable" + MakeCamel(Name(field)));
+      code_.SetValue("VALUENAME",
+                     "mutable" + ConvertCase(Name(field), Case::kUpperCamel));
       code_.SetValue("VALUETYPE", GenType(field.value.type) + Mutable());
       code_ += GenArrayMainBody(nullable) + GenOffset() + const_string +
                GenConstructor("{{ACCESS}}.vector(at: o) + index * {{SIZE}}");
@@ -1435,8 +1438,9 @@ class SwiftGenerator : public BaseGenerator {
           code_ += "let __" + name + " = builder.createVector(ofOffsets: __" +
                    name + "__)";
         } else {
-          code_ += "{{STRUCTNAME}}.startVectorOf" + MakeCamel(name, true) +
-                   "(obj." + name + ".count, in: &builder)";
+          code_ += "{{STRUCTNAME}}.startVectorOf" +
+                   ConvertCase(name, Case::kUpperCamel) + "(obj." + name +
+                   ".count, in: &builder)";
           std::string code;
           GenerateStructArgs(*field.value.type.struct_def, &code, "", "", "_o",
                              true);
@@ -1909,11 +1913,11 @@ class SwiftGenerator : public BaseGenerator {
     if (isupper(name.front())) {
       std::transform(name.begin(), name.end(), name.begin(), CharToLower);
     }
-    return EscapeKeyword(MakeCamel(name, false));
+    return EscapeKeyword(ConvertCase(name, Case::kLowerCamel));
   }
 
   std::string Name(const Definition &def) const {
-    return EscapeKeyword(MakeCamel(def.name, false));
+    return EscapeKeyword(ConvertCase(def.name, Case::kLowerCamel));
   }
 };
 }  // namespace swift
diff --git a/src/idl_gen_ts.cpp b/src/idl_gen_ts.cpp
index 6ab336089..2c69519c1 100644
--- a/src/idl_gen_ts.cpp
+++ b/src/idl_gen_ts.cpp
@@ -282,8 +282,8 @@ class TsGenerator : public BaseGenerator {
         return GenBBAccess() + ".__union_with_string" + arguments;
       case BASE_TYPE_VECTOR: return GenGetter(type.VectorType(), arguments);
       default: {
-        auto getter =
-            GenBBAccess() + ".read" + MakeCamel(GenType(type)) + arguments;
+        auto getter = GenBBAccess() + ".read" +
+                      ConvertCase(GenType(type), Case::kUpperCamel) + arguments;
         if (type.base_type == BASE_TYPE_BOOL) { getter = "!!" + getter; }
         return getter;
       }
@@ -369,8 +369,9 @@ class TsGenerator : public BaseGenerator {
       default: break;
     }
 
-    return IsScalar(type.base_type) ? MakeCamel(GenType(type))
-                                    : (IsStruct(type) ? "Struct" : "Offset");
+    return IsScalar(type.base_type)
+               ? ConvertCase(GenType(type), Case::kUpperCamel)
+               : (IsStruct(type) ? "Struct" : "Offset");
   }
 
   template<typename T> static std::string MaybeAdd(T value) {
@@ -829,7 +830,7 @@ class TsGenerator : public BaseGenerator {
       auto &field = **it;
 
       const auto curr_member_accessor =
-          prefix + "." + MakeCamel(field.name, false);
+          prefix + "." + ConvertCase(field.name, Case::kLowerCamel);
       if (IsStruct(field.value.type)) {
         ret += GenStructMemberValueTS(*field.value.type.struct_def,
                                       curr_member_accessor, delimiter);
@@ -894,7 +895,7 @@ class TsGenerator : public BaseGenerator {
       auto &field = **it;
       if (field.deprecated) continue;
 
-      const auto field_name = MakeCamel(field.name, false);
+      const auto field_name = ConvertCase(field.name, Case::kLowerCamel);
       const auto field_name_escaped = EscapeKeyword(field_name);
       const std::string field_binded_method =
           "this." + field_name + ".bind(this)";
@@ -975,13 +976,13 @@ class TsGenerator : public BaseGenerator {
                 if (sd.fixed) {
                   field_offset_decl =
                       "builder.createStructOffsetList(this." +
-                      field_name_escaped +
-                      ", " + AddImport(imports, struct_def, struct_def) +
-                      ".start" + MakeCamel(field_name) + "Vector)";
+                      field_name_escaped + ", " +
+                      AddImport(imports, struct_def, struct_def) + ".start" +
+                      ConvertCase(field_name, Case::kUpperCamel) + "Vector)";
                 } else {
                   field_offset_decl =
                       AddImport(imports, struct_def, struct_def) + ".create" +
-                      MakeCamel(field_name) +
+                      ConvertCase(field_name, Case::kUpperCamel) +
                       "Vector(builder, builder.createObjectOffsetList(" +
                       "this." + field_name_escaped + "))";
                 }
@@ -996,7 +997,7 @@ class TsGenerator : public BaseGenerator {
                             "Length())";
                 field_offset_decl =
                     AddImport(imports, struct_def, struct_def) + ".create" +
-                    MakeCamel(field_name) +
+                    ConvertCase(field_name, Case::kUpperCamel) +
                     "Vector(builder, builder.createObjectOffsetList(" +
                     "this." + field_name_escaped + "))";
                 break;
@@ -1011,7 +1012,7 @@ class TsGenerator : public BaseGenerator {
 
                 field_offset_decl =
                     AddImport(imports, struct_def, struct_def) + ".create" +
-                    MakeCamel(field_name) +
+                    ConvertCase(field_name, Case::kUpperCamel) +
                     "Vector(builder, builder.createObjectOffsetList(" +
                     "this." + field_name_escaped + "))";
 
@@ -1029,10 +1030,10 @@ class TsGenerator : public BaseGenerator {
                             field_binded_method + ", this." + field_name +
                             "Length())";
 
-                field_offset_decl = AddImport(imports, struct_def, struct_def) +
-                                    ".create" + MakeCamel(field_name) +
-                                    "Vector(builder, this." +
-                                    field_name_escaped + ")";
+                field_offset_decl =
+                    AddImport(imports, struct_def, struct_def) + ".create" +
+                    ConvertCase(field_name, Case::kUpperCamel) +
+                    "Vector(builder, this." + field_name_escaped + ")";
 
                 break;
               }
@@ -1083,8 +1084,8 @@ class TsGenerator : public BaseGenerator {
             pack_func_create_call += "  if (" + field_offset_val + " !== null)\n  ";
           }
           pack_func_create_call += "  " + struct_name + ".add" +
-                                   MakeCamel(field.name) + "(builder, " +
-                                   field_offset_val + ");\n";
+                                   ConvertCase(field.name, Case::kUpperCamel) +
+                                   "(builder, " + field_offset_val + ");\n";
         }
       }
 
@@ -1202,7 +1203,7 @@ class TsGenerator : public BaseGenerator {
         const auto has_null_default = is_string || HasNullDefault(field);
 
         GenDocComment(field.doc_comment, code_ptr);
-        std::string prefix = MakeCamel(field.name, false) + "(";
+        std::string prefix = ConvertCase(field.name, Case::kLowerCamel) + "(";
         if (is_string) {
           code += prefix + "):string|null\n";
           code +=
@@ -1248,7 +1249,7 @@ class TsGenerator : public BaseGenerator {
             const auto type =
                 AddImport(imports, struct_def, *field.value.type.struct_def);
             GenDocComment(field.doc_comment, code_ptr);
-            code += MakeCamel(field.name, false);
+            code += ConvertCase(field.name, Case::kLowerCamel);
             code += "(obj?:" + type + "):" + type + "|null {\n";
 
             if (struct_def.fixed) {
@@ -1288,7 +1289,7 @@ class TsGenerator : public BaseGenerator {
               default: ret_type = vectortypename;
             }
             GenDocComment(field.doc_comment, code_ptr);
-            std::string prefix = MakeCamel(field.name, false);
+            std::string prefix = ConvertCase(field.name, Case::kLowerCamel);
             // TODO: make it work without any
             // if (is_union) { prefix += "<T extends flatbuffers.Table>"; }
             if (is_union) { prefix += ""; }
@@ -1348,7 +1349,7 @@ class TsGenerator : public BaseGenerator {
 
           case BASE_TYPE_UNION: {
             GenDocComment(field.doc_comment, code_ptr);
-            code += MakeCamel(field.name, false);
+            code += ConvertCase(field.name, Case::kLowerCamel);
 
             const auto &union_enum = *(field.value.type.enum_def);
             const auto union_type = GenUnionGenericTypeTS(union_enum);
@@ -1377,8 +1378,8 @@ class TsGenerator : public BaseGenerator {
 
         if (struct_def.fixed) {
           code += "  " + GenBBAccess() + ".write" +
-                  MakeCamel(GenType(field.value.type)) + "(this.bb_pos + " +
-                  NumToString(field.value.offset) + ", ";
+                  ConvertCase(GenType(field.value.type), Case::kUpperCamel) +
+                  "(this.bb_pos + " + NumToString(field.value.offset) + ", ";
         } else {
           code += "  const offset = " + GenBBAccess() +
                   ".__offset(this.bb_pos, " + NumToString(field.value.offset) +
@@ -1389,7 +1390,7 @@ class TsGenerator : public BaseGenerator {
 
           // special case for bools, which are treated as uint8
           code += "  " + GenBBAccess() + ".write" +
-                  MakeCamel(GenType(field.value.type)) +
+                  ConvertCase(GenType(field.value.type), Case::kUpperCamel) +
                   "(this.bb_pos + offset, ";
           if (field.value.type.base_type == BASE_TYPE_BOOL) { code += "+"; }
         }
@@ -1403,7 +1404,7 @@ class TsGenerator : public BaseGenerator {
       if (IsVector(field.value.type)) {
         // Emit a length helper
         GenDocComment(code_ptr);
-        code += MakeCamel(field.name, false);
+        code += ConvertCase(field.name, Case::kLowerCamel);
         code += "Length():number {\n" + offset_prefix;
 
         code +=
@@ -1414,7 +1415,7 @@ class TsGenerator : public BaseGenerator {
         if (IsScalar(vectorType.base_type) && !IsLong(vectorType.base_type)) {
           GenDocComment(code_ptr);
 
-          code += MakeCamel(field.name, false);
+          code += ConvertCase(field.name, Case::kLowerCamel);
           code += "Array():" + GenType(vectorType) + "Array|null {\n" +
                   offset_prefix;
 
@@ -1475,7 +1476,7 @@ class TsGenerator : public BaseGenerator {
 
         // Generate the field insertion method
         GenDocComment(code_ptr);
-        code += "static add" + MakeCamel(field.name);
+        code += "static add" + ConvertCase(field.name, Case::kUpperCamel);
         code += "(builder:flatbuffers.Builder, " + argname + ":" +
                 GetArgType(imports, struct_def, field, false) + ") {\n";
         code += "  builder.addField" + GenWriteMethod(field.value.type) + "(";
@@ -1506,7 +1507,7 @@ class TsGenerator : public BaseGenerator {
             GenDocComment(code_ptr);
 
             const std::string sig_begin =
-                "static create" + MakeCamel(field.name) +
+                "static create" + ConvertCase(field.name, Case::kUpperCamel) +
                 "Vector(builder:flatbuffers.Builder, data:";
             const std::string sig_end = "):flatbuffers.Offset";
             std::string type =
@@ -1544,7 +1545,7 @@ class TsGenerator : public BaseGenerator {
           // after
           GenDocComment(code_ptr);
 
-          code += "static start" + MakeCamel(field.name);
+          code += "static start" + ConvertCase(field.name, Case::kUpperCamel);
           code += "Vector(builder:flatbuffers.Builder, numElems:number) {\n";
           code += "  builder.startVector(" + NumToString(elem_size);
           code += ", numElems, " + NumToString(alignment) + ");\n";
@@ -1603,7 +1604,8 @@ class TsGenerator : public BaseGenerator {
             code += "  if (" + arg_name + " !== null)\n  ";
           }
 
-          code += "  " + methodPrefix + ".add" + MakeCamel(field.name) + "(";
+          code += "  " + methodPrefix + ".add" +
+                  ConvertCase(field.name, Case::kUpperCamel) + "(";
           code += "builder, " + arg_name + ");\n";
         }
 
@@ -1650,7 +1652,7 @@ class TsGenerator : public BaseGenerator {
   }
 
   std::string GetArgName(const FieldDef &field) {
-    auto argname = MakeCamel(field.name, false);
+    auto argname = ConvertCase(field.name, Case::kLowerCamel);
     if (!IsScalar(field.value.type.base_type)) {
       argname += "Offset";
     } else {
diff --git a/src/idl_parser.cpp b/src/idl_parser.cpp
index fc9e095b2..dd106dfd4 100644
--- a/src/idl_parser.cpp
+++ b/src/idl_parser.cpp
@@ -93,33 +93,6 @@ static bool IsLowerSnakeCase(const std::string &str) {
   return true;
 }
 
-// Convert an underscore_based_identifier in to camelCase.
-// Also uppercases the first character if first is true.
-std::string MakeCamel(const std::string &in, bool first) {
-  std::string s;
-  for (size_t i = 0; i < in.length(); i++) {
-    if (!i && first)
-      s += CharToUpper(in[0]);
-    else if (in[i] == '_' && i + 1 < in.length())
-      s += CharToUpper(in[++i]);
-    else
-      s += in[i];
-  }
-  return s;
-}
-
-// Convert an underscore_based_identifier in to screaming snake case.
-std::string MakeScreamingCamel(const std::string &in) {
-  std::string s;
-  for (size_t i = 0; i < in.length(); i++) {
-    if (in[i] != '_')
-      s += CharToUpper(in[i]);
-    else
-      s += in[i];
-  }
-  return s;
-}
-
 void DeserializeDoc(std::vector<std::string> &doc,
                     const Vector<Offset<String>> *documentation) {
   if (documentation == nullptr) return;
@@ -2856,7 +2829,7 @@ CheckedError Parser::ParseProtoFields(StructDef *struct_def, bool isextend,
       if (IsIdent("group") || oneof) {
         if (!oneof) NEXT();
         if (oneof && opts.proto_oneof_union) {
-          auto name = MakeCamel(attribute_, true) + "Union";
+          auto name = ConvertCase(attribute_, Case::kUpperCamel) + "Union";
           ECHECK(StartEnum(name, true, &oneof_union));
           type = Type(BASE_TYPE_UNION, nullptr, oneof_union);
         } else {
diff --git a/src/util.cpp b/src/util.cpp
index 7b6378f52..1cf459be8 100644
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -46,6 +46,7 @@
 
 #include <clocale>
 #include <cstdlib>
+#include <functional>
 #include <fstream>
 
 #include "flatbuffers/base.h"
@@ -318,4 +319,94 @@ void SetupDefaultCRTReportMode() {
   // clang-format on
 }
 
+namespace {
+
+static std::string ToCamelCase(const std::string &input, bool first) {
+  std::string s;
+  for (size_t i = 0; i < input.length(); i++) {
+    if (!i && first)
+      s += CharToUpper(input[i]);
+    else if (input[i] == '_' && i + 1 < input.length())
+      s += CharToUpper(input[++i]);
+    else
+      s += input[i];
+  }
+  return s;
+}
+
+static std::string ToSnakeCase(const std::string &input, bool screaming) {
+  std::string s;
+  for (size_t i = 0; i < input.length(); i++) {
+    if (i == 0) {
+      s += screaming ? CharToUpper(input[i]) : CharToLower(input[i]);
+    } else if (input[i] == '_') {
+      s += '_';
+    } else if (!islower(input[i])) {
+      // Prevent duplicate underscores for Upper_Snake_Case strings
+      // and UPPERCASE strings.
+      if (islower(input[i - 1])) { s += '_'; }
+      s += screaming ? CharToUpper(input[i]) : CharToLower(input[i]);
+    } else {
+      s += screaming ? CharToUpper(input[i]) : input[i];
+    }
+  }
+  return s;
+}
+
+static std::string ToAll(const std::string &input,
+                         std::function<char(const char)> transform) {
+  std::string s;
+  for (size_t i = 0; i < input.length(); i++) { s += transform(input[i]); }
+  return s;
+}
+
+static std::string CamelToSnake(const std::string &input) {
+  std::string s;
+  for (size_t i = 0; i < input.length(); i++) {
+    if (i == 0) {
+      s += CharToLower(input[i]);
+    } else if (input[i] == '_') {
+      s += '_';
+    } else if (!islower(input[i])) {
+      // Prevent duplicate underscores for Upper_Snake_Case strings
+      // and UPPERCASE strings.
+      if (islower(input[i - 1])) { s += '_'; }
+      s += CharToLower(input[i]);
+    } else {
+      s += input[i];
+    }
+  }
+  return s;
+}
+
+}  // namespace
+
+std::string ConvertCase(const std::string &input, Case output_case,
+                        Case input_case) {
+  // The output cases expect snake_case inputs, so if we don't have that input
+  // format, try to convert to snake_case.
+  switch (input_case) {
+    case Case::kLowerCamel:
+    case Case::kUpperCamel:
+      return ConvertCase(CamelToSnake(input), output_case);
+
+    default:
+    case Case::kSnake:
+    case Case::kScreamingSnake:
+    case Case::kAllLower:
+    case Case::kAllUpper: break;
+  }
+
+  switch (output_case) {
+    case Case::kUpperCamel: return ToCamelCase(input, true);
+    case Case::kLowerCamel: return ToCamelCase(input, false);
+    case Case::kSnake: return input;
+    case Case::kScreamingSnake: return ToSnakeCase(input, true);
+    case Case::kAllUpper: return ToAll(input, CharToUpper);
+    case Case::kAllLower: return ToAll(input, CharToLower);
+    default:
+    case Case::kUnknown: return input;
+  }
+}
+
 }  // namespace flatbuffers
diff --git a/tests/test.cpp b/tests/test.cpp
index 530bcbc82..19af4b14b 100644
--- a/tests/test.cpp
+++ b/tests/test.cpp
@@ -211,7 +211,7 @@ flatbuffers::DetachedBuffer CreateFlatBufferTest(std::string &buffer) {
 
   FinishMonsterBuffer(builder, mloc);
 
-  // clang-format off
+// clang-format off
   #ifdef FLATBUFFERS_TEST_VERBOSE
   // print byte data for debugging:
   auto p = builder.GetBufferPointer();
@@ -237,7 +237,7 @@ void AccessFlatBufferTest(const uint8_t *flatbuf, size_t length,
   verifier.SetFlexReuseTracker(&flex_reuse_tracker);
   TEST_EQ(VerifyMonsterBuffer(verifier), true);
 
-  // clang-format off
+// clang-format off
   #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
     std::vector<uint8_t> test_buff;
     test_buff.resize(length * 2);
@@ -618,7 +618,7 @@ void SizePrefixedTest() {
 }
 
 void TriviallyCopyableTest() {
-  // clang-format off
+// clang-format off
   #if __GNUG__ && __GNUC__ < 5
     TEST_EQ(__has_trivial_copy(Vec3), true);
   #else
@@ -1395,6 +1395,86 @@ void CompareTableFieldValue(flatbuffers::Table *table,
   TEST_EQ(read, val);
 }
 
+void UtilConvertCase() {
+  {
+    std::vector<std::tuple<std::string, flatbuffers::Case, std::string>>
+        cases = {
+          // Tests for the common cases
+          { "the_quick_brown_fox", flatbuffers::Case::kUpperCamel,
+            "TheQuickBrownFox" },
+          { "the_quick_brown_fox", flatbuffers::Case::kLowerCamel,
+            "theQuickBrownFox" },
+          { "the_quick_brown_fox", flatbuffers::Case::kSnake,
+            "the_quick_brown_fox" },
+          { "the_quick_brown_fox", flatbuffers::Case::kScreamingSnake,
+            "THE_QUICK_BROWN_FOX" },
+          { "the_quick_brown_fox", flatbuffers::Case::kAllLower,
+            "the_quick_brown_fox" },
+          { "the_quick_brown_fox", flatbuffers::Case::kAllUpper,
+            "THE_QUICK_BROWN_FOX" },
+          { "the_quick_brown_fox", flatbuffers::Case::kUnknown,
+            "the_quick_brown_fox" },
+
+          // Tests for some snake_cases where the _ is oddly placed or missing.
+          { "single", flatbuffers::Case::kUpperCamel, "Single" },
+          { "Single", flatbuffers::Case::kUpperCamel, "Single" },
+          { "_leading", flatbuffers::Case::kUpperCamel, "_leading" },
+          { "trailing_", flatbuffers::Case::kUpperCamel, "Trailing_" },
+          { "double__underscore", flatbuffers::Case::kUpperCamel,
+            "Double_underscore" },
+          { "single", flatbuffers::Case::kLowerCamel, "single" },
+          { "Single", flatbuffers::Case::kLowerCamel, "Single" },
+          { "_leading", flatbuffers::Case::kLowerCamel, "Leading" },
+          { "trailing_", flatbuffers::Case::kLowerCamel, "trailing_" },
+          { "double__underscore", flatbuffers::Case::kLowerCamel,
+            "double_underscore" },
+
+          // Tests for some output snake_cases
+          { "single", flatbuffers::Case::kSnake, "single" },
+          { "single", flatbuffers::Case::kScreamingSnake, "SINGLE" },
+          { "_leading", flatbuffers::Case::kScreamingSnake, "_LEADING" },
+          { "trailing_", flatbuffers::Case::kScreamingSnake, "TRAILING_" },
+          { "double__underscore", flatbuffers::Case::kScreamingSnake,
+            "DOUBLE__UNDERSCORE" },
+        };
+
+    for (auto &test_case : cases) {
+      TEST_EQ(std::get<2>(test_case),
+              flatbuffers::ConvertCase(std::get<0>(test_case),
+                                       std::get<1>(test_case)));
+    }
+  }
+  
+  // Tests for the non snake_case inputs.
+  {
+    std::vector<std::tuple<flatbuffers::Case, std::string, flatbuffers::Case,
+                           std::string>>
+        cases = {
+          { flatbuffers::Case::kUpperCamel, "TheQuickBrownFox",
+            flatbuffers::Case::kSnake, "the_quick_brown_fox" },
+          { flatbuffers::Case::kLowerCamel, "theQuickBrownFox",
+            flatbuffers::Case::kSnake, "the_quick_brown_fox" },
+          { flatbuffers::Case::kSnake, "the_quick_brown_fox",
+            flatbuffers::Case::kSnake, "the_quick_brown_fox" },
+          { flatbuffers::Case::kScreamingSnake, "THE_QUICK_BROWN_FOX",
+            flatbuffers::Case::kSnake, "THE_QUICK_BROWN_FOX" },
+          { flatbuffers::Case::kAllUpper, "SINGLE", flatbuffers::Case::kSnake,
+            "SINGLE" },
+          { flatbuffers::Case::kAllLower, "single", flatbuffers::Case::kSnake,
+            "single" },
+          { flatbuffers::Case::kUpperCamel, "ABCtest",
+            flatbuffers::Case::kSnake, "abctest" },
+        };
+
+    for (auto &test_case : cases) {
+      TEST_EQ(std::get<3>(test_case),
+              flatbuffers::ConvertCase(std::get<1>(test_case),
+                                       std::get<2>(test_case),
+                                       std::get<0>(test_case)));
+    }
+  }
+}
+
 // Low level stress/fuzz test: serialize/deserialize a variety of
 // different kinds of data in different combinations
 void FuzzTest1() {
@@ -1506,7 +1586,7 @@ void FuzzTest2() {
     }
   };
 
-  // clang-format off
+// clang-format off
   #define AddToSchemaAndInstances(schema_add, instance_add) \
     RndDef::Add(definitions, schema, instances_per_definition, \
                 schema_add, instance_add, definition)
@@ -1660,7 +1740,7 @@ void FuzzTest2() {
     TEST_NOTNULL(nullptr);  //-V501 (this comment supresses CWE-570 warning)
   }
 
-  // clang-format off
+// clang-format off
   #ifdef FLATBUFFERS_TEST_VERBOSE
     TEST_OUTPUT_LINE("%dk schema tested with %dk of json\n",
                      static_cast<int>(schema.length() / 1024),
@@ -3052,7 +3132,7 @@ void FlexBuffersTest() {
   });
   slb.Finish();
 
-  // clang-format off
+// clang-format off
   #ifdef FLATBUFFERS_TEST_VERBOSE
     for (size_t i = 0; i < slb.GetBuffer().size(); i++)
       printf("%d ", slb.GetBuffer().data()[i]);
@@ -4198,6 +4278,8 @@ int FlatBufferTests() {
   #endif
   // clang-format on
 
+  UtilConvertCase();
+
   FuzzTest1();
   FuzzTest2();