What is the worst opening move in Chess960 for White? Is there a first move for white in Chess960 in which white can immediately blunder a piece or lose a significant advantage (say -2.0 or so)?
This calls for some scripting, so here's my first hasty attempt at it ;)

Here's a quick way you can do the search on your own in python, using stockfish 10 and only the python-chess package. All open-source and free-software!

Briefly, what the script will do:


Consider all 960 positions, one at a time
For each position, it scans over all legal white moves
For each move, it evaluates the position with a engine ponder time given by user (e.g. 1 second)
If the evaluation is below the given threshold (e.g. -2.0) then it shows the board, the FEN, the move and the evaluation. 
At the end everything will be saved in a text file, so you don't need to log the printouts in the terminal.




Examples found running the script for first 5 chess960 positions

Let's showcase it for the first 5 chess960 positions where:


The evaluation threshold is set to -1.0
The ponder time is 1.0 second per move.


Here are the found cases: (below is the saved results in a textfile, first column is the chess960 position FEN, 2nd column the move whose evaluation fell below the threshold, and the 3rd column is the corresponding evaluation)

bbqnnrkr/pppppppp/8/8/8/8/PPPPPPPP/BBQNNRKR w KQkq - 0 1    g4  -2.19
bqnbnrkr/pppppppp/8/8/8/8/PPPPPPPP/BQNBNRKR w KQkq - 0 1    g4  -1.51
bqnnrbkr/pppppppp/8/8/8/8/PPPPPPPP/BQNNRBKR w KQkq - 0 1    g4  -1.66
qbbnnrkr/pppppppp/8/8/8/8/PPPPPPPP/QBBNNRKR w KQkq - 0 1    g4  -1.35


1.g4 seems to be commonly the worst move among the first 5 setups.

Not so surprising, since in all the so far considered chess960 positions, namely the first 5, the king stands on the usual kingside (specifically, on g1).

Thus, 1.g4 is a highly weakening move with the king on g1.

Here are the positions (updated, 3 more examples found by running script longer):


 eval = -2.19 

 eval = -1.51 

 eval = -1.66 

 eval = -1.35 

 eval = -2.8 

 eval = -2.07 

 eval = -2.12 



Continue the search on your own using the script

To go over all 960 positions takes a lot of time and computational resources. So I leave it up to you and other if they are interested, to run the script for longer ponder times, to scan all 960 positions, and to play with the evaluation threshold of interest. To do that on your own, here's the python script, using Python 3.7.4, python-chess 0.30.1, and Stockfish 10 (place the engine file in same folder as the script):

import chess
import chess.engine
import os
import sys

arguments = sys.argv
pondertime = float(arguments[1])
evalthreshold = float(arguments[2])
#here we assume the engine file is in same folder as our python script
path = os.getcwd()
#Now make sure you give the correct location for your stockfish engine file
#...in the line that follows by correctly defining path
engine = chess.engine.SimpleEngine.popen_uci(path+'/'+'stockfish-10-64')

lsfens = []
lsmoves = []
lsevals = []

numberofpos = 960

for i in range(numberofpos):
    board = chess.Board.from_chess960_pos(i)
    print('Currently analysing the position below')
    print(board)
    print('--------')
    for el in board.legal_moves:
        info = engine.analyse(board, chess.engine.Limit(time=pondertime), root_moves=[el])
        t = str(info["score"])
        if t.startswith('#'):
                print(str(board.san(el))," eval = mate in ", t)
        else:
            if round(int(t)/100.,2)&lt;evalthreshold:
                print('Starting 960 position index: ', board.chess960_pos())
                print('Position FEN: ',board.fen())
                print(str(board.san(el))," eval = ", round(int(t)/100.,2))
                lsfens.append(board.fen())
                lsmoves.append(str(board.san(el)))
                lsevals.append(str(round(int(t)/100.,2)))
    print('--------------------------------------')

engine.quit()

with open('FoundPositions_Pondertime_'+str(pondertime)+'_threshold_'+str(evalthreshold)+'.txt', 'w') as file:
    for i in range(len(lsfens)):
        file.write(lsfens[i]+'\t'+lsmoves[i]+'\t'+lsevals[i]+'\n')


How to run the script:


Copy paste the code into a textfile and save it with a name like 960evaluator.py
Make sure you have python3 installed, similarly for python-chess module (see here for installation) and have downloaded the stockfish binary for your OS.
Place the engine file and the script in the same folder, and open a terminal in that folder
Run the script with the command python 960evaluator.py 1.0 -2.0
Note the first argument you give after the script name is the ponder time per move in seconds. The higher the ponder time value, the more accurate the evaluation.
The second argument is the evaluation threshold: that is, all positions with 1st move evaluations below the given value (in this example -2.0) will be printed in terminal and saved at the end (you could do the saving while running so you can crash the script without losing the so far found cases).
Again, the found cases will be printed in terminal as they are found, but also saved in a text file placed in same folder as your script.


The terminal printouts will look like:

Currently analysing the position below
b b q n n r k r
p p p p p p p p
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
P P P P P P P P
B B Q N N R K R
--------
Starting 960 position index:  0
Position FEN:  bbqnnrkr/pppppppp/8/8/8/8/PPPPPPPP/BBQNNRKR w KQkq - 0 1
g4  eval =  -2.19


Have fun scanning, though do so with caution: running chess engines for long times on personal machines is bit risky as it quickly heats up!