This is rather awful.

The concept isn't terrible necessarily, but the execution and condescension sure is. And some of the rules are just pointlessly argumentative. Such as refusing to use and instead using - those are officially documented to be different things with different behaviors. Blanket banning one of them doesn't improve simplicity, especially if you're blanket banning the "wrong" set of headers. Unless the goal is to also ban namespaces, but that's not called out as such (and namespaces are one of the least contentions C++ features - everyone seems to like them well enough).

Or similarly:

> Don't use anything from STL that allocates memory, unless you don't care about memory management.

So don't use std::vector? Or std::unordered_map? Or std::string? These are all perfectly fine classes, banning them makes no sense at all. Maybe the goal was to ban "hidden cost" classes like std::function, but rolling your own 'C-style' is a hell of a lot more complex & error prone (raise your hand if you've seen a C pointer callback that forgot to have a void* context or a mismanagement of said void* context...)

I think any attempt at defining a strict subset of a language is going to face some pushback like yours, but I do agree that while I agree with most choices this one seems strange. Rolling your own containers is boring and error-prone and won't have all the features of the STL.

Also, while iostream is a bit of a mess, having it be strongly typed means that it's, in my opinion, well worth using over cstdio.

One thing I was surprised not to see mentioned here is multiple inheritance. In my experience it gets really messy really fast.

Also I really recommend reading the linked archived Boost discussion about a geometry library, it's quite funny. It starts with:

  double distance(mypoint const& a, mypoint const& b)
  {
    double dx = a.x - b.x;
    double dy = a.y - b.y;
    return sqrt(dx * dx + dy * dy);
  }

  template 
  double distance(G1 const& g1, G2 const& g2)
  {
    typedef typename strategy_distance
        <
            typename coordinate_system::type,
            typename coordinate_system::type,
            typename point_type::type,
            typename point_type::type,
            dimension::value
        >::type strategy;

    return dispatch::distance
        <
            typename tag::type,
            typename tag::type,
            G1, G2, strategy
        >::apply(g1, g2, strategy());
  }

There's nuance to banning that since implementating multiple interfaces is technically multiple inheritance in C++. So I think I'd agree with you but with an exception for pure-virtual classes.

> Also, while iostream is a bit of a mess, having it be strongly typed means that it's, in my opinion, well worth using over cstdio.

Orthodox C++ would ban this but you can have both printf-style with type safety with https://github.com/fmtlib/fmt

Which inspired C++20's std::format: https://en.cppreference.com/w/cpp/utility/format

Which is also banned by Orthodox C++