No worries, but let me clarify a bit:
RanQ1 is a LFSR with 64 bits of state, three multibit shifts and xors per iteration, with a multiplication mixing stage.
Xorshift64* is a LFSR with 64 bits of state, three multibit shifts and xors per iteration, with a multiplication mixing stage.
That makes them "essentially the same", although the shifts are different, and they generate different sequences.
RanQ1 originates in Numerical Recipes, and fails both MatrixRank and BirthdaySpacings test of the BigCrush suite.
Xorshift64* uses different shift counts and mixing multiplier, and fails only MatrixRank test of the BigCrush suite.
George Marsagllia described the Xorshift family of PRNGs in 2003.
What I showed above, was the Xorshift64*/32 variant, that generates 64 bits of state each iteration, of which only the 32 highest bits are used.
Note that
xoshiro256+ has a similar deficiency, albeit only in the three lowest bits.
The creators'
paper at arxiv describes the behaviour of the family of generators in the BigCrush test suite, and
xoshiro256++ passes all BigCrush tests (in a 10¹⁵-byte test). The xoshiro family was designed as a successor to xorshift, and unless weaknesses are found in it, I too will likely shift to it (because it is faster). The reason I haven't shifted yet is that they xoshiro family is relatively new: xoshiro256++ from
2019, compared to xorshift64* from
2003. Marsaglia's original xorshift family has been more thoroughly investigated; xorshift64* is the 12,25,27 variant of the 275 64-bit ones listed in the article.
It is interesting to note that these actually behave better than Mersenne Twister, often considered the gold standard for numerical simulations (my own field). These are also fast as all hell, with cache footprints so small that other cache-heavy computations are not really affected at all (unlike MT19937/MT19937-64, which has about 2.5KiB of state, with different cachelines accessed in sequence, and entire state regenerated per cycle though the state).
It is important to realize that even though these are "random", they are not unpredictable when given a sequence of generated numbers. Someone who knows sufficiently many sequential generated numbers can still predict new values. The fact that xorshift64*/32 only returns the high 32 bits makes that harder, but not impossible. Really unpredictable PRNGs are called
cryptographically secure PRNGs, and are quite different beasts. For that, I recommend something like
ChaCha20. There is a
SystemVerilog implementation of ChaCha20 licensed under the permissive
MIT license. You can also find other projects and thesis works on that subject using a web search.