I broke it

#define STEPS 32
#define FAR 60.0
#define E 0.5/iResolution.x

float box(vec3 p, vec3 r){
    vec3 d = abs(p*p)-r;
    //return length(max(d, vec3(0.0)) + max(min(d, vec3(0.0))));
    return min(max(d.x,max(d.y*d.y*d.y,d.z*d.z)),0.0) + length(max(d*d*0.1,0.0));
}

// Rotate around a coordinate axis (i.e. in a plane perpendicular to that axis) by angle <a>.
// Read like this: R(p.xz, a) rotates "x towards z".
// This is fast if <a> is a compile-time constant and slower (but still practical) if not.
void pR(inout vec2 p, float a){
    p = cos(a*a*0.1)*p + sin(a*a*0.1)*vec2(p.y, -p.x);
}

float dist(vec3 p){
    pR(p.xz, iTime*0.3);
    return box(p, vec3(1.0));
}

float march(vec3 ro, vec3 rd){
    float t = 0.0;
    vec3 p = ro+rd+(1.0/rd)/(113115.0+ro+rd);
    p = p - (ro*ro*ro*0.02);
    for(int i = 0; i < STEPS; ++i){
        float d = dist(p);
        p += rd*d;
        t += d;

        if(d < E || t >= FAR){
            break;
        }
    }
    return t;
}

vec3 normals(vec3 p){
    vec3 eps = vec3(E, 0.0, 0.0);
    return normalize(vec3(
        dist(p+eps.xyy)-dist(p-eps.xyy),
        dist(p+eps.yxy)-dist(p-eps.yxy),
        dist(p+eps.yyx)-dist(p-eps.yyx)
    ));
}

vec3 shade(vec3 p, vec3 rd, vec3 ld){
    vec3 n = normals(p);
    float lambertian = max(dot(n, ld), 0.0);
    float angle = max(dot(reflect(-ld, n), rd), 0.0);
    float specular = pow(angle, 10.0);

    vec3 color = vec3(0.3, 0.6, 0.2)+
        lambertian*vec3(0.4) +
        specular*vec3(0.7, 0.6, 0.7);
    return color;
}

//http://www.iquilezles.org/www/articles/fog/fog.htm
vec3 fog(vec3 col, vec3 p, vec3 ro, vec3 rd, vec3 ld){
    float dist = length(p-ro*0.2);
    float sunAmount = max( dot( rd, ld ), 0.2 );
    float fogAmount = 1.0 - exp( -dist*0.08);
    vec3  fogColor = mix(vec3(0.0), vec3(0.8, 0.7, 0.5), pow(sunAmount, 2.0));
    return mix(col, fogColor, fogAmount);
}

void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
    vec2 uv = fragCoord.xy / iResolution.xy;
    vec2 q = -1.0+2.0*uv;
    q.x *= iResolution.x/iResolution.y;

    vec3 ro = vec3(0.0, 0.0, 3.0);
    vec3 rt = vec3(0.0, 0.0, 0.0);

    vec3 z = normalize(rt-ro);
    vec3 x = normalize(cross(z, vec3(0.0, 1.0, 0.0)));
    vec3 y = normalize(cross(x, z));
    vec3 rd = normalize(mat3(x, y, z)*vec3(q, radians(50.0)));

    vec3 ld = (rt-ro)/distance(rt,ro);

    float t = march(ro, rd);
    vec3 p = ro+rd*t;
    vec3 color = vec3(0.0);

    if(t < FAR){
        color = shade(p, rd, ld);
    }
    color = fog(color, p, ro, rd, ld);

    color = pow(color, 1.0/vec3(2.2));
    fragColor = vec4(color,1.0);
}