I tried it and compilation fails with

popl_example.cpp:38:21: error: invalid conversion from ‘char**’ to ‘const char**’

Since the main function must have the following (non-const) signature

int main()               // (1)
int main(int, char*[])   // (2)

The argv must be casted to const char**
I checked how getopt solves this, and they are using

int getopt(int argc, char * const argv[], const char *optstring);

When changing the parse function to

void parse(int argc, char* const argv[]);

it compiles and works fine. Can you please test this in your unit test framework?

Yes, I found that independently, pushing a fixed version

I'm confused of all these consts :)

your PR is using

const char * const * argv

which should be equivalent to

const char * const argv[] // constant array of constant pointer to char

which is different (i.e. more constant) to the getopt version

char * const argv[]   // array of constant pointer to char

is there an advantage in your version compared to the getopt version (which is part of the glibc)?
Both are compiling without warning on clang and gcc and I don't fully understand why there is no cast to const necessary, but because the arguments from main are not const, my stomach is pointing me to the getopt char * const argv[] version.

There are several advantages of const char * const argv[] over char * const argv[]:

1. The first explicitly says to user of the parse method: "your data will not be modified by any mean, so after calling these your array remains untouched". Without the 1st const qualifier, you allow parse to modify values (**argv = 'Ж'). It is not that function does at the moment, but such harmful behavior may be introduced intentionally or unintentionally, and the const would protect us from that.
2. As there is a guarantee of constantness, compiler may do more agressive optimizations.
3. It solves my problems I described in PR message above: array of C-string literals cannot be converted to char* argv[], it is always const char* argv[].
4. Finally, char * const argv[] is implicitly convertable to const char * const argv[], so you do no harm by this.

because the arguments from main are not const

It allows users handle argv in-place. For example, one may modify them before pushing into Popl.

cool, convinced, thanks :)