To avoid entering commands:

mov mem1[1] red1
mov mem1[2] red2
mov mem1[3] red3
mov mem1[4] red4

You could enter an array. But with a strict restriction, in order. That is, we cannot enter 4 values in 3 cells. Or 3 values in 4 cells.
Example:

armov mem1[1] mem1[4] red1 red4

Or another way. More universal functions. To use repeated commands with each line of the list.
An abbreviated example:

ar mov out1 out3 r1 r3
ar sst r8 r10 'X'

What it looks like without this function:

mov out1 r1
mov out2 r2
mov out3 r3
sst r8 'X'
sst r9 'X'
sst r10 'X'

And processing large arrays would most likely be more computationally demanding, so you should warn users about the complexity of this process (Need to check and testing)

Some of this is supposedly already supported (per docs) by the SIMD instructions like xmov. Of course those don't give you the chance to arbitrarily rearrange the signals like this would. And at this point it's really unclear how much of SIMD (or any other instructions at all!) are actually working. Is @mataxetos still working on this mod at all? The authors of the other 2 versions of fcpu seem to have abandoned it already. Sad - it has huge potential.

Is @mataxetos still working on this mod at all?

Wait for the PLC. That's all I can tell you (this is a spoiler). So, you will soon forget about fCPU and switch to PLC.

And, I meant about the cyclic command with increment. That is, we can execute the operation multiple times, assigning different sources or different cells. It would also be useful to use the arnext command to continue executing this array of commands by 1. It would also be cool to use them together with label. To call this command remotely.

That's great news, thanks! Cause from what I've seen, every fork of fcpu is riddled with bugs. And that makes sense, cause it's actually deceptively ambitious. To try to do that many things, you have to really pay attention to details of your architecture during every step of development. Else your compromises and kludges will soon paint you into a corner leaving no escape. I haven't looked at fcpu code, but from its behavior, it smells like that.

The creator of the fCPU wrote how it works, but on a simpler level. I myself do not know how it is technically written and how it works.