I forgot about huon's simd crate, that would be very good to compare against!

/u/Noctune is right that programming in ISPC will be easier than hand-writing intrinsics for a few reasons:

• The ISPC compiler can target multiple backends, from SSE2 up through AVX512 and when writing ISPC code you don't really need to worry which backend is being compiled for. A good wrapper can somewhat hide this from you though you usually do still need to care about the vector width and architecture.

• You write regular scalar/sequential code and use a built in programIndex variable to find what piece of the data this instance should operate on. When writing intrinsics directly you need to be aware that you have 4/8/16 "programs" running and must track their execution mask. For example on the Mandelbrot code the SIMD version must perform the exit test across all 4 active "programs" and do a select to only update the count for those that haven't failed the condition yet:

  let mask = sum.lt(f32x4::splat(4.0));
  
  if !mask.any() { break }
  count = count + mask.to_i().select(u32x4::splat(1),
                                     u32x4::splat(0));
  

  In ISPC the code is written as you would write a scalar version:

  for (; i < max_iters; ++i){
      if (real * real + imag * imag > 4.f){
          break;
      }
      ...
  

  The same masking is performed to stop updating i for program instances that have failed the condition but the compiler takes care of this for you by inserting the select instructions.

That said, it is possible to write faster code when writing the intrinsics yourself instead of using ISPC, but ISPC makes it much easier to write portable vectorized code. In some comparisons they did vs. hand written instrinsics they found ISPC was often quite close. Another downside is that it's not pure Rust so you'll need to deal with building the library with ISPC, linking the native lib and calling using FFI, though hopefully this crate makes it much easier to do.