Which is the simplest cryptographic algorithm which is close to commercial-level security? An algorithm is simpler than another if

It is easier to explain to a noob with basic high-school math knowledge.
It is easier to securely self-implement by an intermediate programmer (Yes I know one should never 'roll their own' but this is just a metric of comparing simplicity)
Can be done by hand &amp; paper more easily (not necessarily that it can practically be done on paper, but that it is easier to do on paper if one were to take the pains to do so)
Involves lesser steps.
Any other factors that don't immediately come to mind.

To give an example with popular ciphers, by these criteria RSA is simpler than AES.
The point of this question is maybe find out about some very clever albeit less popular/unheard of cryptographic algorithms that are at or quite close to real commercial-level security while still being incredibly simple.
To use simpler words, the requirements are much above Caesar cipher but much below AES, in terms of complexity.
A question on the most secure hand ciphers inspired this question, except there are no such limitations of not having computational/calculational power here, but similar/stricter restriction on complexity. The idea is to test the limits of simplicity that cryptography can reach while still being done right.
Perhaps symmetric ciphers would be ideal for the criteria of simplicity. However, obviously, any cipher is to-the-mark if it is simple and secure enough.
Edit 1 : The criteria listed above are in order of importance, i.e, the 1st is more important than the second and so on.
I would say MiMC is the simplest block cipher with plausible security. The idea is to cube the state, add a random constant, and repeat. This is typically done in a large prime field, but it is trivial to implement field arithmetic in any language with big integer support. Here's a Python implementation:
def mimc(x, p, k, constants):
    x = (x + k) % p
    for c in constants:
        x = (x**3 + k + c) % p
    return x

Notes:

x is the input.
p is the (prime) order of the field.
k is the block cipher key.
constants is a list of r random field elements, where r is the number of rounds. (The paper uses r - 1 constants, since adding one in the final step does nothing for security, but it doesn't hurt either.)
The authors recommend r = ceil(log(p)/log(3)).
The field must be one in which cubing is a permutation, which holds if gcd(3, p - 1) = 1.