diff --git a/include/samurai/algorithm/graduation.hpp b/include/samurai/algorithm/graduation.hpp
index f0dbba80d..194985d67 100644
--- a/include/samurai/algorithm/graduation.hpp
+++ b/include/samurai/algorithm/graduation.hpp
@@ -94,21 +94,21 @@ namespace samurai
 
             auto tag_func = [&](auto& i_f)
             {
-                auto mask = tag(level, i_f - s[0], index - view(s, xt::range(1, _))) & static_cast<int>(CellFlag::refine);
+                auto mask = tag(level, i_f - s[0], index - view(s, xt::range(1, _))) & static_cast<std::uint8_t>(CellFlag::refine);
                 auto i_c  = i_f >> 1;
                 apply_on_masked(tag(level - 1, i_c, index >> 1),
                                 mask,
                                 [](auto& e)
                                 {
-                                    e |= static_cast<int>(CellFlag::refine);
+                                    e |= static_cast<std::uint8_t>(CellFlag::refine);
                                 });
 
-                auto mask2 = tag(level, i_f - s[0], index - view(s, xt::range(1, _))) & static_cast<int>(CellFlag::keep);
+                auto mask2 = tag(level, i_f - s[0], index - view(s, xt::range(1, _))) & static_cast<std::uint8_t>(CellFlag::keep);
                 apply_on_masked(tag(level - 1, i_c, index >> 1),
                                 mask2,
                                 [](auto& e)
                                 {
-                                    e |= static_cast<int>(CellFlag::keep);
+                                    e |= static_cast<std::uint8_t>(CellFlag::keep);
                                 });
             };
 
@@ -692,9 +692,9 @@ namespace samurai
                 for (value_t x = x_interval.start; x < x_interval.end; ++x)
                 {
                     const size_type itag         = static_cast<size_type>(x_interval.index) + static_cast<unsigned_value_t>(x);
-                    const bool refine            = tag[itag] & static_cast<int>(CellFlag::refine);
-                    const bool coarsenAndNotKeep = tag[itag] & static_cast<int>(CellFlag::coarsen)
-                                               and not(tag[itag] & static_cast<int>(CellFlag::keep));
+                    const bool refine            = tag[itag] & static_cast<std::uint8_t>(CellFlag::refine);
+                    const bool coarsenAndNotKeep = tag[itag] & static_cast<std::uint8_t>(CellFlag::coarsen)
+                                               and not(tag[itag] & static_cast<std::uint8_t>(CellFlag::keep));
                     if (refine and level < mesh.max_level())
                     {
                         ca_remove_p[level].add_point_back(x, yz);
diff --git a/include/samurai/algorithm/update.hpp b/include/samurai/algorithm/update.hpp
index 5911f7871..43b4c8268 100644
--- a/include/samurai/algorithm/update.hpp
+++ b/include/samurai/algorithm/update.hpp
@@ -873,10 +873,10 @@ namespace samurai
                         {
                             if constexpr (dim == 1)
                             {
-                                auto mask1 = (tag(level, 2 * i) & static_cast<int>(CellFlag::coarsen))
-                                           & (tag(level, 2 * i + 1) & static_cast<int>(CellFlag::coarsen));
-                                auto mask2 = (tag(level, 2 * i) & static_cast<int>(CellFlag::keep))
-                                           | (tag(level, 2 * i + 1) & static_cast<int>(CellFlag::keep));
+                                auto mask1 = (tag(level, 2 * i) & static_cast<std::uint8_t>(CellFlag::coarsen))
+                                           & (tag(level, 2 * i + 1) & static_cast<std::uint8_t>(CellFlag::coarsen));
+                                auto mask2 = (tag(level, 2 * i) & static_cast<std::uint8_t>(CellFlag::keep))
+                                           | (tag(level, 2 * i + 1) & static_cast<std::uint8_t>(CellFlag::keep));
                                 auto mask = xt::eval(mask1 && !mask2);
 
                                 xt::masked_view(tag(level, 2 * i), mask)     = 0;
@@ -885,14 +885,14 @@ namespace samurai
                             if constexpr (dim == 2)
                             {
                                 auto j     = index[0];
-                                auto mask1 = (tag(level, 2 * i, 2 * j) & static_cast<int>(CellFlag::coarsen))
-                                           & (tag(level, 2 * i + 1, 2 * j) & static_cast<int>(CellFlag::coarsen))
-                                           & (tag(level, 2 * i, 2 * j + 1) & static_cast<int>(CellFlag::coarsen))
-                                           & (tag(level, 2 * i + 1, 2 * j + 1) & static_cast<int>(CellFlag::coarsen));
-                                auto mask2 = (tag(level, 2 * i, 2 * j) & static_cast<int>(CellFlag::keep))
-                                           | (tag(level, 2 * i + 1, 2 * j) & static_cast<int>(CellFlag::keep))
-                                           | (tag(level, 2 * i, 2 * j + 1) & static_cast<int>(CellFlag::keep))
-                                           | (tag(level, 2 * i + 1, 2 * j + 1) & static_cast<int>(CellFlag::keep));
+                                auto mask1 = (tag(level, 2 * i, 2 * j) & static_cast<std::uint8_t>(CellFlag::coarsen))
+                                           & (tag(level, 2 * i + 1, 2 * j) & static_cast<std::uint8_t>(CellFlag::coarsen))
+                                           & (tag(level, 2 * i, 2 * j + 1) & static_cast<std::uint8_t>(CellFlag::coarsen))
+                                           & (tag(level, 2 * i + 1, 2 * j + 1) & static_cast<std::uint8_t>(CellFlag::coarsen));
+                                auto mask2 = (tag(level, 2 * i, 2 * j) & static_cast<std::uint8_t>(CellFlag::keep))
+                                           | (tag(level, 2 * i + 1, 2 * j) & static_cast<std::uint8_t>(CellFlag::keep))
+                                           | (tag(level, 2 * i, 2 * j + 1) & static_cast<std::uint8_t>(CellFlag::keep))
+                                           | (tag(level, 2 * i + 1, 2 * j + 1) & static_cast<std::uint8_t>(CellFlag::keep));
                                 auto mask = xt::eval(mask1 && !mask2);
 
                                 xt::masked_view(tag(level, 2 * i, 2 * j), mask)         = 0;
@@ -904,22 +904,22 @@ namespace samurai
                             {
                                 auto j     = index[0];
                                 auto k     = index[1];
-                                auto mask1 = (tag(level, 2 * i, 2 * j, 2 * k) & static_cast<int>(CellFlag::coarsen))
-                                           & (tag(level, 2 * i + 1, 2 * j, 2 * k) & static_cast<int>(CellFlag::coarsen))
-                                           & (tag(level, 2 * i, 2 * j + 1, 2 * k) & static_cast<int>(CellFlag::coarsen))
-                                           & (tag(level, 2 * i + 1, 2 * j + 1, 2 * k) & static_cast<int>(CellFlag::coarsen))
-                                           & (tag(level, 2 * i, 2 * j, 2 * k + 1) & static_cast<int>(CellFlag::coarsen))
-                                           & (tag(level, 2 * i + 1, 2 * j, 2 * k + 1) & static_cast<int>(CellFlag::coarsen))
-                                           & (tag(level, 2 * i, 2 * j + 1, 2 * k + 1) & static_cast<int>(CellFlag::coarsen))
-                                           & (tag(level, 2 * i + 1, 2 * j + 1, 2 * k + 1) & static_cast<int>(CellFlag::coarsen));
-                                auto mask2 = (tag(level, 2 * i, 2 * j, 2 * k) & static_cast<int>(CellFlag::keep))
-                                           | (tag(level, 2 * i + 1, 2 * j, 2 * k) & static_cast<int>(CellFlag::keep))
-                                           | (tag(level, 2 * i, 2 * j + 1, 2 * k) & static_cast<int>(CellFlag::keep))
-                                           | (tag(level, 2 * i + 1, 2 * j + 1, 2 * k) & static_cast<int>(CellFlag::keep))
-                                           | (tag(level, 2 * i, 2 * j, 2 * k + 1) & static_cast<int>(CellFlag::keep))
-                                           | (tag(level, 2 * i + 1, 2 * j, 2 * k + 1) & static_cast<int>(CellFlag::keep))
-                                           | (tag(level, 2 * i, 2 * j + 1, 2 * k + 1) & static_cast<int>(CellFlag::keep))
-                                           | (tag(level, 2 * i + 1, 2 * j + 1, 2 * k + 1) & static_cast<int>(CellFlag::keep));
+                                auto mask1 = (tag(level, 2 * i, 2 * j, 2 * k) & static_cast<std::uint8_t>(CellFlag::coarsen))
+                                           & (tag(level, 2 * i + 1, 2 * j, 2 * k) & static_cast<std::uint8_t>(CellFlag::coarsen))
+                                           & (tag(level, 2 * i, 2 * j + 1, 2 * k) & static_cast<std::uint8_t>(CellFlag::coarsen))
+                                           & (tag(level, 2 * i + 1, 2 * j + 1, 2 * k) & static_cast<std::uint8_t>(CellFlag::coarsen))
+                                           & (tag(level, 2 * i, 2 * j, 2 * k + 1) & static_cast<std::uint8_t>(CellFlag::coarsen))
+                                           & (tag(level, 2 * i + 1, 2 * j, 2 * k + 1) & static_cast<std::uint8_t>(CellFlag::coarsen))
+                                           & (tag(level, 2 * i, 2 * j + 1, 2 * k + 1) & static_cast<std::uint8_t>(CellFlag::coarsen))
+                                           & (tag(level, 2 * i + 1, 2 * j + 1, 2 * k + 1) & static_cast<std::uint8_t>(CellFlag::coarsen));
+                                auto mask2 = (tag(level, 2 * i, 2 * j, 2 * k) & static_cast<std::uint8_t>(CellFlag::keep))
+                                           | (tag(level, 2 * i + 1, 2 * j, 2 * k) & static_cast<std::uint8_t>(CellFlag::keep))
+                                           | (tag(level, 2 * i, 2 * j + 1, 2 * k) & static_cast<std::uint8_t>(CellFlag::keep))
+                                           | (tag(level, 2 * i + 1, 2 * j + 1, 2 * k) & static_cast<std::uint8_t>(CellFlag::keep))
+                                           | (tag(level, 2 * i, 2 * j, 2 * k + 1) & static_cast<std::uint8_t>(CellFlag::keep))
+                                           | (tag(level, 2 * i + 1, 2 * j, 2 * k + 1) & static_cast<std::uint8_t>(CellFlag::keep))
+                                           | (tag(level, 2 * i, 2 * j + 1, 2 * k + 1) & static_cast<std::uint8_t>(CellFlag::keep))
+                                           | (tag(level, 2 * i + 1, 2 * j + 1, 2 * k + 1) & static_cast<std::uint8_t>(CellFlag::keep));
                                 auto mask = xt::eval(mask1 && !mask2);
 
                                 xt::masked_view(tag(level, 2 * i, 2 * j, 2 * k), mask)             = 0;
@@ -1454,7 +1454,7 @@ namespace samurai
                               auto itag = static_cast<size_type>(interval.start + interval.index);
                               for (auto i = interval.start; i < interval.end; ++i)
                               {
-                                  if (tag[itag] & static_cast<int>(CellFlag::refine))
+                                  if (tag[itag] & static_cast<std::uint8_t>(CellFlag::refine))
                                   {
                                       if (level < mesh.max_level())
                                       {
@@ -1470,11 +1470,11 @@ namespace samurai
                                           cl[level][index].add_point(i);
                                       }
                                   }
-                                  else if (tag[itag] & static_cast<int>(CellFlag::keep))
+                                  else if (tag[itag] & static_cast<std::uint8_t>(CellFlag::keep))
                                   {
                                       cl[level][index].add_point(i);
                                   }
-                                  else if (tag[itag] & static_cast<int>(CellFlag::coarsen))
+                                  else if (tag[itag] & static_cast<std::uint8_t>(CellFlag::coarsen))
                                   {
                                       if (level > mesh.min_level())
                                       {
diff --git a/include/samurai/algorithm/utils.hpp b/include/samurai/algorithm/utils.hpp
index cf29ad514..dddf2207b 100644
--- a/include/samurai/algorithm/utils.hpp
+++ b/include/samurai/algorithm/utils.hpp
@@ -62,14 +62,14 @@ namespace samurai
             static_nested_loop<1, -s, s + 1>(
                 [&](const auto& stencil)
                 {
-                    tag(level, i + stencil[0]) |= static_cast<int>(CellFlag::keep);
+                    tag(level, i + stencil[0]) |= static_cast<std::uint8_t>(CellFlag::keep);
                 });
         }
 
         template <class T, class Flag, int s>
         SAMURAI_INLINE void operator()(Dim<1>, T& tag, const Flag& flag, std::integral_constant<int, s>) const
         {
-            auto mask = (tag(level, i) & static_cast<int>(flag));
+            auto mask = (tag(level, i) & static_cast<std::uint8_t>(flag));
 
             apply_on_masked(mask,
                             [&](auto imask)
@@ -77,7 +77,7 @@ namespace samurai
                                 static_nested_loop<1, -s, s + 1>(
                                     [&](const auto& stencil)
                                     {
-                                        tag(level, i + stencil[0])(imask) |= static_cast<int>(CellFlag::keep);
+                                        tag(level, i + stencil[0])(imask) |= static_cast<std::uint8_t>(CellFlag::keep);
                                     });
                             });
         }
@@ -88,14 +88,14 @@ namespace samurai
             static_nested_loop<2, -s, s + 1>(
                 [&](const auto& stencil)
                 {
-                    tag(level, i + stencil[0], j + stencil[1]) |= static_cast<int>(CellFlag::keep);
+                    tag(level, i + stencil[0], j + stencil[1]) |= static_cast<std::uint8_t>(CellFlag::keep);
                 });
         }
 
         template <class T, class Flag, int s>
         SAMURAI_INLINE void operator()(Dim<2>, T& tag, const Flag& flag, std::integral_constant<int, s>) const
         {
-            auto mask = (tag(level, i, j) & static_cast<int>(flag));
+            auto mask = (tag(level, i, j) & static_cast<std::uint8_t>(flag));
 
             apply_on_masked(mask,
                             [&](auto imask)
@@ -103,7 +103,7 @@ namespace samurai
                                 static_nested_loop<2, -s, s + 1>(
                                     [&](const auto& stencil)
                                     {
-                                        tag(level, i + stencil[0], j + stencil[1])(imask) |= static_cast<int>(CellFlag::keep);
+                                        tag(level, i + stencil[0], j + stencil[1])(imask) |= static_cast<std::uint8_t>(CellFlag::keep);
                                     });
                             });
         }
@@ -114,24 +114,25 @@ namespace samurai
             static_nested_loop<3, -s, s + 1>(
                 [&](const auto& stencil)
                 {
-                    tag(level, i + stencil[0], j + stencil[1], k + stencil[2]) |= static_cast<int>(CellFlag::keep);
+                    tag(level, i + stencil[0], j + stencil[1], k + stencil[2]) |= static_cast<std::uint8_t>(CellFlag::keep);
                 });
         }
 
         template <class T, class Flag, int s>
         SAMURAI_INLINE void operator()(Dim<3>, T& tag, const Flag& flag, std::integral_constant<int, s>) const
         {
-            auto mask = (tag(level, i, j, k) & static_cast<int>(flag));
+            auto mask = (tag(level, i, j, k) & static_cast<std::uint8_t>(flag));
 
-            apply_on_masked(mask,
-                            [&](auto imask)
-                            {
-                                static_nested_loop<3, -s, s + 1>(
-                                    [&](const auto& stencil)
-                                    {
-                                        tag(level, i + stencil[0], j + stencil[1], k + stencil[2])(imask) |= static_cast<int>(CellFlag::keep);
-                                    });
-                            });
+            apply_on_masked(
+                mask,
+                [&](auto imask)
+                {
+                    static_nested_loop<3, -s, s + 1>(
+                        [&](const auto& stencil)
+                        {
+                            tag(level, i + stencil[0], j + stencil[1], k + stencil[2])(imask) |= static_cast<std::uint8_t>(CellFlag::keep);
+                        });
+                });
         }
     };
 
@@ -161,58 +162,58 @@ namespace samurai
         template <class T>
         SAMURAI_INLINE void operator()(Dim<1>, T& tag) const
         {
-            auto mask = (tag(level + 1, 2 * i) & static_cast<int>(CellFlag::keep))
-                      | (tag(level + 1, 2 * i + 1) & static_cast<int>(CellFlag::keep));
+            auto mask = (tag(level + 1, 2 * i) & static_cast<std::uint8_t>(CellFlag::keep))
+                      | (tag(level + 1, 2 * i + 1) & static_cast<std::uint8_t>(CellFlag::keep));
 
             apply_on_masked(mask,
                             [&](auto imask)
                             {
-                                tag(level + 1, 2 * i)(imask) |= static_cast<int>(CellFlag::keep);
-                                tag(level + 1, 2 * i + 1)(imask) |= static_cast<int>(CellFlag::keep);
+                                tag(level + 1, 2 * i)(imask) |= static_cast<std::uint8_t>(CellFlag::keep);
+                                tag(level + 1, 2 * i + 1)(imask) |= static_cast<std::uint8_t>(CellFlag::keep);
                             });
         }
 
         template <class T>
         SAMURAI_INLINE void operator()(Dim<2>, T& tag) const
         {
-            auto mask = (tag(level + 1, 2 * i, 2 * j) & static_cast<int>(CellFlag::keep))
-                      | (tag(level + 1, 2 * i + 1, 2 * j) & static_cast<int>(CellFlag::keep))
-                      | (tag(level + 1, 2 * i, 2 * j + 1) & static_cast<int>(CellFlag::keep))
-                      | (tag(level + 1, 2 * i + 1, 2 * j + 1) & static_cast<int>(CellFlag::keep));
+            auto mask = (tag(level + 1, 2 * i, 2 * j) & static_cast<std::uint8_t>(CellFlag::keep))
+                      | (tag(level + 1, 2 * i + 1, 2 * j) & static_cast<std::uint8_t>(CellFlag::keep))
+                      | (tag(level + 1, 2 * i, 2 * j + 1) & static_cast<std::uint8_t>(CellFlag::keep))
+                      | (tag(level + 1, 2 * i + 1, 2 * j + 1) & static_cast<std::uint8_t>(CellFlag::keep));
 
             apply_on_masked(mask,
                             [&](auto imask)
                             {
-                                tag(level + 1, 2 * i, 2 * j)(imask) |= static_cast<int>(CellFlag::keep);
-                                tag(level + 1, 2 * i + 1, 2 * j)(imask) |= static_cast<int>(CellFlag::keep);
-                                tag(level + 1, 2 * i, 2 * j + 1)(imask) |= static_cast<int>(CellFlag::keep);
-                                tag(level + 1, 2 * i + 1, 2 * j + 1)(imask) |= static_cast<int>(CellFlag::keep);
+                                tag(level + 1, 2 * i, 2 * j)(imask) |= static_cast<std::uint8_t>(CellFlag::keep);
+                                tag(level + 1, 2 * i + 1, 2 * j)(imask) |= static_cast<std::uint8_t>(CellFlag::keep);
+                                tag(level + 1, 2 * i, 2 * j + 1)(imask) |= static_cast<std::uint8_t>(CellFlag::keep);
+                                tag(level + 1, 2 * i + 1, 2 * j + 1)(imask) |= static_cast<std::uint8_t>(CellFlag::keep);
                             });
         }
 
         template <class T>
         SAMURAI_INLINE void operator()(Dim<3>, T& tag) const
         {
-            auto mask = (tag(level + 1, 2 * i, 2 * j, 2 * k) & static_cast<int>(CellFlag::keep))
-                      | (tag(level + 1, 2 * i + 1, 2 * j, 2 * k) & static_cast<int>(CellFlag::keep))
-                      | (tag(level + 1, 2 * i, 2 * j + 1, 2 * k) & static_cast<int>(CellFlag::keep))
-                      | (tag(level + 1, 2 * i + 1, 2 * j + 1, 2 * k) & static_cast<int>(CellFlag::keep))
-                      | (tag(level + 1, 2 * i, 2 * j, 2 * k + 1) & static_cast<int>(CellFlag::keep))
-                      | (tag(level + 1, 2 * i + 1, 2 * j, 2 * k + 1) & static_cast<int>(CellFlag::keep))
-                      | (tag(level + 1, 2 * i, 2 * j + 1, 2 * k + 1) & static_cast<int>(CellFlag::keep))
-                      | (tag(level + 1, 2 * i + 1, 2 * j + 1, 2 * k + 1) & static_cast<int>(CellFlag::keep));
+            auto mask = (tag(level + 1, 2 * i, 2 * j, 2 * k) & static_cast<std::uint8_t>(CellFlag::keep))
+                      | (tag(level + 1, 2 * i + 1, 2 * j, 2 * k) & static_cast<std::uint8_t>(CellFlag::keep))
+                      | (tag(level + 1, 2 * i, 2 * j + 1, 2 * k) & static_cast<std::uint8_t>(CellFlag::keep))
+                      | (tag(level + 1, 2 * i + 1, 2 * j + 1, 2 * k) & static_cast<std::uint8_t>(CellFlag::keep))
+                      | (tag(level + 1, 2 * i, 2 * j, 2 * k + 1) & static_cast<std::uint8_t>(CellFlag::keep))
+                      | (tag(level + 1, 2 * i + 1, 2 * j, 2 * k + 1) & static_cast<std::uint8_t>(CellFlag::keep))
+                      | (tag(level + 1, 2 * i, 2 * j + 1, 2 * k + 1) & static_cast<std::uint8_t>(CellFlag::keep))
+                      | (tag(level + 1, 2 * i + 1, 2 * j + 1, 2 * k + 1) & static_cast<std::uint8_t>(CellFlag::keep));
 
             apply_on_masked(mask,
                             [&](auto imask)
                             {
-                                tag(level + 1, 2 * i, 2 * j, 2 * k)(imask) |= static_cast<int>(CellFlag::keep);
-                                tag(level + 1, 2 * i + 1, 2 * j, 2 * k)(imask) |= static_cast<int>(CellFlag::keep);
-                                tag(level + 1, 2 * i, 2 * j + 1, 2 * k)(imask) |= static_cast<int>(CellFlag::keep);
-                                tag(level + 1, 2 * i + 1, 2 * j + 1, 2 * k)(imask) |= static_cast<int>(CellFlag::keep);
-                                tag(level + 1, 2 * i, 2 * j, 2 * k + 1)(imask) |= static_cast<int>(CellFlag::keep);
-                                tag(level + 1, 2 * i + 1, 2 * j, 2 * k + 1)(imask) |= static_cast<int>(CellFlag::keep);
-                                tag(level + 1, 2 * i, 2 * j + 1, 2 * k + 1)(imask) |= static_cast<int>(CellFlag::keep);
-                                tag(level + 1, 2 * i + 1, 2 * j + 1, 2 * k + 1)(imask) |= static_cast<int>(CellFlag::keep);
+                                tag(level + 1, 2 * i, 2 * j, 2 * k)(imask) |= static_cast<std::uint8_t>(CellFlag::keep);
+                                tag(level + 1, 2 * i + 1, 2 * j, 2 * k)(imask) |= static_cast<std::uint8_t>(CellFlag::keep);
+                                tag(level + 1, 2 * i, 2 * j + 1, 2 * k)(imask) |= static_cast<std::uint8_t>(CellFlag::keep);
+                                tag(level + 1, 2 * i + 1, 2 * j + 1, 2 * k)(imask) |= static_cast<std::uint8_t>(CellFlag::keep);
+                                tag(level + 1, 2 * i, 2 * j, 2 * k + 1)(imask) |= static_cast<std::uint8_t>(CellFlag::keep);
+                                tag(level + 1, 2 * i + 1, 2 * j, 2 * k + 1)(imask) |= static_cast<std::uint8_t>(CellFlag::keep);
+                                tag(level + 1, 2 * i, 2 * j + 1, 2 * k + 1)(imask) |= static_cast<std::uint8_t>(CellFlag::keep);
+                                tag(level + 1, 2 * i + 1, 2 * j + 1, 2 * k + 1)(imask) |= static_cast<std::uint8_t>(CellFlag::keep);
                             });
         }
     };
diff --git a/include/samurai/cell_flag.hpp b/include/samurai/cell_flag.hpp
index 2ddb7cb2f..e24b91d3a 100644
--- a/include/samurai/cell_flag.hpp
+++ b/include/samurai/cell_flag.hpp
@@ -4,9 +4,11 @@
 
 #pragma once
 
+#include <cstdint>
+
 namespace samurai
 {
-    enum class CellFlag
+    enum class CellFlag : std::uint8_t
     {
         keep    = 1,
         coarsen = 2,
diff --git a/include/samurai/io/from_geometry.hpp b/include/samurai/io/from_geometry.hpp
index b3dbdbb5f..0dc54d7af 100644
--- a/include/samurai/io/from_geometry.hpp
+++ b/include/samurai/io/from_geometry.hpp
@@ -52,7 +52,7 @@ namespace samurai
         std::size_t current_level = start_level;
         while (current_level != max_level + 1)
         {
-            auto tag = make_scalar_field<int>("tag", mesh);
+            auto tag = make_scalar_field<std::uint8_t>("tag", mesh);
             tag.fill(0);
 
             for (std::size_t level = mesh.min_level(); level < current_level; ++level)
@@ -60,7 +60,7 @@ namespace samurai
                 for_each_interval(mesh[level],
                                   [&](std::size_t level, const auto& i, const auto& index)
                                   {
-                                      tag(level, i, index[0], index[1]) = static_cast<int>(CellFlag::keep);
+                                      tag(level, i, index[0], index[1]) = static_cast<std::uint8_t>(CellFlag::keep);
                                   });
             }
 
@@ -92,11 +92,11 @@ namespace samurai
                 {
                     if (current_level != max_level)
                     {
-                        tag[cells[b.id() - start_id]] = static_cast<int>(CellFlag::refine);
+                        tag[cells[b.id() - start_id]] = static_cast<std::uint8_t>(CellFlag::refine);
                     }
                     else
                     {
-                        tag[cells[b.id() - start_id]] = static_cast<int>(CellFlag::keep);
+                        tag[cells[b.id() - start_id]] = static_cast<std::uint8_t>(CellFlag::keep);
                     }
                 }
             };
@@ -110,11 +110,11 @@ namespace samurai
                               res = inside({center(0), center(1), center(2)});
                               if (res == CGAL::ON_BOUNDED_SIDE && keep_inside)
                               {
-                                  tag[cell] |= static_cast<int>(CellFlag::keep);
+                                  tag[cell] |= static_cast<std::uint8_t>(CellFlag::keep);
                               }
                               if (res == CGAL::ON_UNBOUNDED_SIDE && keep_outside)
                               {
-                                  tag[cell] |= static_cast<int>(CellFlag::keep);
+                                  tag[cell] |= static_cast<std::uint8_t>(CellFlag::keep);
                               }
                           });
 
@@ -131,7 +131,7 @@ namespace samurai
                                       auto itag = interval.start + interval.index;
                                       for (typename interval_t::value_t i = interval.start; i < interval.end; ++i, ++itag)
                                       {
-                                          if ((tag[itag] & static_cast<int>(CellFlag::refine)) && level < max_level)
+                                          if ((tag[itag] & static_cast<std::uint8_t>(CellFlag::refine)) && level < max_level)
                                           {
                                               static_nested_loop<2, 0, 2>(
                                                   [&](auto stencil)
@@ -140,7 +140,7 @@ namespace samurai
                                                       cl[level + 1][index].add_interval({2 * i, 2 * i + 2});
                                                   });
                                           }
-                                          else if (tag[itag] & static_cast<int>(CellFlag::keep))
+                                          else if (tag[itag] & static_cast<std::uint8_t>(CellFlag::keep))
                                           {
                                               cl[level][index_yz].add_point(i);
                                           }