Randomize List with guaranteed Index Change
NOTE: updated (before it had low=i+1 always, this missed some valid results, and missed the extra check needed for the last index)
**NOTE: update 2 - randomize order to ensure uniformity **
Consider the following approach:
loopIndex[0..n-1] = permute([0..n-1])
index[0..n-1] = [0..n-1] // track indices
for i=0..n-2
   idx = loopIndex[i]
   if index[idx] == idx
      low = i+1
   else low = i
   swapIdx = random(low,n) // random(start,end) --&gt; start &lt;= i &lt; end
   swapElement(index, idx, loopIndex[swapIdx])
   swapElement(array, idx, loopIndex[swapIdx])
finalIdx = loopIndex[n-1]
if index[finalIdx] == finalIdx
   finalSwapIdx = random(0,n-1)
   swapElement(index, finalSwapIdx, finalIdx)
   swapElement(array, finalSwapIdx, finalIdx)

PROOF NOT YET UPDATED
Note the following:

loopIndex is used to give a random ordering on which we process the elements. This ensures that any non-uniformity is &quot;smoothed out&quot;.
If an index $j$ is selected as swapIdx then that element is swapped to a place where it's not processed again in the loop.
If an index $j &lt; n-1$ is never selected as swapIdx then when $i==j$ the element will be swapped out from $j$ and never can return to $j$.
The final check handles the case where the final element was never selected. In this case, we swap between $n-1$ and some other random element.

Proof of uniformity by induction on the index -
Let $p(j,k)$ be the probability that after completing $i=j$, the element at index $j$ is the element that originally had index $k \neq j$ (clearly $p(j,j)=0$).
Then $p(0,k)=\frac{1}{n-1}$ clearly.
Assume then that the statement holds for all $j \leq t$ and we now prove for $j=t+1$.
$p(t+1,k)$ is the probability the element with original index $k$ is not in the first $t$ elements at step $i=t+1$, times the probability that $k$ is swapIdx now. By the assumption, this is then:
$$
\left(\frac{n-2}{n-1}\right)\left(\frac{n-3}{n-2}\right)\dots\left(\frac{n-t-1}{n-t}\right)\left(\frac{1}{n-t-1}\right) = \frac{1}{n-1}
$$
(Note that there is a minor difference between $k \leq t$ and $k &gt; t+1$. For the former, it must not have been selected as a swapIdx for $j \neq k \leq t$, and it must not have selected $t+1$ as its swapIdx. For the latter, it must not have been selected as a swapIdx. The result though is the same in terms of the math).