diff --git a/bfps/cpp/particles/abstract_particles_distr.hpp b/bfps/cpp/particles/abstract_particles_distr.hpp
index 690c85a93f5115f2b1acb023319fb185e2d3b5e2..1b711d41f9438586d677044496e116aaba2cedcf 100644
--- a/bfps/cpp/particles/abstract_particles_distr.hpp
+++ b/bfps/cpp/particles/abstract_particles_distr.hpp
@@ -199,12 +199,12 @@ public:
         }
         const int nbProcToRecvUpper = neigDescriptors.size()-nbProcToRecvLower;
         const int nbProcToRecv = nbProcToRecvUpper + nbProcToRecvLower;
-        assert(neigDescriptors.size() == nbProcToRecv);
+        assert(int(neigDescriptors.size()) == nbProcToRecv);
         DEBUG_MSG("[%d] nbProcToRecvUpper %d\n", my_rank, nbProcToRecvUpper);
         DEBUG_MSG("[%d] nbProcToRecvLower %d\n", my_rank, nbProcToRecvLower);
         DEBUG_MSG("[%d] nbProcToRecv %d\n", my_rank, nbProcToRecv);
 
-        for(int idxDescr = 0 ; idxDescr < neigDescriptors.size() ; ++idxDescr){
+        for(int idxDescr = 0 ; idxDescr < int(neigDescriptors.size()) ; ++idxDescr){
             NeighborDescriptor& descriptor = neigDescriptors[idxDescr];
 
             if(descriptor.isLower){
diff --git a/bfps/cpp/particles/particles_field_computer.hpp b/bfps/cpp/particles/particles_field_computer.hpp
index 32687dad5e707566c49e8cb649c125084dc29cd8..ecf3cb73479339330671ef0f3fc994e3b4a182f0 100644
--- a/bfps/cpp/particles/particles_field_computer.hpp
+++ b/bfps/cpp/particles/particles_field_computer.hpp
@@ -62,9 +62,9 @@ class particles_field_computer : public abstract_particles_distr<real_number, 3,
             const int partGridIdx_y = int(particles_positions[idxPart*3+IDX_Y]/box_step_width[IDX_Y]);
             const int partGridIdx_z = int(particles_positions[idxPart*3+IDX_Z]/box_step_width[IDX_Z]);
 
-            assert(0 <= partGridIdx_x && partGridIdx_x < field_grid_dim[IDX_X]);
-            assert(0 <= partGridIdx_y && partGridIdx_y < field_grid_dim[IDX_Y]);
-            assert(0 <= partGridIdx_z && partGridIdx_z < field_grid_dim[IDX_Z]);
+            assert(0 <= partGridIdx_x && partGridIdx_x < int(field_grid_dim[IDX_X]));
+            assert(0 <= partGridIdx_y && partGridIdx_y < int(field_grid_dim[IDX_Y]));
+            assert(0 <= partGridIdx_z && partGridIdx_z < int(field_grid_dim[IDX_Z]));
 
             const int interp_limit_mx = partGridIdx_x-interp_neighbours;
             const int interp_limit_x = partGridIdx_x+interp_neighbours+1;
@@ -76,7 +76,7 @@ class particles_field_computer : public abstract_particles_distr<real_number, 3,
             int nb_z_intervals;
 
             if((partGridIdx_z-interp_neighbours) < 0){
-                assert(partGridIdx_z+interp_neighbours+1 < field_grid_dim[IDX_Z]);
+                assert(partGridIdx_z+interp_neighbours+1 < int(field_grid_dim[IDX_Z]));
                 interp_limit_mz[0] = ((partGridIdx_z-interp_neighbours)+field_grid_dim[IDX_Z])%field_grid_dim[IDX_Z];
                 interp_limit_z[0] = current_partition_interval.second-1;
 
@@ -85,7 +85,7 @@ class particles_field_computer : public abstract_particles_distr<real_number, 3,
 
                 nb_z_intervals = 2;
             }
-            else if(field_grid_dim[2] <= (partGridIdx_z+interp_neighbours+1)){
+            else if(int(field_grid_dim[2]) <= (partGridIdx_z+interp_neighbours+1)){
                 interp_limit_mz[0] = std::max(current_partition_interval.first, partGridIdx_z-interp_neighbours);
                 interp_limit_z[0] = std::min(int(field_grid_dim[IDX_Z])-1,current_partition_interval.second-1);// max is not really needed here
 
diff --git a/bfps/cpp/particles/particles_input_hdf5.hpp b/bfps/cpp/particles/particles_input_hdf5.hpp
index ab87fbb01e542201b6a8db9edc737f52047ddc2a..cc7493d5b6743612001ef0baa20f79de596d7f01 100644
--- a/bfps/cpp/particles/particles_input_hdf5.hpp
+++ b/bfps/cpp/particles/particles_input_hdf5.hpp
@@ -209,7 +209,7 @@ public:
         }
 
         std::unique_ptr<int[]> split_particles_indexes(new int[load_splitter.getMySize()]);
-        for(int idx_part = 0 ; idx_part < load_splitter.getMySize() ; ++idx_part){
+        for(int idx_part = 0 ; idx_part < int(load_splitter.getMySize()) ; ++idx_part){
             split_particles_indexes[idx_part] = idx_part + load_splitter.getMyOffset();
         }
 
@@ -228,7 +228,7 @@ public:
                 },
                 [&](const int idx1, const int idx2){
                     std::swap(split_particles_indexes[idx1], split_particles_indexes[idx2]);
-                    for(int idx_rhs = 0 ; idx_rhs < nb_rhs ; ++idx_rhs){
+                    for(int idx_rhs = 0 ; idx_rhs < int(nb_rhs) ; ++idx_rhs){
                         for(int idx_val = 0 ; idx_val < size_particle_rhs ; ++idx_val){
                             std::swap(split_particles_rhs[idx_rhs][idx1*size_particle_rhs + idx_val],
                                       split_particles_rhs[idx_rhs][idx2*size_particle_rhs + idx_val]);
@@ -258,7 +258,7 @@ public:
             split_particles_indexes.release();
 
             my_particles_rhs.resize(nb_rhs);
-            for(int idx_rhs = 0 ; idx_rhs < nb_rhs ; ++idx_rhs){
+            for(int idx_rhs = 0 ; idx_rhs < int(nb_rhs) ; ++idx_rhs){
                 my_particles_rhs[idx_rhs].reset(new real_number[exchanger.getTotalToRecv()*size_particle_rhs]);
                 exchanger.alltoallv<real_number>(split_particles_rhs[idx_rhs].get(), my_particles_rhs[idx_rhs].get(), size_particle_rhs);
             }
diff --git a/bfps/cpp/particles/particles_system.hpp b/bfps/cpp/particles/particles_system.hpp
index 56f4fe793dbd82e7f33d56db7cd49c93c7fb4c32..b31221d367de69458d2c4d10dbf64fb9c7134ec2 100644
--- a/bfps/cpp/particles/particles_system.hpp
+++ b/bfps/cpp/particles/particles_system.hpp
@@ -88,7 +88,7 @@ public:
         },
         [&](const int idx1, const int idx2){
             std::swap(my_particles_positions_indexes[idx1], my_particles_positions_indexes[idx2]);
-            for(int idx_rhs = 0 ; idx_rhs < my_particles_rhs.size() ; ++idx_rhs){
+            for(int idx_rhs = 0 ; idx_rhs < int(my_particles_rhs.size()) ; ++idx_rhs){
                 for(int idx_val = 0 ; idx_val < 3 ; ++idx_val){
                     std::swap(my_particles_rhs[idx_rhs][idx1*3 + idx_val],
                               my_particles_rhs[idx_rhs][idx2*3 + idx_val]);
diff --git a/bfps/cpp/particles/particles_system_builder.hpp b/bfps/cpp/particles/particles_system_builder.hpp
index 5bcd04b599fe21ae2abf0de64e09fa733aba8e6c..3c0861f86bcd12f2a85ae927d84234a027662e14 100644
--- a/bfps/cpp/particles/particles_system_builder.hpp
+++ b/bfps/cpp/particles/particles_system_builder.hpp
@@ -139,7 +139,7 @@ struct particles_system_build_container {
         local_field_offset[IDX_Z] = fs_field->rlayout->starts[IDX_Z];
         // Ensure that 1D partitioning is used
         {
-            assert(myrank < field_grid_dim[IDX_Z]);
+            assert(myrank < int(field_grid_dim[IDX_Z]));
             assert(local_field_offset[IDX_X] == 0);
             assert(local_field_offset[IDX_Y] == 0);
             assert(local_field_dims[IDX_X] == field_grid_dim[IDX_X]);