FRC in CECP

[lucasart]

Code: Select all

(CCRL or GURL single core)
Rating:         Class
> 3100          A1
2900-3100       A2
2700-2900       A3
2500-2700       B1
2300-2500       B2

XB only list - only the engines with at least 'B2' strength (disregarded a few hundreds weaker ones)
(note: to my best knowledge - please report errors for correction in the XB/UCI chronology, if you find some)

Code: Select all

Name            Last Release    RC      Src     PL      Prot
Amateur         2016-10         B2      -       C       XB
Amundsen        2009-04         B2      yes     C       XB
Amy             2004-03         B2      yes     C       XB
Anatoli         2008-04         B1      -       Pascal  XB
Ant (& Gi-Ant)  2010-12         B2      -       C++     XB
Averno          2005-03         B2      -       C++     XB
Bearded         2012-03         B2      -               XB
Betsy           2003-04         B2      -       C       XB
Bringer (Der)   2001-12         B2      -       C++     XB
Bruja           2010-05         B2      -       C++     XB
BugChess2       2011-04         A3      -       C++     XB
Butcher         2012-04         B2      -       C       XB
Caligula#       2019-03         B1      -               XB
Chezzz          2003-02         B2      -       C++     XB
Chronos         2010-06         A3      -       C++     XB
Comet           2005-05         B2      -       C       XB
Crafty          2020-02         A2      yes     C       XB
Cyberpagno      2016-06         B2      -       C       XB
DanChess        2005-02         B1      -       C++     XB
Darmenios       2010-10         B2      -       C++     XB
Dimitri         2019-10         B1*     -               XB
Dirty           2018-11         A2*     -       C++     XB
Djinn           2014-04         A3      -       C++     XB
Dorky           2018-08         B2      -       C++     XB
Drosophila      2020-03         B2*     yes     C       XB
Eeyore          2010-11         B2      -               XB
ETChess         2008-01         B1      -               XB
EveAnn          2017-04         B2      -       Pascal  XB
EXchess         2017-02         A2      yes     C++     XB
Francesca       2020-06         A3*     -       C       XB
FrankWalter     2019-05         B2      yes     Java    XB
Ghost           2017-05         B2      -       C++     XB
Giraffe         2016-11         B2*     yes     C++     XB
Gosu            2006-10         B2      -               XB
GreenLightChess 2004-03         B1      -       C++     XB
Gromit3         2002-01         B2      -       C++     XB
Horizon         2008-02         B2      -       C       XB
JikChess        2015-10         B1      -       C++     XB
Joker           2007-12         B2      -       C       XB
Jumbo           2019-07         B1*     -       C++     XB
KingOfKings     2004-09         B2      -       C++     XB
Kiwi            2005-11         B2      yes     C++     XB
KnightDreamer   2004-07         B2      -               XB
Matacz          2008-09         B2      -               XB
Movei           2007-08         B1      -       C       XB
Myrddin         2015-01         B2      -               XB
nanoSzachy      2015-10         B1      -               XB
Nebiyu          2020-01         B2*     yes     C++     XB
Nemeton         2019-05         B2*     yes     Pascal  XB
Nimzo           1999-11         B1      -               XB
NoraGrace       2014-11         B1      yes     C#      XB
Olithink        2020-12         A3      yes     C       XB
Petir           2007-09         B1      -               XB
Phalanx         2016-05         B1*     yes     C       XB
pikoSzachy      2015-10         B2      -               XB
Popochin#       2018-04         B2      -               XB
Porucnik        2009-01         B2      yes     C++     XB
Postmodernist   2006-06         B2      -               XB
ProDeo          2020-11         A3      -               XB
Prophet         2007-02         B2*     yes     C       XB
Prophet3        2019-06         B2*     yes     C++     XB
Pseudo          2005-04         B1      -       C       XB
Quark           2004-07         B2      -       C++     XB
RattateChess    2010-02         B2      -               XB
Resp            2010-12         B2      yes     C++     XB
Rodin           2016-02         B1      -       C       XB
RomiChess       2017-12         B2      -       C       XB
Sage            2008-05         B2      -               XB
Sloppy#         2010-07         B1      yes     C       XB
SpiderChess     2007-06         B2      -       Pascal  XB
TheCrazyBishop  2004-07         B2      -       C++     XB
TheKing         2007-10         B1      -       C       XB
Thinker*        2009-03         A2      -       C++     XB
Thor's Hammer   2010-10         B2      yes     C++     XB
TJChess         2016-09         B2      -               XB
Trace#          2006-11         B2      -       C       XB
Typhoon         2008-08         B2      yes     C       XB
Tytan           2007-07         B2      -       C++     XB
Waxman          2018-01         B2      -       C       XB
WChess          2018-05         B2      -       C       XB
Xpdnt           2009-10         B2      yes     C       XB
Zarkov          2016-06         B1      -       C       XB

Interesting list.

If we exclude dead engines, defined as 3y without update, we're left with:

• A1: 0 engines
• A2: 2 engines (Crafty, Dirty)
• A3: 3 engines (Franscesca, Olithink, ProDeo)
• B1: 3 engines (Catigula, Dimitri, Jumbo)

To put this in perspective, looking at http://fastgm.de/60-0.60.html, the top CECP-only engines are #64 (Dirty) and #65 (Crafty).

[Pio]

Code: Select all

(CCRL or GURL single core)
Rating:         Class
> 3100          A1
2900-3100       A2
2700-2900       A3
2500-2700       B1
2300-2500       B2

XB only list - only the engines with at least 'B2' strength (disregarded a few hundreds weaker ones)
(note: to my best knowledge - please report errors for correction in the XB/UCI chronology, if you find some)

Code: Select all

Name            Last Release    RC      Src     PL      Prot
Amateur         2016-10         B2      -       C       XB
Amundsen        2009-04         B2      yes     C       XB
Amy             2004-03         B2      yes     C       XB
Anatoli         2008-04         B1      -       Pascal  XB
Ant (& Gi-Ant)  2010-12         B2      -       C++     XB
Averno          2005-03         B2      -       C++     XB
Bearded         2012-03         B2      -               XB
Betsy           2003-04         B2      -       C       XB
Bringer (Der)   2001-12         B2      -       C++     XB
Bruja           2010-05         B2      -       C++     XB
BugChess2       2011-04         A3      -       C++     XB
Butcher         2012-04         B2      -       C       XB
Caligula#       2019-03         B1      -               XB
Chezzz          2003-02         B2      -       C++     XB
Chronos         2010-06         A3      -       C++     XB
Comet           2005-05         B2      -       C       XB
Crafty          2020-02         A2      yes     C       XB
Cyberpagno      2016-06         B2      -       C       XB
DanChess        2005-02         B1      -       C++     XB
Darmenios       2010-10         B2      -       C++     XB
Dimitri         2019-10         B1*     -               XB
Dirty           2018-11         A2*     -       C++     XB
Djinn           2014-04         A3      -       C++     XB
Dorky           2018-08         B2      -       C++     XB
Drosophila      2020-03         B2*     yes     C       XB
Eeyore          2010-11         B2      -               XB
ETChess         2008-01         B1      -               XB
EveAnn          2017-04         B2      -       Pascal  XB
EXchess         2017-02         A2      yes     C++     XB
Francesca       2020-06         A3*     -       C       XB
FrankWalter     2019-05         B2      yes     Java    XB
Ghost           2017-05         B2      -       C++     XB
Giraffe         2016-11         B2*     yes     C++     XB
Gosu            2006-10         B2      -               XB
GreenLightChess 2004-03         B1      -       C++     XB
Gromit3         2002-01         B2      -       C++     XB
Horizon         2008-02         B2      -       C       XB
JikChess        2015-10         B1      -       C++     XB
Joker           2007-12         B2      -       C       XB
Jumbo           2019-07         B1*     -       C++     XB
KingOfKings     2004-09         B2      -       C++     XB
Kiwi            2005-11         B2      yes     C++     XB
KnightDreamer   2004-07         B2      -               XB
Matacz          2008-09         B2      -               XB
Movei           2007-08         B1      -       C       XB
Myrddin         2015-01         B2      -               XB
nanoSzachy      2015-10         B1      -               XB
Nebiyu          2020-01         B2*     yes     C++     XB
Nemeton         2019-05         B2*     yes     Pascal  XB
Nimzo           1999-11         B1      -               XB
NoraGrace       2014-11         B1      yes     C#      XB
Olithink        2020-12         A3      yes     C       XB
Petir           2007-09         B1      -               XB
Phalanx         2016-05         B1*     yes     C       XB
pikoSzachy      2015-10         B2      -               XB
Popochin#       2018-04         B2      -               XB
Porucnik        2009-01         B2      yes     C++     XB
Postmodernist   2006-06         B2      -               XB
ProDeo          2020-11         A3      -               XB
Prophet         2007-02         B2*     yes     C       XB
Prophet3        2019-06         B2*     yes     C++     XB
Pseudo          2005-04         B1      -       C       XB
Quark           2004-07         B2      -       C++     XB
RattateChess    2010-02         B2      -               XB
Resp            2010-12         B2      yes     C++     XB
Rodin           2016-02         B1      -       C       XB
RomiChess       2017-12         B2      -       C       XB
Sage            2008-05         B2      -               XB
Sloppy#         2010-07         B1      yes     C       XB
SpiderChess     2007-06         B2      -       Pascal  XB
TheCrazyBishop  2004-07         B2      -       C++     XB
TheKing         2007-10         B1      -       C       XB
Thinker*        2009-03         A2      -       C++     XB
Thor's Hammer   2010-10         B2      yes     C++     XB
TJChess         2016-09         B2      -               XB
Trace#          2006-11         B2      -       C       XB
Typhoon         2008-08         B2      yes     C       XB
Tytan           2007-07         B2      -       C++     XB
Waxman          2018-01         B2      -       C       XB
WChess          2018-05         B2      -       C       XB
Xpdnt           2009-10         B2      yes     C       XB
Zarkov          2016-06         B1      -       C       XB

Interesting list.

If we exclude dead engines, defined as 3y without update, we're left with:

• A1: 0 engines
• A2: 2 engines (Crafty, Dirty)
• A3: 3 engines (Franscesca, Olithink, ProDeo)
• B1: 3 engines (Catigula, Dimitri, Jumbo)

To put this in perspective, looking at http://fastgm.de/60-0.60.html, the top CECP-only engines are #64 (Dirty) and #65 (Crafty).

If most people think the earth is flat it won’t change the Earth’s curvature even if you think so. What it shows is that people are sheep following the majority without thinking. Sometimes it works. Sometimes it doesn’t.

I remembered when I looked at the different protocols for my engine and for me CECP/Winboard/XBoard was the only option really since you cannot treat something as stateless when it isn’t. UCI has many problems and delegates to many decisions to the GUI. It might be fine if you do another high ranked derivative like most do since it will be easier to copy paste from those engines supporting UCI. Of course some authors think they are extremely innovative and smart if they change a line or two .

I think that CECP/Winboard/XBoard could be simplified a lot, be more strict sometimes and have all there commands from side to move point of view. Even with its current flaws it is much much better than UCI. A protocol that mimics the real chess protocol is the best one.

[jdart]

CECP should have died 2 decades ago

I think it is unnecessarily complex. And, as noted, can be poorly implemented. But UCI has its own issues too, and can be poorly implemented also.

My main issue with UCI is that it basically treats the engine as a remote callable search function. It assumes you have a "smart" UI and a "dumb" engine. The engine has no context about the game except the series of moves. The engine cannot decide to resign or offer a draw. The engine can't adjust its behavior based on the opponent's rating. Arasan has a learning feature but it doesn't work in UCI mode because it depends on tracking the game state over time. Arasan can store a record of its own games in CECP mode, but not in UCI mode. Arasan's logging is broken in UCI too. I could probably fix some of these issues with some work but the protocol does not make it easy.

[Ras]

The engine cannot decide to resign or offer a draw.

You can always send some info string message to the user, and in automated tournaments, the operator wants to decide what the resign threshold is across all engines.

Arasan has a learning feature but it doesn't work in UCI mode because it depends on tracking the game state over time.

If you absolutely want that, you can always record the hashes of all positions that are possible after the opponent will have answered. If you have a match, then the position is a subsequent one.

Same as you would do in CECP in case the GUI chooses to transfer the game with setboard after the last irreversible move and then force for the remaining moves until the current position. Or does this actually only work with some of the many ways that CECP offers, but not for all anyway?

The game result is easily determined before either an unrelated position is transmitted, or ucinewgame arrives. If you have something above a winning/losing threshold, that's the result.

Arasan can store a record of its own games in CECP mode, but not in UCI mode. Arasan's logging is broken in UCI too.

That doesn't seem related to the protocol. Besides, storing the games is the job of the UI so that this works uniformly across all engines instead of having each engine (of possibly dozens) do its own thing in its own peculiar way.

[Guenther]

...
If we exclude dead engines, defined as 3y without update, we're left with:

• A1: 0 engines
• A2: 2 engines (Crafty, Dirty)
• A3: 3 engines (Franscesca, Olithink, ProDeo)
• B1: 3 engines (Catigula, Dimitri, Jumbo)

To put this in perspective, looking at http://fastgm.de/60-0.60.html, the top CECP-only engines are #64 (Dirty) and #65 (Crafty).

Thank's god a lot of people exist, who are not only fixated on (top) strength of an engine, otherwise this 'hobby' would have died already
over ten years ago ... and you with it ;-)

[lucasart]

The engine has no context about the game except the series of moves.

What more do you need as context ? What prevents you from storing the context in your engine (if you need any, I don't); and clear that storage when receiving "ucinewgame" ?

The engine cannot decide to resign or offer a draw.

I don't understand the value proposition here. The user decides (via the GUI) when engines resign or draw. And the way it's done is completely standard (score <= -Threshold for N moves by any one side for resign, |score| <= Threshold for N moves for draw). What else do you need ? And if you have something better, why can't it be implemented by the GUI ?

The engine can't adjust its behavior based on the opponent's rating.

UCI allows you to implement any option you like, include a Level option. And it even has a standardized one UCI_Elo. The only scenario I see you need ELO adjustment, is if your engine is playing on a chess server, and you want to set UCI_Elo automatically to match the one of the opponent. Pretty sure that would be banned by the chess server (because the engine's rating would get manipulated and pollute the ratings of everyone else as a result). But if you really wanted that, why couldn't it be done by the GUI ?

Arasan has a learning feature but it doesn't work in UCI mode because it depends on tracking the game state over time. Arasan can store a record of its own games in CECP mode, but not in UCI mode. Arasan's logging is broken in UCI too. I could probably fix some of these issues with some work but the protocol does not make it easy.

Same as before. I don't understand why UCI prevents you from recording state. You can record whatver you like, and clear the record on "ucinewgame" (or not, depending on what you are trying to do).

[Ras]

I remembered when I looked at the different protocols for my engine and for me CECP/Winboard/XBoard was the only option really since you cannot treat something as stateless when it isn’t.

It is. Or why else do CECP engines fail to exploit that "strength" on CCRL?

Of course some authors think they are extremely innovative and smart if they change a line or two .

You mean, single devs with unique engines like Ethereal that are also clearly above the IIRC highest ranking CECP-only engine Crafty? Or even engines like LC0 and its derivatives?

[hgm]

I don't understand the value proposition here. The user decides (via the GUI) when engines resign or draw. And the way it's done is completely standard (score <= -Threshold for N moves by any one side for resign, |score| <= Threshold for N moves for draw). What else do you need ? And if you have something better, why can't it be implemented by the GUI ?

That is not 'resigning'. You mix it up with 'adjudication'. Crafty can resign. UCI engines cannot. The GUI will have to adjudicate their games. If they do that based on the engine scores, it is especially bad. You can gain Elo on most rating lists by having the engine lie about negative scores, by (say) dividing those by 10...

[Joerg Oster]

I don't understand the value proposition here. The user decides (via the GUI) when engines resign or draw. And the way it's done is completely standard (score <= -Threshold for N moves by any one side for resign, |score| <= Threshold for N moves for draw). What else do you need ? And if you have something better, why can't it be implemented by the GUI ?

That is not 'resigning'. You mix it up with 'adjudication'. Crafty can resign. UCI engines cannot. The GUI will have to adjudicate their games. If they do that based on the engine scores, it is especially bad. You can gain Elo on most rating lists by having the engine lie about negative scores, by (say) dividing those by 10...

What's the difference?
The programmer decides when the engine should send a resign message, most likely based on the last scores. No?
The only difference here is one time the programmer decides when to stop, and the other time it's the user.

And lying about the score is also possible with CECP engines ...

[lucasart]

You can gain Elo on most rating lists by having the engine lie about negative scores, by (say) dividing those by 10...

I'm interested to see any evidence to back that statement. If that were true, you can imagine that all competitive engines (SF, LC0, K, H, E) would be doing this already. Perhaps this can be true in the patzer-land of CECP, with bogus 1500 elo engines that show resign scores for a few moves, due to a bug, then change their mind. But, for any serious engine, I doubt it.

Besides, your argument is irrelevant to the CECP resign vs. UCI adjudication debate. Any CECP engine can troll at will by never resigning (and lying about the score).