Which really big number is bigger?
Ruby, 150 bytes

See revisions for previous byte counts.

-&gt;a,b,c,d,e,f,g,h,i,j{l=-&gt;s,t=c{Math.log(s,t)};y,z=l[l[g,b]]-d**e+l[h]*i**=j,l[l[a,f]*b**c,g];a&gt;1?f&lt;2?1:b&lt;2||g&lt;2?z&gt;h:c&lt;2||d&lt;2?l[z,h]&gt;i:y==0?a&gt;f:y&lt;0:p}


-10 bytes thanks to @ValueInk

+16 bytes thanks to @RosLuP for bugs.

Try it online.

Compare different base powers-towers (of 'height' five)?

Ungolfed code:

-&gt; a, b, c, d, e, f, g, h, i, j {
    l =-&gt; s, t = c {Math.log(s, t)}
    i **= j
    y = l[l[g, b]] - d ** e + l[h] * i
    z = l[l[a, f] * b ** c, g]
    if a == 1
        return p
    elsif f == 1
        return 1
    elsif b == 1 || g == 1
        return z &gt; h
    elsif d == 1 || c == 1
        return l[z, h] &gt; i
    elsif y == 0
        return a &gt; f
    else
        return y &lt; 0
    end
}


Code breakdown:

l =-&gt; s, t = c {Math.log(s, t)}


This is the base t logarithm, which will be used to reduce the size of the numbers we are comparing. It defaults to base c when only one argument is given.

i **= j
y = l[l[g, b]] - d ** e + l[h] * i
z = l[l[a, f] * b ** c, g]


This updates i = i ** j since i never gets used on it's own, and y is the result of logging b^c^d^e == g^h^i(^j) twice and moving everything to one side. We then let z = l[a, f] * b ** c as the log base g of the log base f of a ** b ** c.

if a == 1
    return p
elsif f == 1
    return 1


1^b^c^d^e = 1 is never greater than f^g^h^i^j, and likewise, a^b^c^d^e is always greater than 1^g^h^i^j = 1 if a != 1. Note that return p returns nil, which is falsey, and return 1 returns 1, which is truthy.

elsif b == 1
    return z &gt; h


If b == 1 or g == 1, then this reduces to comparing a ** b ** c to f ** g ** h, which is done with two logs to both sides.

elsif d == 1 || c == 1
    return l[z, h] &gt; i


This compares a ** b ** c with f ** g ** h ** i by rearranging it as log[log[b ** c * log[a, f], g], h] compared to i. (Recall that i **= j in the beginning and z = log[b ** c * log[a, f], g].)

elsif y == 0
    return a &gt; f
else
    return y &lt; 0
end


This compares the 4 highest powers after logging both sides twice. If they are equal, it compares the base.