END OF AN ERA, FRACTALFORUMS.COM IS CONTINUED ON FRACTALFORUMS.ORG

You are right. IMHO "projection of the octonion on quaternionic complex hyperplane" is oversophistication. It still is quaternion based engine, so there is no way to deffine octanion variables. But two quaternion variables are just like one octonion variable.

Its how I did a hyperbolic sine with quaternions.
quaternion C, Ch;
import Math.Hypercomplex as hmath;
void init(void)
z= 0;
C= pixel;
void loop(void)
{
Ch = hmath.cosh(z);
z= z*Ch*z -sqr(C);
}
bool bailout(void)
{
return(  |z|  <= bailout);
}

Since there are multiplication, maybe a mandelbrot set on octonions. Could be like this:
import Math.Octonion as omath;

omath.mult (z,Z1,z,Z1,z,Z1);
z=z+C;

z, z1, C both are quaternion variables, of them z are predefined. z=z+C is in quaternions of corse, and with k=0. Maybe with some combination of z and pixel coordinates you can get something.

So far I hadn't seen a single fractal on octonions, even the most ugly one;) Maybe if 3 dimensions would be put twice, there would be just 2 left as 0.

It's pretty straight forward to do all this via the Cayley-Disckon construction
Basically, addition is always defined per element and multiplication like this:
given two pairs of numbers (a,b) and (c,d), the pairs are multiplied like this:
(*) - note, the order of multiplication is important. You cannot reorder these structures.

You can do this for ANY pair of ANY numbers, e.g. if a,b,c and d are all reals, you get the complex numbers.
If you repeat this for where a,b,c and d are complex numbers, you get quaternions.
If you repeat it for them being quaternions, you get octronions and so on.

That way, you obtain a recursive definition which you can carry out ad infinitum. It would probably require only very little code to write something like that.

Given a vector with elements, split it into two vectors with elements and multiply them according to the rule above. Repeat until you arrive at vectors with exactly 1 element in which case the multiplication trivially reduces to the normal kind of multiplication.

That would be a recursive divide-and-conquer type algorithm for multiplying arbitrary octonions, sedenions or any higher order number defined in such a way. The only constraint is to have the number of elements be where .

(*) the just is complex conjugation: - just like multiplication, it's defined recursively. Note the after the =. It means that you have to apply it to the part vector again, so it keeps being applied until you reach individual reals which, of course, don't change under conjugation.

Since you already have quaternions defined, you could just define octonions as vectors of two quaternions which you use those rules on, as described here.

This might be rather useless, but just visualize them the way you like - preferably in a way that gives interesting results.
You can really only visualize 3 or less Dimensions, so even with a Quaternion it's not clear what to choose.
Take any three directions and plot them as any of the various subspaces you could choose.

You could "just" go through all possible 3D subspaces to find which one are most interesting.
Alternatively, you could do 2D subspaces as demonstrated by M Benesi's video above.

It's just impossible to do better than that in our world, and even 3D is kind of a hack for the screens we use to show 3D objects on are themselves flat.

The difference really just is that, if you show a 3D (or higher) object on a screen, you'll do a projection down to 2D, while if you do a 2D image, what you do is a cut through your object.