[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"project-83820":3},{"id":4,"name":5,"fullName":6,"owner":7,"repo":5,"description":8,"homepage":9,"htmlUrl":10,"language":11,"languages":9,"totalLinesOfCode":9,"stars":12,"forks":13,"watchers":14,"openIssues":15,"contributorsCount":9,"subscribersCount":16,"size":16,"stars1d":17,"stars7d":17,"stars30d":17,"stars90d":16,"forks30d":16,"starsTrendScore":18,"compositeScore":19,"rankGlobal":9,"rankLanguage":9,"license":9,"archived":20,"fork":20,"defaultBranch":21,"hasWiki":20,"hasPages":20,"topics":22,"createdAt":9,"pushedAt":9,"updatedAt":38,"readmeContent":39,"aiSummary":9,"trendingCount":16,"starSnapshotCount":16,"syncStatus":40,"lastSyncTime":41,"discoverSource":42},83820,"magic_enum","Neargye\u002Fmagic_enum","Neargye","Static reflection for enums (to string, from string, iteration) for modern C++, work with any enum type without any macro or boilerplate code",null,"https:\u002F\u002Fgithub.com\u002FNeargye\u002Fmagic_enum","C++",6101,557,64,11,0,1,3,63.84,false,"main",[23,24,25,26,27,28,29,30,31,32,33,34,35,36,37],"cplusplus","cplusplus-17","c-plus-plus","c-plus-plus-17","cpp","cpp17","enum-to-string","string-to-enum","serialization","reflection","metaprogramming","header-only","single-file","no-dependencies","enum","2026-06-12 04:01:42","[![Github releases](https:\u002F\u002Fimg.shields.io\u002Fgithub\u002Frelease\u002FNeargye\u002Fmagic_enum.svg)](https:\u002F\u002Fgithub.com\u002FNeargye\u002Fmagic_enum\u002Freleases)\n[![Conan package](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FConan-package-blueviolet)](https:\u002F\u002Fconan.io\u002Fcenter\u002Frecipes\u002Fmagic_enum)\n[![Vcpkg package](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FVcpkg-package-blueviolet)](https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002Fvcpkg\u002Ftree\u002Fmaster\u002Fports\u002Fmagic-enum)\n[![Build2 package](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FBuild2-package-blueviolet)](https:\u002F\u002Fwww.cppget.org\u002Fmagic_enum?q=magic_enum)\n[![Meson wrap](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FMeson-wrap-blueviolet)](https:\u002F\u002Fgithub.com\u002Fmesonbuild\u002Fwrapdb\u002Fblob\u002Fmaster\u002Fsubprojects\u002Fmagic_enum.wrap)\n[![License](https:\u002F\u002Fimg.shields.io\u002Fgithub\u002Flicense\u002FNeargye\u002Fmagic_enum.svg)](LICENSE)\n[![Compiler explorer](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002Fcompiler_explorer-online-blue.svg)](https:\u002F\u002Fgodbolt.org\u002Fz\u002FfeqcPa5G6)\n[![OpenSSF Scorecard](https:\u002F\u002Fapi.securityscorecards.dev\u002Fprojects\u002Fgithub.com\u002FNeargye\u002Fmagic_enum\u002Fbadge)](https:\u002F\u002Fsecurityscorecards.dev\u002Fviewer\u002F?uri=github.com\u002FNeargye\u002Fmagic_enum)\n[![Stand With Ukraine](https:\u002F\u002Fraw.githubusercontent.com\u002Fvshymanskyy\u002FStandWithUkraine\u002Fmain\u002Fbadges\u002FStandWithUkraine.svg)](https:\u002F\u002Fstand-with-ukraine.pp.ua)\n\n# Magic Enum C++\n\nHeader-only C++17 library provides static reflection for enums, work with any enum type without any macro or boilerplate code.\n\nIf you like this project, please consider donating to one of the funds that help victims of the war in Ukraine: https:\u002F\u002Fu24.gov.ua.\n\n## Documentation\n\n* [Reference](doc\u002Freference.md)\n* [Limitations](doc\u002Flimitations.md)\n* [Integration](#Integration)\n\n## [Features & Examples](example\u002F)\n\n* Basic\n\n  ```cpp\n  #include \u003Cmagic_enum\u002Fmagic_enum.hpp>\n  #include \u003Ciostream>\n\n  enum class Color { RED = -10, BLUE = 0, GREEN = 10 };\n\n  int main() {\n    Color c1 = Color::RED;\n    std::cout \u003C\u003C magic_enum::enum_name(c1) \u003C\u003C std::endl; \u002F\u002F RED\n    return 0;\n  }\n  ```\n\n* Enum value to string\n\n  ```cpp\n  Color color = Color::RED;\n  auto color_name = magic_enum::enum_name(color);\n  \u002F\u002F color_name -> \"RED\"\n  ```\n\n* String to enum value\n\n  ```cpp\n  std::string color_name{\"GREEN\"};\n  auto color = magic_enum::enum_cast\u003CColor>(color_name);\n  if (color.has_value()) {\n    \u002F\u002F color.value() -> Color::GREEN\n  }\n\n  \u002F\u002F case insensitive enum_cast\n  auto color = magic_enum::enum_cast\u003CColor>(value, magic_enum::case_insensitive);\n\n  \u002F\u002F enum_cast with BinaryPredicate\n  auto color = magic_enum::enum_cast\u003CColor>(value, [](char lhs, char rhs) { return std::tolower(lhs) == std::tolower(rhs); });\n\n  \u002F\u002F enum_cast with default\n  auto color_or_default = magic_enum::enum_cast\u003CColor>(value).value_or(Color::NONE);\n  ```\n\n* Integer to enum value\n\n  ```cpp\n  int color_integer = 0;\n  auto color = magic_enum::enum_cast\u003CColor>(color_integer);\n  if (color.has_value()) {\n    \u002F\u002F color.value() -> Color::BLUE\n  }\n\n  auto color_or_default = magic_enum::enum_cast\u003CColor>(value).value_or(Color::NONE);\n  ```\n\n* Indexed access to enum value\n\n  ```cpp\n  std::size_t i = 0;\n  Color color = magic_enum::enum_value\u003CColor>(i);\n  \u002F\u002F color -> Color::RED\n  ```\n\n* Enum value sequence\n\n  ```cpp\n  constexpr auto colors = magic_enum::enum_values\u003CColor>();\n  \u002F\u002F colors -> {Color::RED, Color::BLUE, Color::GREEN}\n  \u002F\u002F colors[0] -> Color::RED\n  ```\n\n* Number of enum elements\n\n  ```cpp\n  constexpr std::size_t color_count = magic_enum::enum_count\u003CColor>();\n  \u002F\u002F color_count -> 3\n  ```\n\n* Enum value to integer\n\n  ```cpp\n  Color color = Color::RED;\n  auto color_integer = magic_enum::enum_integer(color); \u002F\u002F or magic_enum::enum_underlying(color);\n  \u002F\u002F color_integer -> -10\n  ```\n\n* Enum names sequence\n\n  ```cpp\n  constexpr auto color_names = magic_enum::enum_names\u003CColor>();\n  \u002F\u002F color_names -> {\"RED\", \"BLUE\", \"GREEN\"}\n  \u002F\u002F color_names[0] -> \"RED\"\n  ```\n\n* Enum entries sequence\n\n  ```cpp\n  constexpr auto color_entries = magic_enum::enum_entries\u003CColor>();\n  \u002F\u002F color_entries -> {{Color::RED, \"RED\"}, {Color::BLUE, \"BLUE\"}, {Color::GREEN, \"GREEN\"}}\n  \u002F\u002F color_entries[0].first -> Color::RED\n  \u002F\u002F color_entries[0].second -> \"RED\"\n  ```\n\n* Enum fusion for multi-level switch\u002Fcase statements\n\n  ```cpp\n  switch (magic_enum::enum_fuse(color, direction).value()) {\n    case magic_enum::enum_fuse(Color::RED, Directions::Up).value(): \u002F\u002F ...\n    case magic_enum::enum_fuse(Color::BLUE, Directions::Down).value(): \u002F\u002F ...\n  \u002F\u002F ...\n  }\n  ```\n\n* Enum switch runtime value as constexpr constant\n  ```cpp\n  Color color = Color::RED;\n  magic_enum::enum_switch([] (auto val) {\n    constexpr Color c_color = val;\n    \u002F\u002F ...\n  }, color);\n  ```\n\n* Enum iterate for each enum as constexpr constant\n  ```cpp\n  magic_enum::enum_for_each\u003CColor>([] (auto val) {\n    constexpr Color c_color = val;\n    \u002F\u002F ...\n  });\n  ```\n\n* Check if enum contains\n\n  ```cpp\n  magic_enum::enum_contains(Color::GREEN); \u002F\u002F -> true\n  magic_enum::enum_contains\u003CColor>(2); \u002F\u002F -> true\n  magic_enum::enum_contains\u003CColor>(123); \u002F\u002F -> false\n  magic_enum::enum_contains\u003CColor>(\"GREEN\"); \u002F\u002F -> true\n  magic_enum::enum_contains\u003CColor>(\"fda\"); \u002F\u002F -> false\n  ```\n\n* Enum index in sequence\n\n  ```cpp\n  constexpr auto color_index = magic_enum::enum_index(Color::BLUE);\n  \u002F\u002F color_index.value() -> 1\n  \u002F\u002F color_index.has_value() -> true\n  ```\n\n* Functions for flags\n\n  ```cpp\n  enum Directions : std::uint64_t {\n    Left = 1,\n    Down = 2,\n    Up = 4,\n    Right = 8,\n  };\n  template \u003C>\n  struct magic_enum::customize::enum_range\u003CDirections> {\n    static constexpr bool is_flags = true;\n  };\n\n  magic_enum::enum_flags_name(Directions::Up | Directions::Right); \u002F\u002F -> \"Directions::Up|Directions::Right\"\n  magic_enum::enum_flags_name(Directions::Up | Directions::Right, ','); \u002F\u002F -> \"Directions::Up,Directions::Right\"\n  magic_enum::enum_flags_contains(Directions::Up | Directions::Right); \u002F\u002F -> true\n  magic_enum::enum_flags_cast(3); \u002F\u002F -> \"Directions::Left|Directions::Down\"\n  magic_enum::enum_flags_cast\u003CDirections>(\"Left,Down\", ','); \u002F\u002F -> Directions::Left|Directions::Down\n  ```\n\n* Enum type name\n\n  ```cpp\n  Color color = Color::RED;\n  auto type_name = magic_enum::enum_type_name\u003Cdecltype(color)>();\n  \u002F\u002F type_name -> \"Color\"\n  ```\n\n* IOstream operator for enum\n\n  ```cpp\n  using magic_enum::iostream_operators::operator\u003C\u003C; \u002F\u002F out-of-the-box ostream operators for enums.\n  Color color = Color::BLUE;\n  std::cout \u003C\u003C color \u003C\u003C std::endl; \u002F\u002F \"BLUE\"\n  ```\n\n  ```cpp\n  using magic_enum::iostream_operators::operator>>; \u002F\u002F out-of-the-box istream operators for enums.\n  Color color;\n  std::cin >> color;\n  ```\n\n* Bitwise operator for enum\n\n  ```cpp\n  enum class Flags { A = 1 \u003C\u003C 0, B = 1 \u003C\u003C 1, C = 1 \u003C\u003C 2, D = 1 \u003C\u003C 3 };\n  using namespace magic_enum::bitwise_operators; \u002F\u002F out-of-the-box bitwise operators for enums.\n  \u002F\u002F Support operators: ~, |, &, ^, |=, &=, ^=.\n  Flags flags = Flags::A | Flags::B & ~Flags::C;\n  ```\n\n* Checks whether type is an [Unscoped enumeration](https:\u002F\u002Fen.cppreference.com\u002Fw\u002Fcpp\u002Flanguage\u002Fenum#Unscoped_enumeration).\n\n  ```cpp\n  enum color { red, green, blue };\n  enum class direction { left, right };\n\n  magic_enum::is_unscoped_enum\u003Ccolor>::value -> true\n  magic_enum::is_unscoped_enum\u003Cdirection>::value -> false\n  magic_enum::is_unscoped_enum\u003Cint>::value -> false\n\n  \u002F\u002F Helper variable template.\n  magic_enum::is_unscoped_enum_v\u003Ccolor> -> true\n  ```\n\n* Checks whether type is an [Scoped enumeration](https:\u002F\u002Fen.cppreference.com\u002Fw\u002Fcpp\u002Flanguage\u002Fenum#Scoped_enumerations).\n\n  ```cpp\n  enum color { red, green, blue };\n  enum class direction { left, right };\n\n  magic_enum::is_scoped_enum\u003Ccolor>::value -> false\n  magic_enum::is_scoped_enum\u003Cdirection>::value -> true\n  magic_enum::is_scoped_enum\u003Cint>::value -> false\n\n  \u002F\u002F Helper variable template.\n  magic_enum::is_scoped_enum_v\u003Cdirection> -> true\n  ```\n\n* Static storage enum variable to string\n  This version is much lighter on the compile times and is not restricted to the enum_range [limitation](doc\u002Flimitations.md).\n\n  ```cpp\n  constexpr Color color = Color::BLUE;\n  constexpr auto color_name = magic_enum::enum_name\u003Ccolor>();\n  \u002F\u002F color_name -> \"BLUE\"\n  ```\n\n* `containers::array` array container for enums.\n\n  ```cpp\n  magic_enum::containers::array\u003CColor, RGB> color_rgb_array {};\n  color_rgb_array[Color::RED] = {255, 0, 0};\n  color_rgb_array[Color::GREEN] = {0, 255, 0};\n  color_rgb_array[Color::BLUE] = {0, 0, 255};\n  magic_enum::containers::get\u003CColor::BLUE>(color_rgb_array) \u002F\u002F -> RGB{0, 0, 255}\n  ```\n\n* `containers::bitset` bitset container for enums.\n\n  ```cpp\n  std::uint8_t incoming = 0b00000011;\n  auto color_bitset = magic_enum::containers::bitset\u003CColor> {magic_enum::containers::raw_access, incoming};\n  color_bitset.set(Color::BLUE);\n  auto raw_value = color_bitset.to_ulong(magic_enum::containers::raw_access);\n  ```\n\n* `containers::set` set container for enums.\n\n  ```cpp\n  auto color_set = magic_enum::containers::set\u003CColor>();\n  bool empty = color_set.empty();\n  \u002F\u002F empty -> true\n  color_set.insert(Color::GREEN);\n  color_set.insert(Color::BLUE);\n  color_set.insert(Color::RED);\n  std::size_t size = color_set.size();\n  \u002F\u002F size -> 3\n  ```\n\n* Improved UB-free \"SFINAE-friendly\" [underlying_type](https:\u002F\u002Fen.cppreference.com\u002Fw\u002Fcpp\u002Ftypes\u002Funderlying_type).\n\n  ```cpp\n  magic_enum::underlying_type\u003Ccolor>::type -> int\n\n  \u002F\u002F Helper types.\n  magic_enum::underlying_type_t\u003CDirection> -> int\n  ```\n## Remarks\n\n* `magic_enum` does not pretend to be a silver bullet for reflection for enums, it was originally designed for small enum.\n\n* Before use, read the [limitations](doc\u002Flimitations.md) of functionality.\n\n## Integration\n\n* You should add the required file [magic_enum.hpp](include\u002Fmagic_enum\u002Fmagic_enum.hpp), and optionally other headers from [include dir](include\u002F) or [release archive](https:\u002F\u002Fgithub.com\u002FNeargye\u002Fmagic_enum\u002Freleases\u002Flatest). Alternatively, you can build the library with CMake.\n\n* If you are using [vcpkg](https:\u002F\u002Fgithub.com\u002FMicrosoft\u002Fvcpkg\u002F) on your project for external dependencies, then you can use the [magic-enum package](https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002Fvcpkg\u002Ftree\u002Fmaster\u002Fports\u002Fmagic-enum).\n\n* If you are using [Conan](https:\u002F\u002Fwww.conan.io\u002F) to manage your dependencies, merely add `magic_enum\u002Fx.y.z` to your conan's requires, where `x.y.z` is the release version you want to use.\n\n* If you are using [Build2](https:\u002F\u002Fbuild2.org\u002F) to build and manage your dependencies, add `depends: magic_enum ^x.y.z` to the manifest file where `x.y.z` is the release version you want to use. You can then import the target using `magic_enum%lib{magic_enum}`.\n\n* Alternatively, you can use something like [CPM](https:\u002F\u002Fgithub.com\u002FTheLartians\u002FCPM) which is based on CMake's `Fetch_Content` module.\n\n  ```cmake\n  CPMAddPackage(\n      NAME magic_enum\n      GITHUB_REPOSITORY Neargye\u002Fmagic_enum\n      GIT_TAG vx.y.z # Where `x.y.z` is the release version you want to use.\n  )\n  ```\n\n* Bazel is also supported, simply add to your WORKSPACE file:\n\n  ```\n  http_archive(\n      name = \"magic_enum\",\n      strip_prefix = \"magic_enum-\u003Ccommit>\",\n      urls = [\"https:\u002F\u002Fgithub.com\u002FNeargye\u002Fmagic_enum\u002Farchive\u002F\u003Ccommit>.zip\"],\n  )\n  ```\n\n  To use bazel inside the repository it's possible to do:\n\n  ```\n  bazel build \u002F\u002F...\n  bazel test \u002F\u002F...\n  bazel run \u002F\u002Fexample\n  ```\n\n  (Note that you must use a supported compiler or specify it with `export CC= \u003Ccompiler>`.)\n\n* If you are using [Ros](https:\u002F\u002Fwww.ros.org\u002F), you can include this package by adding `\u003Cdepend>magic_enum\u003C\u002Fdepend>` to your package.xml and include this package in your workspace. In your CMakeLists.txt add the following:\n  ```cmake\n  find_package(magic_enum CONFIG REQUIRED)\n  ...\n  target_link_libraries(your_executable magic_enum::magic_enum)\n  ```\n\n* **C++20 modules** are supported as an alternative to the header-only mode, requires CMake 3.28+.\n\n  Configure with CMake:\n  ```cmake\n  cmake -DMAGIC_ENUM_USE_MODULES=ON -G Ninja ...\n  ```\n\n  Then use `import` instead of `#include`:\n  ```cpp\n  import magic_enum;\n\n  enum class Color { RED, GREEN, BLUE };\n  auto name = magic_enum::enum_name(Color::RED); \u002F\u002F \"RED\"\n  ```\n\n  Caveats:\n  - Do not mix `#include \u003Cmagic_enum\u002F...>` and `import magic_enum;` within the same link unit — ODR violation.\n  - `import std;` is opt-in: add `-DCMAKE_CXX_STANDARD=23 -DCMAKE_CXX_IMPORT_STD=ON` (requires CMake 3.30+).\n\n## Compiler compatibility\n\n* Clang\u002FLLVM >= 5\n* MSVC++ >= 14.11 \u002F Visual Studio >= 2017\n* Xcode >= 10\n* GCC >= 9\n* MinGW >= 9\n\n## Licensed under the [MIT License](LICENSE)\n",2,"2026-06-11 04:11:34","trending"]