Stockfish.js

https://github.com/nmrugg/stockfish.js

by tosh • 4 years ago

135 32 4 years ago

github.com

tiffanyh3• 4 years ago

How does this compare to stockfish-nnue.wasm [0] which is used on Lichess.org [1]

[0] https://github.com/hi-ogawa/Stockfish

[1] https://lichess.org/source

jokethrowaway• 4 years ago

NNUE is heavier but considered better

perihelions4• 4 years ago

That's not the distinction here: these are two different Stockfish JS projects, both of which port the NNUE version.

perihelions4• 4 years ago

A related fork [0] powers the web-based tool on Lichess [1]. It's a notable example of WASM in widespread use (I believe it's WASM-by-default on every browser now).

[0] https://github.com/hi-ogawa/Stockfish

[1] https://lichess.org/analysis (in the top-right corner: "Stockfish 14+ NNUE in local browser")

(edit: fixed link to the correct fork)

tiffanyh3• 4 years ago

FYI - the version you linked to is the “Slower fallback versions of Stockfish for browsers (C++, WebAssembly, JavaScript)” according to Lichess.

https://lichess.org/source

EDIT: nevermind, looks like you changed the link.

perihelions4• 4 years ago

Thanks, corrected link!

WithinReason3• 4 years ago

I wonder why Lichess doesn't use multithreading, it was working in a previous version. I mean Brave can use 2 threads but I've seen 8/16 max threads before.

tiffanyh3• 4 years ago

Lichess doesn’t?

There’s reference to thread support in the library documentation.

https://github.com/hi-ogawa/Stockfish#threads

JacobLinney• 4 years ago

Lichess on chrome let's me use however many logical processors I have. For whatever reason I can only get a single thread on Firefox.

I'm not sure why either, because a while back I could use how ever many threads I wanted on Firefox.

archseer• 4 years ago

You can configure how many CPUs and memory to use under settings

tromp• 4 years ago

Chess engine performance is dependent on fast 64-bit integer operations. How does this implementation deal with javascript ints being limited to 32-bits? Is emscriptem somehow able to generate code using WASM's 64 bit ints?

threatofrain• 4 years ago

I believe JS has access to 64-bit.

petilon• 4 years ago

JS has access to 64-bit floating point, not int.

Kubuxu• 4 years ago

It uses WASM which has 64bit integers.

brrrrrm• 4 years ago

^ this. Ref: https://webassembly.github.io/spec/core/syntax/types.html#sy...

johndough• 4 years ago

Seems to be true. https://mbebenita.github.io/WasmExplorer/ emits i64.mul which is compiled to imul rax, rdi by firefox for the following code snippet:

    #include <stdint.h>
    
    uint64_t multiply(uint64_t a, uint64_t b){
        return a * b;
    }

Cthulhu_• 4 years ago

Probably using JS's BigInt https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe...

tediousdemise• 4 years ago

Opened a random cpp source file, saw goto statements, and noped out of there real quick.

Cpoll• 4 years ago

https://github.com/nmrugg/stockfish.js/search?q=goto

Five occurrences of goto, for anyone that's curious. The code is pretty easy to read, good variable names, some explanatory comments. The gotos don't make spaghetti. I'm inclined to think the writers knew what they were doing, though goto offends my sensibilities as much as anyone.

Could anyone with more experience explain the pattern? Why gotos for control flow along with >thousand line functions?

mhink• 4 years ago

Interesting. I was looking at the algorithm in evaluate.cpp [0] and it seems to be the case that the control flow is pretty much just an alternative to if-statements... which, personally, I find to be more readable than it'd otherwise be if it were heavily nested. I'm open to arguments otherwise, though.

Consider two alternatives (written in pseudo-Javascript, I guess):

    let xyz = 0;
    if (!condition1) {
      doSomething();
      xyz = getValueSomehow();
      
      if (!condition2) {
        doSomethingElse();
        xyz += getSomeOtherValueSomehow();
      }
    }
    finishUpBusinessLogic();
    return xyz;

that seems much less readable than:

    let xyz = 0;
    if (condition1)
      goto done;

    doSomething();
    xyz = getValueSomehow();

    if (condition2)
      goto done;

    doSomethingElse();
    xyz += getSomeOtherValueSomehow();

    done:
    finishUpBusinessLogic();
    return xyz;

0: https://github.com/nmrugg/stockfish.js/blob/d96c98872103c60b...

daniel-thompson• 4 years ago

There are a total of 5 gotos in the codebase¹. That's not bad for a chess engine which is heavily optimized for runtime performance above all other considerations.

¹ https://github.com/nmrugg/stockfish.js/search?q=goto&type=

Koffiepoeder• 4 years ago

Thinking in absolutes is never a good idea when it comes to a subjective matter (in this case: code style).

goto statements can and sometimes do have good use cases, for instance finite state machines and error handling.

It's not because something is generally not a recommended construct that you should never consider using it: in my opinion you should use all the tools you have in your belt and consider each use case separately to determine usefulness, practicality and other criteria applicable to your project.

ryeights• 4 years ago

IMO, although it is not used in this codebase, the “goto error” pattern for error handling is far more elegant and readable than any non-goto-using alternatives. Goto can have its place sometimes.

ComputerGuru• 4 years ago

Your loss.

eternityforest• 4 years ago

I can still appreciate it no matter how bad the code quality is, because it works amazingly well and I don't have to maintain it myself.

If it works for the devs, then it's fine. Chess engines have a fairly low attack surface, all you have is moving pieces. Security is probably fine. Performance and strength are clearly fine.

Stockfish.js

Related Stories