rooklift / nibbler

Chess analysis GUI for UCI engines, with extra features for Leela (Lc0) in particular.

Nibbler

"By far the best ICCF analysis tool for Leela." — jhorthos

Nibbler is a real-time analysis GUI for Leela Chess Zero (Lc0), which runs Leela in the background and constantly displays opinions about the current position. You can also compel the engine to evaluate one or more specific moves. Nibbler is loosely inspired by Lizzie and Sabaki.

These days, Nibbler more-or-less works with traditional engines like Stockfish, too. (Ensure MultiPV is 1, Threads (CPU) is set, and Hash is set (more is better), for maximum strength.)

For prebuilt binary releases, see the Releases section. For help, the Discord may be your best bet, or open an issue here.

Features

• Display Leela's top choices graphically.
• Winrate graph.
• Optionally shows Leela statistics like N, P, Q, S, U, V, and WDL for each move.
• UCI searchmoves functionality.
• Automatic full-game analysis.
• Play against Leela from any position.
• Leela self-play from any position.
• PGN loading via menu, clipboard, or drag-and-drop.
• Supports PGN variations of arbitrary depth.
• FEN loading.
• Chess 960.

Installation - Windows / Linux

Some Windows and Linux standalone releases are uploaded to the Releases section from time to time.

Alternatively, it is possible to run Nibbler from source. This requires Electron, but has no other dependencies. If you have Electron installed (e.g. npm install -g electron) you can likely enter the /src directory, then do electron . to run it. Nibbler should be compatible with at least version 5 and above.

You could also build a standalone app. See comments inside the Python script builder.py for info.

Linux install script

Linux users can make use of the following one-liner to install the latest version of Nibbler:

curl -L https://raw.githubusercontent.com/rooklift/nibbler/master/files/scripts/install.sh | bash

Installation - Mac

Mac builds have been made by twoplan and Jac-Zac - the latter is probably more up-to-date.

Advanced engine options

Most people won't need them, but all of Leela's engine options can be set in two ways:

• Leela automatically loads options from a file called lc0.config at startup - see here.
• Nibbler will send UCI options specified in Nibbler's own engines.json file (which you can find via the Dev menu).

Hints and tips

An option to enable the UCI searchmoves feature is available in the Analysis menu. Once enabled, one or more moves can be specified as moves to focus on; Leela will ignore other moves. This is useful when you think Leela isn't giving a certain move enough attention.

Leela forgets much of the evaluation if the position changes. To mitigate this, an option in the Analysis menu allows you to hover over a PV (on the right) and see it play out on the board, without changing the position we're actually analysing. You might prefer to halt Leela while doing this, so that the PVs don't change while you're looking at them.

Leela running out of RAM can be a problem if searches go on too long. You might like to set a reasonable node limit (in the Engine menu), perhaps 10 million or so.

Thanks

Thanks to everyone in Discord and GitHub who's offered advice and suggestions; and thanks to all Lc0 devs and GPU-hours contributors!

The pieces are from Lichess.

Icon design by ciriousjoker based on this.

nibbler's Issues

macOS: paste of fen or epd string

First, let me thank you for implementing new features ("node limit" - like it a lot!) so quick.

I'm struggling to paste epd strings like 6k1/p3q2p/1nr3pB/8/3Q1P2/6P1/PP5P/3R2K1 b - - bm Rd6; into the line under the chess board. After clearing the field and pasting the position with CMD-V nothing appears there.

Or is this feature not ready yet?

Query Only : Depth Parameter

Just wondering what the parameter is that indicates Depth searched ?
I forgot - sorry !!

The app needs an icon

A dock is sad without it.

Nibbler 0.70 Mac crashes immediately

Oops - please ignore - big booboo.

Colors rendered differently

Sorry if this is a very minor nitpick...

From left to right: scid, xboard, nibbler.

I noticed a different tone to the square colors in nibbler, they seem colder.

Backlog of changing positions causing lag on slow setups

When running an extremely slow configuration (i.e. big net on CPU-only), if the position changes very rapidly (e.g. by running through a PGN with an arrow key) a massive delay can be caused.

What happens is, for every position we pass through, we send a go / stop cycle to the engine, which then is obliged to at least look at the position and return a bestmove. On slow setups this can cause a backlog of positions.

This has presumably always been the case, I never tried it until now.

draw_movelist() is too slow for big PGN

To fix this, what needs to happen?

The HTML needs to not be redrawn when the tree hasn't changed and the currently highlighted (i.e. white-coloured) line hasn't changed. Rather, the old and new highlighted (blue/yellow) moves need to have their classes changed, and that's all.

Thus we'll need to compare the new vs old end-of-line nodes as well as checking the total_tree_changes. If there's no actual change, just change the HTML classes.

This will involve finding the spans in the HTML via their unique id. For this to be pleasant, it would be preferable if each clicker had a one-to-one mapping to the nodes, rather than the current many-to-one. That should be easily accomplished in write_tree2().

Can't open Nibbler with double click in Linux

I just can open it with ./nibbler.
Please tell me how to open Nibbler with double click.

macOS: config.json not found in nibbler directory

With version 0.5.1, config.json is not found in the nibbler directory any more. This worked well until nibbler version 0.5.0rc1 on my Mac.

There pops up this error message:
Couldn't find config file. Looked at: /usr/local/lib/node_modules/electron/dist/Electron.app/Contents/Frameworks/Electron\ Helper.app/Contents/MacOS/config.json

And in the terminal:

Main process couldn't find config file. Looked at:
   /usr/local/lib/node_modules/electron/dist/Electron.app/Contents/MacOS/config.json

Had to copy my config.json file into both directories to avoid the error and to run nibbler. Maybe it is related to how main.js gets invoked? My shell script looks like this:

#!/bin/bash
export PATH="/usr/local/bin:$PATH"
cd /Users/max/chess/Lc0/nibbler-0.5.1
electron .

% character in path causes Nibbler to fail

Running Nibbler in a path with % is seen not to work, while ' was fixed today...

Also, examine visual flicker when path contains a '

Maybe build with 6.0.3 since 6 seems to mostly avoid the flicker.

Changing Windows resolution

There's something off about the results of changing Windows' resolution. I'll need to investigate further....

Moves animation?

Would it be too difficult to add moves animation? It's nice when browsing games.

Nibbler GUI only for LCZero?

Hello fohristiwhirl,

can you enhance Nibbler in a way that other UCI-compatible- chess engines http://download.shredderchess.com/div/uci.zip can be embedded into this graphical user interface, too?

Regards,

White text on white background in Linux for Electron 8

There's a report that, under Arch Linux and Electron 8, menu items are white text on white background.

(Can anyone else confirm / deny?)

Code Audit

In which we read through the codebase.

• function XY(s)
• function S(x, y)
• function InfoVal(s, key)
• function InfoPV(s)
• function CompareArrays(a, b)
• function ArrayStartsWith(a, b)
• function ArrayIncludes(a, b)
• function OppositeColour(s)
• function ReplaceAll(s, search, replace)
• function SafeString(s)
• function Log(s)
• function New2DArray(width, height)
• function CanvasCoords(x, y)
• function Point(a, b)
• const position_prototype
• move: function(s)
• illegal: function(s)
• sequence_illegal: function(moves)
• los: function(x1, y1, x2, y2)
• attacked: function(target, my_colour)
• line_attack: function(target, step_x, step_y, my_colour)
• find: function(piece, startx, starty, endx, endy)
• parse_pgn: function(s)
• piece: function(point)
• is_white: function(point)
• is_black: function(point)
• is_empty: function(point)
• colour: function(point)
• same_colour: function(point1, point2)
• nice_string: function(s)
• next_number_string: function()
• fen: function()
• copy: function()
• function NewPosition(state = null, active = "w", castling = "", enpassant = null, halfmove = 0, fullmove = 1)
• function LoadFEN(fen)
• const node_prototype
• make_move: function(s, force_new_node)
• history: function()
• future_history: function()
• get_root: function()
• get_end: function()
• get_board: function()
• promote_to_main_line: function()
• fen: function()
• nice_move: function()
• token: function()
• detach: function()
• function NewNode(parent, move)
• function NewTree(startpos)
• function DestroyTree(node)
• function __destroy_tree(node)
• function split_buffer(buf)
• function new_byte_pusher(size)
• function new_pgn_record()
• function PreParsePGN(buf)
• function LoadPGNRecord(o)
• function SavePGN(filename, node)
• function PGNToClipboard(node)
• function make_movetext(node)
• function TokenNodeConnections(node)
• function new_string_node_connector()
• function write_tree(node, connector, skip_self_flag, force_number_string)
• function get_movelist_highlight()
• function fix_scrollbar_position(node)
• function NewMovelistHander()
• handler.draw = function(node)
• handler.draw_lazy = function(node)
• handler.draw_hard = function(node)
• handler.redraw_node = function(node)
• handler.node_from_click = function(event)
• function NewInfoHandler()
• ih.clear = function()
• ih.err_receive = function(s)
• ih.receive = function(s, board)
• ih.sorted = function()
• ih.must_draw_infobox = function()
• ih.draw_infobox = function(mouse_point, active_square, leela_should_go, active_colour, searchmoves)
• ih.moves_from_click = function(event)
• ih.searchmove_from_click = function(event)
• ih.draw_arrows = function()
• const info_prototype
• nice_pv: function()
• value: function()
• value_string: function(dp, force_0_100_scale)
• function new_info(board, move)
• function NewEngine()
• eng.send = function(msg)
• eng.setoption = function(name, value)
• eng.sync = function()
• eng.setup = function(engine_path, args, receive_fn, err_receive_fn, log_info_lines)
• function NewRenderer()
• renderer.position_changed = function(new_game_flag)
• renderer.set_versus = function(s)
• renderer.move = function(s)
• renderer.play_info_index = function(n)
• renderer.prev = function()
• renderer.next = function()
• renderer.goto_root = function()
• renderer.goto_end = function()
• renderer.return_to_main_line = function()
• renderer.promote_to_main_line = function()
• renderer.delete_move = function()
• renderer.load_fen = function(s)
• renderer.new_game = function()
• renderer.pgn_to_clipboard = function()
• renderer.save = function(filename)
• renderer.open = function(filename)
• renderer.load_pgn_from_string = function(s)
• renderer.load_pgn_buffer = function(buf)
• renderer.load_pgn_object = function(o)
• renderer.show_pgn_chooser = function()
• renderer.hide_pgn_chooser = function()
• renderer.pgnchooser_click = function(event)
• renderer.validate_pgn = function(filename)
• renderer.leela_should_go = function()
• renderer.receive = function(s)
• renderer.err_receive = function(s)
• renderer.go_or_halt = function(new_game_flag)
• renderer.__halt = function()
• renderer.__go = function(new_game_flag)
• renderer.validate_searchmoves = function()
• renderer.reset_leela_cache = function()
• renderer.switch_weights = function(filename)
• renderer.toggle_flip = function()
• renderer.escape = function()
• renderer.toggle_debug_css = function()
• renderer.set_active_square = function(new_point)
• renderer.mouse_point = function()
• renderer.boardfriends_click = function(event)
• renderer.infobox_click = function(event)
• renderer.maybe_searchmove_click = function(event)
• renderer.movelist_click = function(event)
• renderer.show_promotiontable = function(partial_move)
• renderer.hide_promotiontable = function()
• renderer.handle_drop = function(event)
• renderer.console = function(...args)
• renderer.toggle = function(option)
• renderer.draw_friendlies_in_table = function()
• renderer.draw_enemies_in_canvas = function()
• renderer.draw = function()
• renderer.draw_loop = function()
• 99_start.js
• modules
• main.js

Nibbler doesn't recognise Syzygy's rtbz, rtbw files as DTZ and WDL files.

I'm trying to integrate Syzygy endgame tablebase into Nibbler using SyzygyPath. I have already generated all the Syzygy files but when I try to call them using "SyzygyPath": "C:\Lc0 folder\Syzygy folder\" it says it has found 0 WDL files 0 DTM files and 0 DTZ files. My files are .rtbz and .rtbw files which made me think they're the wrong file type but according to Syzygy's GitHub page .rtbz is DTZ files and .rtbw is WDL files. Now I've hit a dead-end. It would be useful to know exactly what files nibbler is looking for but I don't want to search into nibbler and Lc0's base code.

Out of sync issue

MadMike1234 writes (here):

V0.25 with Nibbler v1.2.4
Nibbler working fine with Stockfish but with any leela doesnt work anymore. I used CUDA version.

It was working 0.25 rc1 with nibbler 1.1.7 but I deleted because I wanted newest version and after that no any combination working.. I tried lot of different leelas nibblers but all the time the same "OUT of SYNC". I have Nvidia 750 .. i7 16GB.. Windows 7 x64

And yes, leela benchmark working well...

Is it possible that either Nibbler or Leela put something in the registry base that could cause this problem?

And also:

Also, I cant add Leela under Fritz, maybe that is connected.

Nibbler on iPadOS

Is Nibbler ready to be used on iPadOS?
And iPad Pro 3 and 4?
With the iPadOS it should be even possible to use the magic mouse!, the magic trackpad and also the bluetooth keyboard from an iMac or Mac Pro. Also it's possible to see the display on a big monitor or tv. The handling is also superb. And programming is now much much easier and faster.

Best regards

Nibbler GUI: separate path to endgame tablebases

Hello fohristiwhirl,
other graphical interfaces like Arena www.playwitharena.de , ChessGUI http://www.chess.hylogic.de/ or WinBoard AA Beta http://hgm.nubati.net/WinBoard-AA.zip possess an extra path to egtbs
cf. http://computer-chess.org/doku.php?id=computer_chess:wiki:lists:egtbs_list Especially Gaviota, Nalimov and Syzygy are very common
Would such a feature under "Engine" for Nibbler GUI be an improvement (>upcoming editions)?
Regards,

Max lines display?

After updating from 0.53 to 1.01 rc2 and now 1.02 it seems the previous option for controlling the displayed max number of analysis lines does not work anymore. (pasted from old config to new config)

It seems there is no option anymore for this at all. Also just using 'Top move only' seems not work here. Is there another way to change the display from 20 max lines?

Drag and drop is broken if the board is flipped.

As title. Looking at it now...

Castling in Chess 960

Nibbler doesn't recognize castling in chess 960 and you can't tweak the FEN to allow it.

macOS Nibbler

Hellooo !
Just wondering if the macOS dev is on hiatus (indefinitely) ?
The Windows version works just fine.

CSS needs improved

The general layout of Nibbler is like this:

But I struggle to get the CSS right. Especially, the bottom of the graphbox needs to line up with the bottom of the board - currently this is done by using JS to calculate the correct height of the infobox and setting it exactly, so that the graph below it lines up "by magic".

Is there no better way?

0.5.2-rc2: white piece size

My config.json

"width": 1280,
"height": 760,
"board_size": 520,
"mainline_height": 110,

With version 0.5.2-rc2 the white pieces now remain to big in size. The black pieces are scaled correct. Version 0.5.1 was OK.

macOS: minimize window closes Nibbler

When you try to minimize (with the yellow button on top left) the Nibbler window into the macOS dock, the program gets closed instead.

You used the standard shortcut for "minimize to dock" (CMD-M) for "Make this the main line".

Low quality compositing in the canvas

Low quality compositing seems to happen with the default pieces when the board is at its smallest (480) and the canvas is being drawn to.

Pieces showing only on non-playing side

As the title says.
Screenshot: http://prntscr.com/otiu8d
(I changed pieces set but the problems shows up also with default set.)
Windows 10 Home
Nibbler 1.0.9

Draw board of the analysis step for each line

thanks a lot for this great application..
I'm search most of GUI only chess.com draw a board for each step in the analysis lines..
I will be great to all popup board show how the steps will be ... it will be better for the new learner to follow the steps than gust reading the line of codes..

Todo / suggestions list

Note that this is just for my own benefit, I'm not really asking for help. Also, some things in the second section I don't necessarily agree with.

My own thoughts

• Work better on high resolutions (sort of done: everything needed can be configured).
• At some point I'll need a legal move generator. How hard can it be?
• Better CSS layout, I need to learn flex.
• Proper persistent preferences.
• PGN parser must handle variations that repeat the original move (e.g. 1. d4 (d4 Nf3 etc)
• Performance improvements when handling large trees - the problem is the regeneration of the entire move list.
• But until then, mitigation for all types of user input that can lag on large trees.
• Delete node.
• Automatically move the scroll bar on the main line if needed (e.g. this).
• When moving manually, the ability to underpromote (already works for Leela moves).
• Better visualisation of the internal move tree.
• Read and write PGN trees (RAV format).
• PV display as a board?
• Winrate graph.
• Pawn promotion moves should be displayed the colour of the best one. Maybe adjust the sort.
• End of game detection.
• Better PGN saving (e.g. player names if known, etc)
• Properly support engines that don't accept UCI_Chess960
• Initial isready / readyok cycle

User comments

• Scroll bar for the infobox. Don't cap number of lines.
• There's some issue in Linux with the file open dialogs, they open behind the main window.
• Drag and drop functionality.
• Show winrate on arrowheads.
• A 'threats' command, where it flips side to move to show 'threats', kinda like making a pass move, which is often very useful in analysis.
• Hover over arrow/arrow head highlights the PV.
• Play out the PV when you hover over a move.
• Hover over piece prioritizes their move arrows (sets them visually 'on top'), or maybe even turns off every other arrow after a small delay? This would be useful for when the move doesn't show under the current Move display setting.
• Arrow alpha. (not really needed)
• If FEN wasn't changed, don't reset analysis or PGN.
• Show speed and total nodecount somewhere.
• Mousewheel scrolls through move list.
• Key rebinding? ctrl-H is a tough reach. (too many in use already)
• Return to main line even when not in a PGN.
• Show opening names.
• Search from openings by name to immediately set up position.
• Restart engine in app to get new weights/cpuct/whatever without needing to restart the application.
• Load PGN from clipboard.
• More useful info in the PGN chooser.
• It should allow the engine path and weights to be configured by the GUI.
• You could look for the engine in the system path. (a bit tricky, no real need)
• Keyboard input for the moves.
• Node limit for searches.
• Option for decimal places.
• Q-U ordering (showing the best move if we are pessimistic). (meaning of the maths unclear)
• Live URL's such as Hiarcs Chess Explorer has.
• Searchmove functionality... force Leela to ignore her top move and focus on the second one.
• Coordinates.
• Option to show raw Q.
• Alignment of N, P, U in the list.
• Sort list by Q, N, P, U options.
• Highlight from list to board (currently board to list only).
• After reaching the node limit, play the move.
• Optionally, scores from White's POV
• Infobox to clipboard
• Make an option to have a new line between the PV and the listing of values
• Change-in-winrate graph
• Moves animation
• Should display PGN comments
• Save auto-eval to comments
• Lock eval position
• WDL graph
• Time control
• Board editor
• Edit PGN comments

openDialog error

I'm getting this error since 1.2.1, it works well in 1.2.0.

Operating system: Ubuntu 20.04
Running from source
Version of Nibbler: 1.2.1
Electron: 8.2.3

Make a Mac OS build

This is a thing I should do. @twoplan, if I made a build would you be willing to test it?

The movelist is too slow for big trees.

The problem is the draw_hard() method. I should do something about this.

Lc0 should spawn with cwd set to its own directory

For several reasons I always unpack the weights files I really plan to use with LC0 and rename them (ID#).
Nibbler does not like this and reports it cannot read the weights file.
I confirmed that it reads the still packed, but renamed weights file.

(LC0 itself has no problems with either of them)

Blog Post draft

Does the world need another Chess GUI? Some people say no, but they don't have very many Chess GUIs, do they?

I'm the author of Nibbler, the first Chess GUI designed specifically for Lc0, and inspired by the excellent Lizzie Go interface. Although Nibbler is a work in progress, it's very usable, and has received a lot of favourable comment.

Being designed specifically for Lc0 means it can use the sort of information Leela provides that other engines don't (or can't). For example, Leela is always giving opinions about multiple different moves, and so Nibbler shows several possibilities graphically.

For the more technically minded Leela user, Nibbler also provides Nodes, Policy, and Uncertainty statistics.

Prebuilt binary releases are here.

Nibbler 0.66 GUI for Windows with LC0 v0.21.2 Blas

Hello fohristiwhirl,
after downloading https://github.com/LeelaChessZero/lc0/releases/download/v0.21.2/lc0-v0.21.2-windows-blas.zip I extracted all files in the same directory where Nibbler066.exe (application) is located. Then a message is visible to rename necessarily config.example.json into config.json. After doing this and invoke Nibbler.exe > error, that no config.json file can be found. Is a pre-configurated weights file on your website available at all and why does your application "Nibbler" does not contain the the current LC0 packages including a redirection link to https://lczero.org/networks/ ? In my opinion the original weightsfile is too long, is is possible to replace this whole alphanumeric order by an abreviation e.g. blas.xyz too?
The contribution http://blog.lczero.org/2018/09/guide-setting-up-leela-on-chess-gui.html seems to be interesting - my first GUI for running LC0 was ChessBase graphical interface (Fritz GUI).

Regards,

How to use two or more GPUs

How do i analyse with two cards. I tried adjusting settings but wrong syntax.

Alternate draw method

Consider:

• Show nothing in the boardfriends table (which must still exist).
• Show everything in the canvas.
• Have a drag image for dragging.

https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer/setDragImage

• Check any changes work with flip.
• Check the promotion table still works.
• Check the fantasy board still works.

Also, can likely delete the 2nd canvas and just use one.

Version 1.01rc2 on macOS

Small feedback about version 1.01rc2 on macOS.

• started Nibbler with electron . from the terminal (without any config.json file)
• selected lc0 engine and weights, changed some sizes and nodes
• closed nibbler and got this message at the terminal:

$ electron .
objc[4281]: Class FIFinderSyncExtensionHost is implemented in both /System/Library/PrivateFrameworks/FinderKit.framework/Versions/A/FinderKit (0x7fff8daadcd0) and /System/Library/PrivateFrameworks/FileProvider.framework/OverrideBundles/FinderSyncCollaborationFileProviderOverride.bundle/Contents/MacOS/FinderSyncCollaborationFileProviderOverride (0x113fa7cd8). One of the two will be used. Which one is undefined.

After the next start, this message did not show up again. Great, Nibbler remembered all previous made changes!

Looks like ~/Library/Application Support/Nibbler with it's config.json works for you!

Castling is not correctly reported with Lc0 release 0.23+

Problem

Castling moves are not properly shown by the Nibbler GUI for Lc0 0.23+. I would guess that this is because the Lc0 engine has changed the info string output for FRC.

Reproduction

• Open Nibbler 1.1.1
• Play the following moves: 1. e4 e5 2. Nf3 Nf6 3. Bc4 Bc5 *
• Press CTRL-g for "go"

Observations

Nibbler GUI

• lc0 0.22 -- castling move (O-O) is shown as the second best move (good)
• lc0 0.23.1 -- castling move (O-O) is shown in the bottom of the move list without stats (bad)

From Nibbler log / lc0 0.22

< info string e1g1  (103 ) N:       5 (+ 0) (P:  3.29%) (Q:  0.08298) (D:  0.000) (U: 0.64388) (Q+U:  0.72685) (V:  0.1383) 

From Nibbler log / lc0 0.23.1

< info string e1h1  (103 ) N:       5 (+ 0) (P:  3.29%) (Q:  0.08298) (D:  0.000) (U: 0.62544) (Q+U:  0.70842) (V:  0.1383) 
... Nibbler: invalid move received!: e1h1

Test environment

• Gentoo Linux
• Prebuilt Nibbler 1.1.1
• Locally built Lc0 0.22 and 0.23.1
• Net weights: 42810

Workaround

Use Lc0 0.22

Problem with FEN (to strict parser)

Window 10
Prebuilt 1.1.1

Problem is with FEN from Position Trainer:
r1bqkbnr/pp1ppppp/2n5/2p5/2P1PP2/8/PP1P2PP/RNBQKBNR b KQkq -

Chessdb:
r1bqkbnr/pp1ppppp/2n5/2p5/2P1PP2/8/PP1P2PP/RNBQKBNR/ b KQkq - 0 0

Problem is because parser is to strict. I programmed parser in Python for FEN which accept all syntaxes.

Nibbler crashing when Leela runs out of RAM

Report from Windows:

Nibbler has been known to crash when Leela runs out of memory and starts paging. This happened on a system with 64 GB of RAM, some time before 675 million nodes.

Of course Leela running out of RAM is not Nibbler's fault, but why are we crashing?

Support for Chess960

Leela support FRC castling now but nets for FRC is yet to be trained.

After clicking and dragging a piece, the square beneath it flashes black

"after clicking and dragging a piece, the square beneath it flashes black"

-- reports from Linux

Tiny display glitch with Lc0 0.23.x on macOS

Lc0 version 0.23.x shows its logo in red. Nibbler doesn't interpret (or ignore) these esc-sequences for the terminal on macOS and the output gets a little puzzled.

Nibbler 0.77 GUI win64 problem including 0.21.2 Lc0

Hello fohristiwhirl,

I downloaded and extracted https://github.com/LeelaChessZero/lc0/releases/download/v0.21.2/lc0-v0.21.2-windows-blas.zip + https://lc0.org/ld2 and renamed just the last file into weights6-swa-20000 (because my pc does not possess a GPU)

That works with the external graphical interfaces Arena www.playwitharena.de and WinBoard AA beta http://hgm.nubati.net/WinBoard-AA.zip of course, but after launching Nibbler 0.77 exists an error message: "couldn´t spawn process - check the paths in the comfig file and use absolute paths."

The config.example.json is unchanged.
What is the suggestion in this case to run Lc0 21.2 with Nibbler GUI 0.77, please?

Regards,

0.7.8: without config file

Should Nibbler find lc0 and the weights by itself? At my mac this part didn't work.

After selecting the engine with Find engine... Lc0 starts with this error message

and loads the tablebases, but not the weights! Which seems strange, as both path names are in my lc0.config. And --backend=blas is there too.

Loading weights manually worked.

Save config.json... should move the focus to the Nibbler directory and name it correct. It points to the last directory, from where the weights was loaded.

After the next start of Nibbler (with the newly written config.json) the --backend error comes again, but all works as expected.

Issue for posting screenshots

Draw notification

I'm posting a few questions on this day and I just realised I didn't say what software config. I am using
Win 10 Pro
Nibbler 1.1.3 / Electron 5.0.13
Lc0 v0.23.2

There's no immediate sign that there's a draw. That might not be as bad for a stalemate but for 3 fold repetition especially for the non-obvious ones, and 50 moves no capture no push limit though you can see it from the FEN.

Similar issues for winning especially because it displays + in PGN instead of #.

Feature request: network name in the About-window

Sometimes I have difficulties to remember which network gets used for analysis.

Could you add the name of the loaded weights file to the About-window?