Answers.Body: <p>Using @Phonon's Python script, I was able to determine that the worst move is <code>1. g4??</code> from the <code>BBQRNNKR</code> starting configuration, or <code>1. b4??</code> from its mirror image.</p>
  <p>This evaluates to <code>-2.5</code> in one second of Stockfish search.  Not quite a minor piece, but still a substantial handicap to recover from.</p>
  <p>Why is this position so powerful for the opponent?  The black Queen is able to threaten the advanced pawn as soon as its way is unblocked by <code>1. … d5</code>; once there, White is in check after move 2!  Then, after <code>3. … Qxf2</code> Black is able to fork several of White's pieces on the back rank, possibly including the other Rook.</p>
  <p>This line begins:</p>
  <pre><code>1. …     d5
  2. c3    Qxg4+
  3. Ng3   b6
  4. d4    c5
  </code></pre>
  <p>Additionally the black Bishops have similarly direct lines to the white Kingside Rook and its pawn.  White can defend, but doing so immobilises several pieces and thus loses a lot of development tempo.  He also no longer has a viable pawn structure in front of his King.</p>
  <p>The above is not even Stockfish's <a href="https://lichess.org/analysis/chess960/bbqrnnkr/pppppppp/8/8/8/8/PPPPPPPP/BBQRNNKR_w_kqKQ__-_0_1#1" rel="nofollow noreferrer">preferred line</a> for Black:</p>
  <pre><code>1. …     h5
  2. gxh5  b6
  3. Ng3   Ne6
  4. Ng2   c5
  </code></pre>
  <p>…after which Black has a Rook on a semi-open file, two Bishops pointing at White's King and several pieces (which, as predicted, are pinned down in defensive positions), and a quite acceptable pawn structure and control of the centre.  White has none of these things.</p>
  <p>Extending the analysis time to 5 seconds, the evaluation of this position and its mirror image deepen to <code>-2.79</code> and <code>-2.81</code> respectively.  Their nearest rivals are around <code>-2.54</code> at this level.</p>
  
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-01-29T08:58:41.347Z
Answers.Text: Great work! `BBQRNNKR` is possibly the most harmonious arrangement of pieces to launch a kingside attack and white's `g4` even *further* encourages a kingside battle, a positional disaster!
Answers.UserDisplayName: Ellie
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-01-29T09:45:31.480Z
Answers.Text: It is unclear to me what the variation is supposed to be after 1.g4 d5 that leads to 3...Qxf2.
Answers.UserDisplayName: Evargalo
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-01-29T12:11:34.840Z
Answers.Text: @Evargalo That's my amateur analysis which assumes `2. … Qxg4` or something very similar.  Stockfish does a better job, of course.
Answers.UserDisplayName: Chromatix
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2021-05-25T12:04:32.763Z
Answers.Text: @Chromatix : I wasn't debatting the quality of your analysis, it is just that you don't provide the moves in between and they are not obvious to guess...
Answers.UserDisplayName: Evargalo
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-01-29T04:38:41.727Z
Answers.LastActivityDate: 2021-05-25T18:49:12.070Z
Answers.LastEditDate: 2021-05-25T18:49:12.070Z
Answers.UserDisplayName: Chromatix
Answers.Body: <p>You said "blunder a piece" or "lose significant advantage", so how about mate since that is even worse? I could only find a few, but here they are.</p>
  
  <p>Since it takes at least two moves for there to be any interaction between pieces, I am going to start there, and use some logic, but I could still only find a very few.</p>
  
  <p>First, you have to keep in mind that traditional chess can, and has, been one of the starting positions in actual competitions, so this horrid opening comes to mind first as a logical starting place.</p>
  
  <pre><code> [FEN ""]
  
   1. g4 e6 2. f4 Qh4#
  </code></pre>
  
  <p>From that, we know that THE worst openings have to be mates of white in two moves (it still takes three moves for white to mate black). Of course, you can have the famous two-move mate that on the other side too.</p>
  
  <p>From here, I am just going to use pictures since I am not sure how PGN/FEN works for Chess 960.</p>
  
  <p><a href="https://i.sstatic.net/a8zV1.png" rel="noreferrer"><img src="https://i.sstatic.net/a8zV1.png" alt="enter image description here"></a></p>
  
  <p>Here is another mate with the queen.</p>
  
  <p><a href="https://i.sstatic.net/kZd79.png" rel="noreferrer"><img src="https://i.sstatic.net/kZd79.png" alt="enter image description here"></a></p>
  
  <p>Here is another that is similar. I could just move this over a file, but I will not add any more like this with the king just hemmed in by rooks since you get the idea.</p>
  
  <p><a href="https://i.sstatic.net/ePa1h.png" rel="noreferrer"><img src="https://i.sstatic.net/ePa1h.png" alt="enter image description here"></a></p>
  
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-01-28T14:15:07.830Z
Answers.Text: The question *title* says "worst opening move", though the question itself could be interpreted a bit more generally. Regardless of the quality of the opening move, in these examples the *second* move seems to be the blunder, since there are obvious second moves by white which would capture the black queen if black played the check.
Answers.UserDisplayName: alephzero
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-01-28T14:25:56.903Z
Answers.Text: @alephzero, I realize, but when he added "white can immediately blunder" to the question, and it is clear that that is impossible on the "opening move", I thought it opened the door to the phrase "opening moves", rather than just "opening move".
  
  At the time I was compiling my answer, Phonon had not yet posted, and I did not want to throw away 20+ minutes of work.
  
  I also thought that there might not be any additional answers at the time, so that mine might be better than nothing.
  
  I did upvote his answer.
Answers.UserDisplayName: PhishMaster
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2021-05-25T19:18:05.137Z
Answers.Text: Your third example is not valid, since the king must start between the rooks in Chess960.
Answers.UserDisplayName: Brian McCutchon
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-01-28T11:02:11.777Z
Answers.LastActivityDate: 2020-01-28T11:02:11.777Z
Answers.UserDisplayName: PhishMaster
Answers.Body: <p>This calls for some scripting, so here's my first hasty attempt at it ;)</p>
  
  <p>Here's a quick way you can do the search on your own in <a href="https://www.python.org/" rel="noreferrer">python</a>, using <a href="https://stockfishchess.org/" rel="noreferrer"><code>stockfish 10</code></a> and only the <a href="https://python-chess.readthedocs.io/en/latest/" rel="noreferrer"><code>python-chess</code></a> package. <strong>All open-source and free-software!</strong></p>
  
  <h2>Briefly, what the script will do:</h2>
  
  <ul>
  <li>Consider all 960 positions, one at a time</li>
  <li>For each position, it scans over all legal white moves</li>
  <li>For each move, it evaluates the position with a engine ponder time given by user (e.g. 1 second)</li>
  <li>If the evaluation is below the given threshold (e.g. <code>-2.0</code>) then it shows the board, the FEN, the move and the evaluation. </li>
  <li>At the end everything will be saved in a text file, so you don't need to log the printouts in the terminal.</li>
  </ul>
  
  <hr>
  
  <h2>Examples found running the script for first 5 chess960 positions</h2>
  
  <p>Let's showcase it for the first <code>5</code> chess960 positions where:</p>
  
  <ul>
  <li>The evaluation threshold is set to <code>-1.0</code></li>
  <li>The ponder time is <code>1.0</code> second per move.</li>
  </ul>
  
  <p>Here are the found cases: <em>(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)</em></p>
  
  <pre><code>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
  </code></pre>
  
  <h2><code>1.g4</code> seems to be commonly the worst move among the first 5 setups.</h2>
  
  <p><strong>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 <code>g1</code>).</strong></p>
  
  <h2>Thus, <code>1.g4</code> is a highly weakening move with the king on <code>g1.</code></h2>
  
  <p>Here are the positions (<strong>updated</strong>, <em>3 more examples found by running script longer</em>):</p>
  
  <p><img src="https://i.sstatic.net/uSaI8.png" width="200" height="200">
  <sup><i> eval = -2.19 </i></sup>
  <img src="https://i.sstatic.net/bTXge.png" width="200" height="200">
  <sup><i> eval = -1.51 </i></sup>
  <img src="https://i.sstatic.net/bBsT5.png" width="200" height="200">
  <sup><i> eval = -1.66 </i></sup>
  <img src="https://i.sstatic.net/Tj7Wn.png" width="200" height="200">
  <sup><i> eval = -1.35 </i></sup>
  <img src="https://i.sstatic.net/t4Ljo.png" width="200" height="200">
  <sup><i> eval = -2.8 </i></sup>
  <img src="https://i.sstatic.net/WbBBO.png" width="200" height="200">
  <sup><i> eval = -2.07 </i></sup>
  <img src="https://i.sstatic.net/2a3BX.png" width="200" height="200">
  <sup><i> eval = -2.12 </i></sup></p>
  
  <hr>
  
  <h2>Continue the search on your own using the script</h2>
  
  <p>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 <code>Python 3.7.4</code>, <code>python-chess 0.30.1</code>, and <code>Stockfish 10</code> (place the engine file in same folder as the script):</p>
  
  <pre><code>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')
  </code></pre>
  
  <h2>How to run the script:</h2>
  
  <ol>
  <li>Copy paste the code into a textfile and save it with a name like <code>960evaluator.py</code></li>
  <li>Make sure you have python3 installed, similarly for <code>python-chess</code> module (see <a href="https://pypi.org/project/python-chess/#installing" rel="noreferrer">here for installation</a>) and have downloaded <a href="https://stockfishchess.org/download/" rel="noreferrer">the stockfish binary for your OS</a>.</li>
  <li>Place the engine file and the script in the same folder, and open a terminal in that folder</li>
  <li>Run the script with the command <code>python 960evaluator.py 1.0 -2.0</code></li>
  <li>Note the <strong>first argument</strong> you give after the script name is the <strong>ponder time</strong> per move in seconds. The higher the ponder time value, the more accurate the evaluation.</li>
  <li>The <strong>second argument</strong> is the <strong>evaluation threshold</strong>: that is, all positions with 1st move evaluations below the given value (in this example <code>-2.0</code>) 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).</li>
  <li>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.</li>
  </ol>
  
  <p>The terminal printouts will look like:</p>
  
  <pre><code>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
  </code></pre>
  
  <p>Have fun scanning, though do so with caution: <strong>running chess engines for long times on personal machines is bit risky as it quickly heats up!</strong></p>
  
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-01-28T10:51:49.577Z
Answers.Text: Does Stockfish 10 know about the chess 960 castling rules, and do you call it in a way that it knows this is is 960?
Answers.UserDisplayName: RemcoGerlich
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-01-28T11:06:07.240Z
Answers.Text: @RemcoGerlich Good question! I reckon the evaluation is just considering the position by itself, so without knowledge of castling rules in chess960. Nonetheless, for the purposes of all the showcased positions, the castling makes negligible difference considering that short castles keeps the king on kingside (so still suffering from the weakened light squares induced by `g4`) while long castles is far too many tempi away to be relevant. But for the remaining chess960 positions, it might make a difference in the eval. Should be easy to assess those cases manually once the search is finished.
Answers.UserDisplayName: Ellie
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-01-28T13:27:39.723Z
Answers.Text: @user253751 it's a just a word of caution, since the (unexperienced) user might use high ponder times and leave the search on (which can take hours) with the laptop lying on a surface (like carpet) that causes inadequate ventilation.
Answers.UserDisplayName: Ellie
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-01-28T14:15:44.413Z
Answers.Text: "engine ponder time given by user (e.g. 1 second)", "To go over all 960 positions takes a lot of time and computational resources." ;)
Answers.UserDisplayName: JollyJoker
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-01-28T14:26:57.277Z
Answers.Text: @JollyJoker and per position it needs to scan about 20 branch-outs (total legal moves per position), so it's 1 second per *move*, and the number of starting moves varies with the 960 positions. Say 20 starting moves per position, then we have 20 seconds per position, so about 6 hours of runtime for all 960 at 1 second ponder time (which is already quite low per move, going lower the reliability in the evaluation suffer drastically).
Answers.UserDisplayName: Ellie
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-01-28T14:30:35.630Z
Answers.Text: @Phonon Ah, missed the factor of 20. Well, you could always reduce the ponder time below 1s.
Answers.UserDisplayName: JollyJoker
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-01-28T21:47:34.760Z
Answers.Text: What's the acquired depth after 1 second?
Answers.UserDisplayName: Mast
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-01-28T22:18:00.933Z
Answers.Text: @Mast About `20` plies. All these extra details are stored in `info` (see code). For instance, to see the reached depth and count of searched nodes: `print("depth and nodes", info["depth"], info["nodes"])`
Answers.UserDisplayName: Ellie
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-01-28T22:25:25.557Z
Answers.Text: I've modified my copy of the script slightly so that it will print the worst move found at the end of the search, and set it running.  See you in six hours…
Answers.UserDisplayName: Chromatix
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-01-29T13:36:35.513Z
Answers.Text: I am afraid this experiment tells us only that Stockfish's evaluation function penalizes heavily having a hole in front of the king.
Answers.UserDisplayName: Federico Poloni
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-01-29T14:16:06.673Z
Answers.Text: @FedericoPoloni e.g. in `BBQRNNKR`: `g4` opens the diagonal for the `a8` bishop, the `b8` bishop eyeing the kingside becomes stronger as a fortress with `g3` can no longer be established, the queen on `c8` can target the unprotected `g4` pawn in one move, while also able to create a deadly mating battery with `b5-Qb7`. The knights are centrally placed which means, despite their slowness, they can reach the white kingside in 2 moves starting from `Nf6-Ng6,` exploiting `f4-h4` holes. Last but not least, `g4` acts as a hook, which can be exploited to open files (e.g. with `h5`) for the rooks.
Answers.UserDisplayName: Ellie
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-01-29T14:19:53.517Z
Answers.Text: @Phonon I assume stockfish runs multithreaded when called in this manner? Otherwise there's an obvious optimization that should greatly reduce the time. If it does then the time should be off by approximately the CPU count, except if we are memory bound.
Answers.UserDisplayName: Voo
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-01-29T17:15:16.693Z
Answers.Text: @Voo On my Linux machine it runs single-threaded.  But even if it was multithreaded, this would change the effective search depth but not the search time.
Answers.UserDisplayName: Chromatix
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-01-29T17:20:54.247Z
Answers.Text: @Chromatix The idea would be to use multiple processes to analyse the initial board states in parallel. You'd still spend the same time on a single one of the 960 board states, but could analyse several at once. Depends which resources we're constrained in, but I'd expect a nice speedup with this.
Answers.UserDisplayName: Voo
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-01-29T17:51:05.270Z
Answers.Text: @Voo It could be done that way, but not with this script.  You'd need to run multiple instances of the engine ad implement threading; the script only starts one.
Answers.UserDisplayName: Chromatix
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-01-29T18:14:57.997Z
Answers.Text: @Chromatix Yes sure, that's why I'm saying "if it's single threaded there'd be an obvious optimization". You wouldn't want to use threading in Python though, you definitely would want the multiprocessing module here.
Answers.UserDisplayName: Voo
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-01-30T22:59:24.233Z
Answers.Text: Stockfish is definitely capable of playing FRC, but you might need to enable the FRC setting. Also, Stockfish 11 is available now, if you haven't already upgraded you might want to (it's free).
Answers.UserDisplayName: Allure
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-01-28T10:43:30.887Z
Answers.LastActivityDate: 2020-01-28T13:40:07.137Z
Answers.LastEditDate: 2020-01-28T13:40:07.137Z
Answers.UserDisplayName: Ellie
Body: <p>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)?</p>
  
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2020-01-28T07:06:28.583Z
Comments.Text: Since the 960 variant is named for the number of initial positions it allows, it is difficult to answer the worst opening movement of any of those 960 initial positions.
Comments.UserDisplayName: djnavas
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2020-01-28T09:09:39.277Z
Comments.Text: @djnavas: I'm assuming he means taking all possible opening positions into account, what's the worst white move in them. That's difficult but questions are allowed to be difficult.
Comments.UserDisplayName: RemcoGerlich
Tags: <opening><engines><analysis><programming><chess960>
Title: What is the worst opening move in Chess960 for White?
ThreadText: # What is the worst opening move in Chess960 for White?
  
  (Asked by: username_0 on 2020-01-28)
  
  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)?
  
  **Tags:** opening, engines, analysis, programming, chess960
  
  > **Comments:**
  > **username_1**: Since the 960 variant is named for the number of initial positions it allows, it is difficult to answer the worst opening movement of any of those 960 initial positions.  
  > **username_2**: @username_1: I'm assuming he means taking all possible opening positions into account, what's the worst white move in them. That's difficult but questions are allowed to be difficult.  
  
  ---
  
  ## 3 answers
  
  ### Answer by username_4 on 2020-01-28. Score: 42 | Accepted answer
  
  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)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!
  
  > **Comments:**
  > **username_2**: Does Stockfish 10 know about the chess 960 castling rules, and do you call it in a way that it knows this is is 960?  
  > **username_4**: @username_2 Good question! I reckon the evaluation is just considering the position by itself, so without knowledge of castling rules in chess960. Nonetheless, for the purposes of all the showcased positions, the castling makes negligible difference considering that short castles keeps the king on kingside (so still suffering from the weakened light squares induced by `g4`) while long castles is far too many tempi away to be relevant. But for the remaining chess960 positions, it might make a difference in the eval. Should be easy to assess those cases manually once the search is finished.  
  > **username_4**: @user253751 it's a just a word of caution, since the (unexperienced) user might use high ponder times and leave the search on (which can take hours) with the laptop lying on a surface (like carpet) that causes inadequate ventilation.  
  > **username_9**: "engine ponder time given by user (e.g. 1 second)", "To go over all 960 positions takes a lot of time and computational resources." ;)  
  > **username_4**: @username_9 and per position it needs to scan about 20 branch-outs (total legal moves per position), so it's 1 second per *move*, and the number of starting moves varies with the 960 positions. Say 20 starting moves per position, then we have 20 seconds per position, so about 6 hours of runtime for all 960 at 1 second ponder time (which is already quite low per move, going lower the reliability in the evaluation suffer drastically).  
  > **username_9**: @Phonon Ah, missed the factor of 20. Well, you could always reduce the ponder time below 1s.  
  > **username_10**: What's the acquired depth after 1 second?  
  > **username_4**: @username_10 About `20` plies. All these extra details are stored in `info` (see code). For instance, to see the reached depth and count of searched nodes: `print("depth and nodes", info["depth"], info["nodes"])`  
  > **username_3**: I've modified my copy of the script slightly so that it will print the worst move found at the end of the search, and set it running.  See you in six hours…  
  > **username_11**: I am afraid this experiment tells us only that Stockfish's evaluation function penalizes heavily having a hole in front of the king.  
  > **username_4**: @FedericoPoloni e.g. in `BBQRNNKR`: `g4` opens the diagonal for the `a8` bishop, the `b8` bishop eyeing the kingside becomes stronger as a fortress with `g3` can no longer be established, the queen on `c8` can target the unprotected `g4` pawn in one move, while also able to create a deadly mating battery with `b5-Qb7`. The knights are centrally placed which means, despite their slowness, they can reach the white kingside in 2 moves starting from `Nf6-Ng6,` exploiting `f4-h4` holes. Last but not least, `g4` acts as a hook, which can be exploited to open files (e.g. with `h5`) for the rooks.  
  > **username_12**: @Phonon I assume stockfish runs multithreaded when called in this manner? Otherwise there's an obvious optimization that should greatly reduce the time. If it does then the time should be off by approximately the CPU count, except if we are memory bound.  
  > **username_3**: @username_12 On my Linux machine it runs single-threaded.  But even if it was multithreaded, this would change the effective search depth but not the search time.  
  > **username_12**: @username_3 The idea would be to use multiple processes to analyse the initial board states in parallel. You'd still spend the same time on a single one of the 960 board states, but could analyse several at once. Depends which resources we're constrained in, but I'd expect a nice speedup with this.  
  > **username_3**: @username_12 It could be done that way, but not with this script.  You'd need to run multiple instances of the engine ad implement threading; the script only starts one.  
  > **username_12**: @username_3 Yes sure, that's why I'm saying "if it's single threaded there'd be an obvious optimization". You wouldn't want to use threading in Python though, you definitely would want the multiprocessing module here.  
  > **username_13**: Stockfish is definitely capable of playing FRC, but you might need to enable the FRC setting. Also, Stockfish 11 is available now, if you haven't already upgraded you might want to (it's free).  
  
  ---
  
  ### Answer by username_3 on 2020-01-29. Score: 19
  
  Using @Phonon's Python script, I was able to determine that the worst move is 1. g4?? from the BBQRNNKR starting configuration, or 1. b4?? from its mirror image.
  This evaluates to -2.5 in one second of Stockfish search.  Not quite a minor piece, but still a substantial handicap to recover from.
  Why is this position so powerful for the opponent?  The black Queen is able to threaten the advanced pawn as soon as its way is unblocked by 1. … d5; once there, White is in check after move 2!  Then, after 3. … Qxf2 Black is able to fork several of White's pieces on the back rank, possibly including the other Rook.
  This line begins:
  1. …     d5
  2. c3    Qxg4+
  3. Ng3   b6
  4. d4    c5
  
  Additionally the black Bishops have similarly direct lines to the white Kingside Rook and its pawn.  White can defend, but doing so immobilises several pieces and thus loses a lot of development tempo.  He also no longer has a viable pawn structure in front of his King.
  The above is not even Stockfish's preferred line for Black:
  1. …     h5
  2. gxh5  b6
  3. Ng3   Ne6
  4. Ng2   c5
  
  …after which Black has a Rook on a semi-open file, two Bishops pointing at White's King and several pieces (which, as predicted, are pinned down in defensive positions), and a quite acceptable pawn structure and control of the centre.  White has none of these things.
  Extending the analysis time to 5 seconds, the evaluation of this position and its mirror image deepen to -2.79 and -2.81 respectively.  Their nearest rivals are around -2.54 at this level.
  
  > **Comments:**
  > **username_4**: Great work! `BBQRNNKR` is possibly the most harmonious arrangement of pieces to launch a kingside attack and white's `g4` even *further* encourages a kingside battle, a positional disaster!  
  > **username_5**: It is unclear to me what the variation is supposed to be after 1.g4 d5 that leads to 3...Qxf2.  
  > **username_3**: @username_5 That's my amateur analysis which assumes `2. … Qxg4` or something very similar.  Stockfish does a better job, of course.  
  > **username_5**: @username_3 : I wasn't debatting the quality of your analysis, it is just that you don't provide the moves in between and they are not obvious to guess...  
  
  ---
  
  ### Answer by username_6 on 2020-01-28. Score: 7
  
  You said "blunder a piece" or "lose significant advantage", so how about mate since that is even worse? I could only find a few, but here they are.
  Since it takes at least two moves for there to be any interaction between pieces, I am going to start there, and use some logic, but I could still only find a very few.
  First, you have to keep in mind that traditional chess can, and has, been one of the starting positions in actual competitions, so this horrid opening comes to mind first as a logical starting place.
   [FEN ""]
  
   1. g4 e6 2. f4 Qh4#
  
  From that, we know that THE worst openings have to be mates of white in two moves (it still takes three moves for white to mate black). Of course, you can have the famous two-move mate that on the other side too.
  From here, I am just going to use pictures since I am not sure how PGN/FEN works for Chess 960.
  
  Here is another mate with the queen.
  
  Here is another that is similar. I could just move this over a file, but I will not add any more like this with the king just hemmed in by rooks since you get the idea.
  
  > **Comments:**
  > **username_7**: The question *title* says "worst opening move", though the question itself could be interpreted a bit more generally. Regardless of the quality of the opening move, in these examples the *second* move seems to be the blunder, since there are obvious second moves by white which would capture the black queen if black played the check.  
  > **username_6**: @username_7, I realize, but when he added "white can immediately blunder" to the question, and it is clear that that is impossible on the "opening move", I thought it opened the door to the phrase "opening moves", rather than just "opening move".  At the time I was compiling my answer, Phonon had not yet posted, and I did not want to throw away 20+ minutes of work.  I also thought that there might not be any additional answers at the time, so that mine might be better than nothing.  I did upvote his answer.  
  > **username_8**: Your third example is not valid, since the king must start between the rooks in Chess960.  
  
  ---
  
  