Research Report on the History of Computer Chinese Chess (Xiangqi) Game-Playing

Chapter 7 Qizhong Forum: The Heart of the Engine Community

7.1 The Creation and Early Development of Qizhong Forum

Qizhong Forum (棋中论坛, qqzze.com) was one of the most important communication platforms in the Chinese chess engine community. It was established around the early 2000s, when internet forums were in their golden age.

The founder of Qizhong Forum is no longer verifiable, but the forum’s growth and prosperity gathered the contributions of many Chinese chess engine developers and enthusiasts. The domain qqzze.com comes from the pinyin combination of “Qizhong” (chess in the middle / chess within).

Forum Section Layout:

Qizhong Forum set up a series of sections tailored to the needs of the Chinese chess engine community:

• Engine Release Area: A dedicated zone for developing and releasing chess engine versions, where developers could post their engine versions and changelogs.
• Technical Exchange Area: A section for discussing engine development technology (search algorithms, evaluation functions, UCCI protocol, etc.) — the core area with the highest technical content.
• Opening Book Research Area: Focused on opening book creation and research, where community members shared and discussed opening books.
• Game Notation Appreciation Area: An area for posting and discussing high-level game notations, including human-computer games and master games.
• Binghe 54 Discussion Area: A dedicated discussion area for the Binghe 54 engine management tool.
• Online Play Discussion Area: Discussing gameplay and strategies on online platforms like Yitian (Yitian/弈天).
• Software Evaluation Area: Performance comparison and evaluation of different engines and opening books.

7.2 Forum Culture and Contributions

Qizhong Forum’s influence on the Chinese chess engine community was profound, as reflected in the following aspects:

1. Hub of Knowledge Dissemination:

Qizhong Forum was the core channel for disseminating technical knowledge about Chinese chess engines. Many engine developers shared their technical experience on the forum, including:

• Implementation details and optimization techniques of search algorithms
• Tuning experience for evaluation functions
• Methods for creating opening books
• Implementation strategies for multithreaded/distributed search

Although these posts lacked the rigor of academic papers, they were often more practical and of extremely high reference value for other developers (especially self-taught learners).

2. Venue for Community Testing:

Qizhong Forum was the main venue for community testing and evaluation of engines. Users would:

• Publish head-to-head test results between different engines
• Compare engine performance under different settings
• Discuss the pros and cons of specific engine versions
• Share engine analysis results for specific positions

These test reports and discussions provided valuable feedback data for engine developers and also helped users choose the engine best suited to their needs.

3. Publishing and Distribution Channel for Commercial Engines:

During the golden age of commercial engines (2005–2015), Qizhong Forum was the most important channel for engine authors to publish commercial versions and interact with users. Engine authors would:

• Release preview versions and official versions of new releases
• Collect bug reports and feedback from users
• Publish official updates and patches
• Manage version announcements

4. Bridge Between Engines and Users:

Qizhong Forum played a bridging role between engine developers and users. On the forum:

• Users could ask questions and seek help
• Developers could understand user needs and issues
• Third-party enthusiasts could create auxiliary resources such as opening books and interface configurations

7.3 Key Figures and Community Contributors

Many individuals made significant contributions to the Chinese chess engine community on Qizhong Forum:

Engine Developers:

• Chen Chaoying (author of Xiangqi Cyclone): Frequently posted new versions and changelogs of Cyclone on the forum
• Jiang Zhimin and Zhang Min (authors of Xiangqi Mingshou): Released versions and test results of Mingshou through the forum
• Li Guolai (author of Jiajia Xiangqi): Discussed technical details of Jiajia on the forum

Opening Book Creators:

• “Longjiang” (龙江): Created the famous “Longjiang Library” series of opening books
• “Intella”-related opening book creators: Produced high-quality opening books for Intella

Technical Sharers:

• Multiple community members who published extensive technical tutorials on the forum, covering content from basic programming to advanced algorithm optimization

Testers and Evaluators:

• Community members who regularly published engine test reports on the forum, providing references for engine performance evaluation

7.4 The Decline of Qizhong Forum and the Transformation of the Technical Community

With the rise of mobile internet and the wider adoption of social media, traditional forums gradually declined in the late 2010s. Qizhong Forum’s user activity significantly decreased after 2015, for reasons including:

1. Impact of social media: Instant messaging tools such as WeChat and QQ groups replaced forums as daily discussion channels
2. Insufficient SEO optimization: The forum’s UI/UX failed to keep up with the requirements of the mobile internet era
3. Withdrawal of commercial engines: As the commercial engine market shrank, the core content (engine releases and evaluations) on the forum diminished
4. Rise of GitHub: Engine developers’ collaboration moved from forums to GitHub, and technical discussions migrated accordingly

The decline of Qizhong Forum marked an important transformation in the Chinese chess engine community’s structure — from the traditional “forum-centered” model to a distributed model of “GitHub + QQ/WeChat groups.” This transformation accelerated in the 2020s with the rise of open-source projects such as Pikafish.

---

Chapter 8 ElephantEye and Huang Chen’s Open-Source Contributions (2005–2020)

8.1 The Open-Source Architecture of ElephantEye

ElephantEye (Chinese name “Xiangyan” / 象眼) was developed by Huang Chen (黄晨), and is one of the most important open-source Chinese chess engine projects. Huang Chen was also the maintainer of xqbase.com, the designer of the UCCI protocol, and the promoter of the XQF game notation format standard.

ElephantEye’s Development History:

Huang Chen began developing ElephantEye around 2000. As a technical explorer and community builder for Chinese chess engines, Huang Chen chose to release ElephantEye under the LGPL license. This meant:

• Anyone could freely use, modify, and distribute ElephantEye’s source code
• If modified code was used as a library, the requirements were more relaxed
• If distributed as a standalone program, the source code had to be provided or reverse engineering had to be permitted

ElephantEye’s development goal was not to “surpass commercial engines” but to “provide a platform for learning and research.” Huang Chen wrote extensive technical documentation on xqbase.com detailing ElephantEye’s implementation. These documents are considered “bible-level” reference materials for Chinese chess engine programming.

8.2 ElephantEye’s Technical System

ElephantEye’s code structure was clean and highly modular. Its main modules included:

1. Position Representation:

Adopted a bitboard-based representation, with each piece type using a 64-bit integer (the first 90 bits of the bitboard representing the 90 intersection points of the 9×10 board).

The core advantage of the bitboard representation was fast move generation. Through precomputation and bitwise operations, the engine could generate all legal moves in a very short time. For example, rook moves could be generated through precomputed “reachability tables” combined with board state.

2. Move Generator:

Huang Chen designed an efficient move generator for ElephantEye, focusing on optimizing:

• Move generation speed optimized for Chinese chess piece characteristics (especially the blocking restrictions of horses and elephants)
• Use of precomputed tables to reduce runtime computation
• Separation of capturing and non-capturing moves (SEE requires capture move sequences)

3. Transposition Table:

ElephantEye implemented a standard Zobrist hash transposition table, with configurable size (typically 2^20 to 2^24 entries).

Information stored in transposition table entries included:

• Hash value (for verification)
• Search depth (depth of the search result)
• Node type (exact value / Alpha bound / Beta bound)
• Best move (for move ordering)
• Evaluation value

4. Evaluation Function:

ElephantEye’s evaluation function was representative among open-source engines:

• Material value evaluation: Weighted scores for each piece based on position and game phase (opening / middlegame / endgame)
• Positional value evaluation: Score for each piece at each position on the board (stored in precomputed position value tables)
• Piece mobility evaluation: Based on piece maneuverability and area control
• King safety evaluation: Protection status of both kings
• Pawn structure evaluation: Pawn configuration, value of crossed-river pawns
• Piece coordination evaluation: Coordination between rooks, horses, and cannons; defensive integrity of advisors and elephants

5. UCCI Protocol Implementation:

ElephantEye included complete UCCI protocol support, allowing it to work with any UCCI-compatible GUI. ElephantEye’s UCCI protocol support covered all core commands and options.

6. LEAGUE Simulator:

ElephantEye’s code included the LEAGUE simulator — an automated match testing tool that could run large numbers of games under different settings. The existence of LEAGUE allowed developers to perform thorough testing and validation before committing code changes.

7. XQFTOOLS (Chess Notation Tools):

Huang Chen also developed the XQFTOOLS suite for conversion between XQF (Chinese chess notation format) and PGN (portable game notation).

8.3 ElephantEye’s Playing Strength Evaluation

According to Huang Chen’s own assessment and reports from other engine testers, ElephantEye’s playing strength roughly corresponded to human amateur 3-dan to 4-dan level (approximately 2000–2200 ELO). This strength was at a medium level during 2005–2008, far below contemporary commercial engines (Cyclone, Intella, etc.).

However, ElephantEye’s open-source nature gave it value beyond its playing strength. It was the best learning resource for Chinese chess engine beginners and attracted countless developers to conduct research and secondary development based on it. Multiple subsequent engines (such as BitStronger and some early versions of Cyclone) referenced ElephantEye’s code or design.

8.4 Huang Chen’s Teaching Documentation

Besides the engine itself, the series of teaching documents Huang Chen published on xqbase.com were equally valuable knowledge resources. These documents included:

• “Exploration of Chinese Chess Program Design” series: An introduction to developing a Chinese chess program from scratch, covering board representation, search algorithms, evaluation functions, UCCI protocol, and other topics.

• “UCCI Protocol Specification”: The complete technical documentation of the UCCI protocol, an essential reference for all UCCI protocol implementers.

• “Hash Techniques in Chinese Chess Programs”: A detailed introduction to the implementation of Zobrist hashing and transposition tables in Chinese chess programs.

• “Move Generation in Chinese Chess Programs”: A detailed introduction to move generation algorithms and optimization strategies for various Chinese chess pieces.

These documents were concise and easy to understand in format, with extensive sample code, making them among the highest quality Chinese-language teaching resources in the field of Chinese chess programming.

8.5 Historical Significance of ElephantEye

The historical significance of ElephantEye can be summarized as:

1. Open-source anchor: ElephantEye’s open-source nature provided a stable code reference for the Chinese chess engine community. Against the backdrop of most engines being closed-source, ElephantEye was the only complete engine that could be freely studied, modified, and distributed.

2. Talent cultivation: Countless Chinese chess engine developers entered the field of engine development by studying ElephantEye’s source code.

3. Standard setting: The UCCI protocol and XQF tools implemented by Huang Chen in ElephantEye promoted the standardization of Chinese chess engines.

4. Knowledge heritage: The teaching documents written by Huang Chen systematically recorded the core knowledge of Chinese chess engine development, benefiting thousands of developers through the dissemination effect of the internet.

5. Cross-domain influence: ElephantEye’s influence extended beyond the Chinese chess domain; it was also ported to international chess variants (such as through Fairy-Stockfish adaptation), demonstrating its architectural extensibility.

---

Chapter 9 Binghe 54 Interface and Engine Management Tools

9.1 The Birth of Binghe 54

Binghe 54 (兵河五四, BingHe 54) was one of the most important interface and management tools in the Chinese chess software field. It was created by the community developer “54” (五四, pseudonym), with the initial goal of providing a unified, feature-rich management platform for chess engines.

The name “Binghe 54” is a homophonic play on “Engine” (引擎), reflecting both the tool’s functional positioning and Chinese chess characteristics. The emergence of Binghe 54 filled the market gap for Chinese chess engine management tools after the popularization of the UCCI protocol.

9.2 Core Functions of Binghe 54

Binghe 54’s core functions included:

Multi-Engine Management: Binghe 54 supported loading multiple UCCI/UCI protocol engines simultaneously. Users could freely switch between different engines, which was extremely useful in comparative testing and competition preparation. Binghe 54 also supported:

• Running multiple engine instances simultaneously
• Independent setting and saving of engine parameters
• Real-time monitoring of engine performance

Automated Match System: Binghe 54 had a built-in complete automated batch match system, supporting:

• Round-robin and knockout tournament scheduling
• Time control settings (absolute, incremental, limit, etc.)
• Opening book management
• Automatic saving of game notations and statistics
• ELO rating calculation
• Real-time display and replay of game processes

Cloud Book Integration: Binghe 54 was one of the main front-end clients for the Chinese Chess Cloud Book. Through Binghe 54, users could directly query opening book and endgame tablebase data from the cloud book, and also use the cloud book’s auto-learning function.

Online Play Connectivity: Binghe 54 supported connecting to multiple online play platforms (such as Yitian, QQ Chess, Tiange Chess, etc.), allowing users to engage in man-machine cooperation combined with engine analysis.

Custom Options: Binghe 54 provided rich customization options, including:

• Engine path and startup parameter settings
• Opening book loading and editing
• Game notation format configuration
• Interface appearance settings
• Hotkey binding

9.3 Binghe 54’s Impact on the Chinese Chess Software Ecosystem

Binghe 54’s impact on the Chinese chess software ecosystem was multifaceted:

1. Lowered the barrier to engine use: Users did not need to manually type command lines to invoke engines; through Binghe 54’s graphical interface, engine management and invocation could be completed.

2. Standardized engine testing methods: Binghe 54’s automated match system provided a standardized testing methodology, making test results from different users comparable.

3. Promoted exchange between engines: Binghe 54 supported managing multiple engines on the same platform, allowing users to intuitively compare the performance of different engines.

4. Contribution to documentation and community: Binghe 54’s documentation and usage tutorials spread widely in the community, forming a knowledge system around its use.

9.4 Other Contemporary Interface Tools

Important interface tools contemporary with Binghe 54:

• Xiangqi Wizard (象棋巫师, ElephantBoard): A famous interface developed by Huang Chen, with a built-in ElephantEye engine, supporting UCCI protocol, featuring a friendly user interface and good user experience.

• Intella Interface: Originally the companion interface for Intella, later supported multiple engines. The Intella interface had a high market share in the late 2000s.

• Cyclone Interface: The companion interface for Xiangqi Cyclone, tightly integrated with the Cyclone engine, offering advantages in optimization and compatibility.

These interface tools, together with the engines, constituted a complete Chinese chess software ecosystem, allowing users to use advanced engine features without understanding the underlying protocols.

9.5 Comparison of Chinese Chess GUI Interface Tools

The interface tools (GUI) for Chinese chess engines evolved from engine-built-in interfaces to independent universal interfaces. Below is a comparison of mainstream interface tools:

Note: Binghe 54, as the most functionally complete engine management tool in history, although discontinued in the 2010s, its design philosophy (separation of interface and engine, multi-engine management, online-play connectivity) profoundly influenced all subsequent chess software. Xiangqi Wizard played an irreplaceable role in education and entry-level use — many Chinese chess enthusiasts first encountered UCCI engines through Xiangqi Wizard. As mobile internet became widespread, PC-side GUI tools have generally given way to mobile apps, but for engine developers and heavy users, Binghe 54 has yet to be fully replaced.

---

Chapter 10 Xiangqi Mingshou and Jiajia Xiangqi (2009–2015)

10.1 The Rise of Xiangqi Mingshou

Xiangqi Mingshou (象棋名手, CChess Master) was developed by the team of Jiang Zhimin (蒋志敏) and Zhang Min (张闽), and is the pinnacle of Chinese commercial chess engines. Mingshou became the leader of the Chinese chess engine market during 2009–2015.

Xiangqi Mingshou’s initial version was released around 2009. Its early versions won championships at the CCMC China Computer Game Championship, and Mingshou was continuously improved, gradually building a comprehensive advantage in playing strength, stability, and ease of use.

Xiangqi Mingshou’s Technical Features:

1. PVS Search: Mingshou implemented a highly optimized PVS search, with search efficiency at a leading level among contemporaneous engines. Mingshou’s PVS implementation paid particular attention to:

• Efficient move ordering strategies
• Precise window management
• Balance between pruning and safety

2. Multithreaded Parallel Search: Mingshou was one of the early engines to support multithreaded parallel search. On dual-core and quad-core machines, Mingshou’s parallel search efficiency could reach over 70%. This parallel capability offered a significant performance advantage during the rapid hardware development of the late 2000s.

3. Distributed Computing Support: Mingshou supported distributing search tasks across multiple computers. Although the scope of this distributed computing in practical applications was limited (requiring high-speed network connections between multiple machines), it demonstrated Mingshou’s forward-looking design in scalability.

4. Deep Hand-Tuned Evaluation Function: Mingshou’s evaluation function is considered the pinnacle of the hand-tuned evaluation era. Its evaluation function included hundreds of finely tuned positional features, with multiple sets of evaluation parameters designed for different position types. Mingshou’s evaluation function had the following characteristics:

• Refined piece coordination evaluation
• Deep tactical threat detection
• Specialized rules for handling typical tactical patterns such as exposed cannons (空头炮), trapped horses (窝心马), and multi-piece flank concentration (多子归边)

Xiangqi Mingshou’s Competition Results:

Xiangqi Mingshou achieved remarkable results in the China Computer Game Championship (CCMC):

• 2009: Champion (Shenzhen)
• 2011: Champion
• 2012: Champion
• 2013: Champion
• 2014: Champion

Mingshou’s consecutive championship record at CCMC fully demonstrated its playing strength stability and leadership.

10.2 Detailed Technical Architecture of Xiangqi Mingshou

Xiangqi Mingshou’s technical architecture represented the highest level of traditional Alpha-Beta engines. Its core design decisions included:

(I) Parallel Search Architecture

Xiangqi Mingshou adopted a more aggressive parallel search strategy than contemporaneous engines. Traditional parallel search schemes (such as Young Brothers Wait, ABDADA, etc.) had limitations in load balancing and communication overhead between cores. Mingshou used an improved version of “Split Search” — when the search reached a certain depth, different branches of the search tree were assigned to different cores for parallel exploration.

Mingshou’s parallel efficiency could reach approximately 70–80% on 4–8 core machines, a leading level among contemporaneous engines.

(II) Distributed Computing Implementation

Xiangqi Mingshou supported distributing search tasks across multiple computers. The specific implementation involved distributing search tasks to distributed computing nodes through a network protocol, with nodes summarizing results after completing subtasks. This architecture was extremely avant-garde for its time — most engines only supported single-machine multi-core, while Mingshou could already utilize computing resources across the entire network.

Distributed Computing Workflow:

1. The Master node runs the engine’s control logic and evaluation function
2. Each Worker node runs search computation tasks
3. The Master node assigns search tasks (a series of moves) to Worker nodes
4. Worker nodes return results to the Master node after completing tasks
5. The Master node summarizes results and performs further analysis

(III) Evaluation Function Refinement

Mingshou’s evaluation function is considered the pinnacle of the hand-tuned evaluation era. It included:

• Hundreds of hand-tuned positional features
• Multiple sets of evaluation parameters for different position types
• Refined piece coordination evaluation
• Deep tactical threat detection
• Specialized rules for handling typical tactical patterns such as exposed cannons, trapped horses, and multi-piece flank concentration

(IV) Opening Book and Endgame Tablebase Community Ecosystem

Xiangqi Mingshou’s opening book was mainly maintained by high-level players in the community. These players collaborated through platforms such as Qizhong Forum:

• Regularly publishing new opening book versions
• Updating weights based on latest master games and engine test results
• Customizing opening books for different engine characteristics
• Verifying opening book effectiveness through community testing

10.3 Jiajia Xiangqi and GGzero

Jiajia Xiangqi (佳佳象棋, Jiangui / Jiajia) was developed by Li Guolai (李国来). While traditional Alpha-Beta engines reached their peak, Jiajia Xiangqi also actively explored the application of reinforcement learning in Chinese chess.

Traditional Version of Jiajia Xiangqi:

The traditional version of Jiajia Xiangqi was based on Alpha-Beta search and hand-tuned evaluation functions. It reached a playing strength level comparable to Mingshou and Cyclone in the early 2010s. Jiajia Xiangqi had its own characteristics in evaluation function design, particularly in relatively accurate defensive position assessment.

GGzero Project:

GGzero was a reinforcement-learning-based Chinese chess engine developed by the Jiajia Xiangqi team, directly inspired by DeepMind’s AlphaZero. GGzero used deep neural networks (CNN) to replace hand-tuned evaluation functions, learning through self-play.

GGzero’s technical characteristics included:

• Monte Carlo Tree Search (MCTS): Replacing traditional Alpha-Beta search
• Deep neural network: Using convolutional neural networks (CNN) to simultaneously predict move probabilities and position evaluation values
• Self-play learning: Continuously improving by playing against its own past versions
• Computational requirements: Training required substantial GPU resources (typically multiple high-end GPUs running for weeks)

The emergence of GGzero marked an exploratory attempt at “neural network + reinforcement learning” technology in Chinese chess engines. Although GGzero’s training process was limited by computational resources and its playing strength did not surpass the top Alpha-Beta engines of the time, it demonstrated a new direction for Chinese chess engine development.

10.4 Xiaochong Xiangqi (BugChess)

Xiaochong Xiangqi (小虫象棋, BugChess) was developed by the team of Liu Zongyuan (刘宗元), forming an important force among Chinese commercial chess engines. BugChess won the gold medal at the 17th Computer Olympiad in 2013, cementing its position as a major player in the Chinese chess commercial engine landscape. In the Chinese chess software market, it had very high market share and market recognition.

Technical Features:

1. Efficient Alpha-Beta search implementation: Although BugChess’s search algorithm had no fundamental innovation, its engineering implementation was extremely solid. The code underwent extensive hand optimization and performed excellently on equivalent hardware.

2. Multithreaded parallel search: BugChess supported multi-core parallel search early on, with good scalability on dual-core and quad-core machines.

3. Large-scale opening book: BugChess collaborated with community opening book maintainers to provide an extremely broad-coverage opening book. Its opening book covered nearly all mainstream opening branches and offered multiple versions for users of different playing strength levels.

4. Endgame tablebase support: Supported Nalimov-style endgame tablebases for precise play in the endgame phase.

5. Multi-platform compatibility: BugChess supported multiple platforms including Windows, Android, and iOS. Its Android version had a very high market share among mobile chess software.

Business Model and Market Strategy:

BugChess’s business strategy differed from those of Cyclone and Mingshou:

• Relatively lower pricing, targeting a broader user base
• Supported multiple payment methods and licensing models
• Offered free trial versions
• Continuous updates and maintenance, fast user support response

User Base:

BugChess’s user base covered an extremely wide range:

• Chess training institutions used BugChess as a teaching aid
• Professional players used BugChess for pre-competition preparation and position analysis
• Amateurs used BugChess for daily training and play
• Users of online play platforms used BugChess for man-machine cooperation

Although BugChess did not have the “champion halo” of Cyclone or Mingshou, with its stability, ease of use, and broad platform support, it occupied an unignorable position in the Chinese chess software market.

10.5 2009–2015 Engine Multi-Dimensional Comparison

2009 to 2015 was the mature period of Chinese chess engine commercialization, with engines showing differentiated development in technical approach, business model, and market positioning. Below is a systematic comparison from multiple dimensions:

Note: During this period, Xiangqi Mingshou established its position as the top commercial engine with five consecutive CCMC championships. However, its non-participation in international events like ICGA reflected the strategic choice of some domestic commercial engines — prioritizing commercial returns in the domestic market over international academic competitions. The GGzero attempt by Jiajia Xiangqi was the first systematic application of MCTS technology in Chinese chess. Although its playing strength did not reach the level of PVS engines, it laid the technical groundwork for the later NNUE era. BugChess’s success demonstrated the importance of cross-platform support and reasonable pricing in expanding the user base.

Chapter 11 Nanao Chess: From Xiangqi Shijia to Cross-Generational Legacy

11.1 The Predecessor of Nanao Chess: The Birth of Xiangqi Shijia

Nanao Chess (Nanao Xiangqi / sachess) is an important force with a deep historical heritage in the field of Xiangqi engines. Its predecessor is Xiangqi Shijia (Xiangqi Shijia / “Chess Family”), created by Taiwanese developer Zheng Mingzheng (online alias “Poor”) in the mid-1990s.

The Origin of Xiangqi Shijia (1995):

Zheng Mingzheng was a primary school teacher in Taiwan. In November 1995, he used his spare time to begin writing a Chinese chess client program named “zmz” for playing online on ICCS (International Chinese Chess System). The program was initially a simple chess interface, but as Zheng Mingzheng continuously added features, it gradually evolved into a complete Xiangqi engine.

In 2000, the software was officially named Xiangqi Shijia, a culturally evocative name given by Shi Jinshan. Subsequently, a formal development team was assembled:

• Zheng Mingzheng (Poor): Engine core developer, responsible for search algorithms and evaluation functions (developed using Visual Basic 6.0 (sp5) programming language)
• Wu Yanqi: Engine testing and optimization
• Tang Shiyan: Engine testing
• Shi Jinshan: Opening book collection
• Huang Hengshan: Lead tester

In the early 2000s, Xiangqi Shijia was sold in Taiwan and Hong Kong, becoming one of the important brands in the commercial Xiangqi software market. Xiangqi Shijia was also one of the earliest Xiangqi chess software to engage in cross-border remote development collaboration via the Internet. Xiangqi Shijia V4 was the last major version developed by Zheng Mingzheng and Xiao Ye (Guangzhou, Mainland China). V5 was a major version where Zheng Mingzheng was responsible for the engine (C++ source code, algorithm inherited from his own VB algorithm) and Oldwu (Shanghai, Mainland China) was responsible for the interface and sales in the Mainland China market. Subsequently, due to internal team disagreements, the original team split, resulting in the V6-V9 series versions maintained by Oldwu.

Xiangqi Shijia’s Achievements at ICGA:

In 2010, Xiangqi Shijia (competing under the name Shiga) won the gold medal in the Xiangqi event at the 15th ICGA Computer Olympiad (Kanazawa, Japan). This was the highest honor for the Xiangqi Shijia series of engines in international competitions.

11.2 Nanao Chess’s Rebranding and Technical Architecture

After 2009, Oldwu, the interface author of Xiangqi Shijia, after years of research into engine technology, released a new engine under the name Nanao Chess (sachess). The engine’s executable file was named sachess.exe, hence it is also commonly referred to as “Sachess.”

Technical Architecture:

Nanao Chess is an engine based on traditional Hand-Crafted Evaluation (HCE), using the classic Alpha-Beta search architecture:

1. Search Algorithm: PVS (Principal Variation Search) combined with Iterative Deepening, Null Move Pruning, History Pruning, Aspiration Windows, and other techniques.

2. Quiescence Search: Used to mitigate the Horizon Effect, continuing to search captures and key moves after reaching the set search depth.

3. Transposition Table: A Zobrist hash-based transposition table that caches results of already searched positions.

4. Move Ordering: Employs a multi-layer ordering strategy — transposition table best move first, followed by capture moves (ordered by MVV/LVA principle, i.e., Most Valuable Victim / Least Valuable Attacker), then Killer Moves, and finally History Heuristic moves.

5. Search Extensions: Techniques such as Check Extension, Recapture Extension, and Mate-threat Extension.

6. Position Representation: Uses bit-rank/bit-file techniques for efficient move generation.

7. Evaluation Function: Traditional hand-crafted evaluation, including multiple dimensions such as material value, positional value, piece activity, king safety, etc. Nanao Chess’s evaluation function was finely tuned during the hand-crafted evaluation era.

Opening Book:

Nanao Chess’s opening book is built from thousands of master-level games, including high-level game data from national chess competitions, Xiangjia League, individual championships, Yitian Huashan, and other sources. The opening book supports online queries of cloud opening books and cloud endgame tablebases.

Multi-Core Support:

Nanao Chess released multiple versions to support different hardware configurations:

• Dual-Core Edition (free release): Optimized for dual-core CPUs
• Quad-Core Ultimate Edition v1.5: Optimized for quad-core CPUs
• Both 32-bit and 64-bit versions were provided

Interface Features:

The accompanying GUI of Nanao Chess has the following features:

• Office 2003 style interface
• Analysis mode for any position
• Support for XML format game notation recording
• Compatibility with XQF, CBL, PGN, MXQ, CHE, and other game notation formats
• Opening book management and editing
• Engine configuration management

11.3 Nanao Chess Competition Results

Nanao Chess achieved the following results in tournaments such as the China Computer Games Championship and the Asian AI Xiangqi Invitational:

2017 11th China Computer Games Championship:

At the 11th China Computer Games Championship held in Chongqing, Nanao Chess won the runner-up position, one of its best results in Mainland China tournaments. During the competition, Nanao Chess demonstrated excellent middlegame tactical ability and stable endgame handling.

2017 2nd Chuhe Hanjie Cup:

At the Chuhe Hanjie Cup Asia Xiangqi AI Invitational held in Xingyang, Henan, Nanao Chess competed against strong opponents such as Xiangqi Cyclone, Xiangqi Tianqi, and Alpha Cat. The tournament used a unified 36-core supercomputing setup, opening books were disabled, and an 8-move forced book exit was applied.

Nanao Chess drew consecutively against Xiangqi Cyclone, Xiangqi Tianqi, and Alpha Cat in the first three rounds of the preliminaries, demonstrating a stable competitive state. It ultimately won third place and a prize of 5,000 RMB. The champion was Xiangqi Cyclone, and the runner-up was Xiangqi Mingshou.

Strength Assessment:

According to community test data, the playing strength of the Nanao Chess free edition is approximately 2890 ELO (on Kaka’s engine rating list), equivalent to the level of Xiangqi Mingshou 3.26, far exceeding human grandmasters, but significantly behind modern NNUE engines (Pikafish at approximately 4005 ELO).

In the community engine rating rankings, Nanao Chess is positioned around 16th (out of approximately 26 tested engines), placing it at the level of second-tier traditional engines.

11.4 Nanao Chess Licensing Model and Community Impact

Nanao Chess’s licensing model evolved from commercial to free:

• Nanao Chess Dual-Core Edition: Free release, suitable for low-end computers
• Quad-Core Ultimate Edition: Possibly a paid version

The source code of Nanao Chess has never been made public. Although its license is not clearly documented, the free release of the dual-core edition enabled a large number of Xiangqi enthusiasts to access commercial-grade engine analysis capabilities.

11.5 Historical Significance of Nanao Chess

Nanao Chess’s position in the history of Xiangqi engine development:

1. Pioneer of the Commercial-to-Free Transition: The release model of Nanao Chess’s free dual-core edition was one of the early attempts at transitioning commercial engines to a free model.

2. Benchmark of the Traditional HCE Era: Before the popularization of NNUE, the tuning level of Nanao Chess’s evaluation function represented the high standard of traditional hand-crafted evaluation engines.

3. Vessel of Community Memory: The circulated versions and competition records of Nanao Chess carry the memory of the Xiangqi engine community’s development journey through the 2000s-2010s.

The latest known version is Nanao Chess v1.6 (circa 2017-2019). After this, updates to Nanao Chess appear to have ceased, but its influence in the community and its practicality on low-end computers still remain.

---

Chapter 12 Pikafish: The NNUE-Era Open Source Revolution (2022–Present)

12.1 NNUE Technology and Its Introduction to Xiangqi

NNUE (Efficiently Updatable Neural Network) is a neural network evaluation architecture originally developed by Japanese programmer Yu Nasu in 2018 for the chess engine Stockfish. The hallmark feature of NNUE is: using a half-integer linear network structure, where after each move only the affected features need to be incrementally updated, rather than performing a full network inference on the entire board.

Main Innovations of NNUE:

1. Incremental Update: NNUE only updates the feature values of the moved piece’s old and new positions, rather than recomputing the entire board. This makes the computational cost of feature updates independent of board size, only related to the local scope affected by each move.

2. Sparse Computation: NNUE converts sparse feature extraction into matrix computations of fully connected layers, cleverly utilizing SIMD instruction sets (especially AVX2) for efficient batch inference.

3. Hybrid Architecture: NNUE is used as a position evaluation model in combination with Alpha-Beta search — evaluation is done by NNUE, while search still uses traditional PVS search.

Migration of NNUE from Chess to Xiangqi:

Migrating NNUE from chess to Xiangqi is not a simple parameter copy; it requires solving the following adaptation issues:

Board Size Difference: Chess is 8×8 = 64 squares; Xiangqi is 9×10 = 90 intersection points. This means the input feature dimension for Xiangqi is approximately 1.4 times that of chess.

Piece Type Difference: Chess has 6 piece types per side (King, Queen, Rook, Bishop, Knight, Pawn); Xiangqi has 7 piece types per side (King/General, Advisor, Elephant/Bishop, Horse, Rook, Cannon, Pawn/Soldier). Additionally, Xiangqi’s “Cannon” has a unique jumping capture rule with no counterpart in chess.

River Boundary Difference: Xiangqi’s “river” divides the board into red and black territories. Pawns/Soldiers change their behavior after crossing the river, which needs to be reflected in the evaluation network.

Palace Difference: The King/General and Advisor’s movement range is restricted to the palace, which affects the encoding method of network input features.

12.2 The Birth and Early Development of Pikafish

Pikafish project began in 2022, created by users on the open source platform GitHub. Initially, it was driven by a group of developers in the community with deep knowledge of the Stockfish technical approach.

Origin of the Name Pikafish:

The name Pikafish comes from a phonetic play on “Feika Yu” (Pikafish sounds similar to the Chinese “Feika Yu”), while also corresponding to the name Stockfish (Stockfish is dried cod, Pikafish is another kind of “fish”). This naming style reflects the project’s relationship with Stockfish — adapting Stockfish’s codebase for Xiangqi.

Project Origin and GitHub Repository Creation:

Pikafish’s GitHub repository was initially created with the organization/repository name “official-pikafish/Pikafish.” Founding team members chose to participate anonymously or under pseudonyms, partly to avoid potential disputes over commercial engine intellectual property.

Early Version Development (2022):

The earliest versions of Pikafish (approximately April-May 2022) mainly involved adapting Stockfish’s code to Xiangqi rules and board. Work at this stage included:

1. Board representation changed from 8×8 to 9×10
2. Piece types changed from 6 per side to 7 per side
3. Rule adaptation (generals facing, cannon’s jump capture, pawn crossing the river, etc.)
4. NNUE network structure adaptation (input layer size adjustment)
5. UCCI protocol support (instead of UCI protocol)

Joining of Community Contributors:

The Pikafish project quickly attracted a large number of community developers. These contributors had diverse backgrounds:

• Developers from the chess community interested in Xiangqi
• Enthusiasts from the Xiangqi software community
• Researchers and students in computer science
• Programmers interested in open source projects

12.3 NNUE Network Training and Datasets

Training an NNUE network requires large-scale, high-quality Xiangqi position evaluation data. Pikafish’s data sources include:

1. Cloud Book Data: Using large endgame tablebase and opening book data from the Xiangqi Cloud Book (chessdb.cn). The cloud book provides approximately 2.5M evaluation data points.

2. Self-Play Data: Pikafish collects game data by conducting large numbers of matches between different versions of the engine. This data is managed through the Fishtest framework.

3. Engine vs. Engine Data: Data generated from matches between Pikafish and other engines (such as Cyclone, Mingshou).

4. Game Database Data: Historical master-level human player game data.

NNUE network training uses Python scripts (based on PyTorch or TensorFlow), with the training process including:

• Data preparation: Converting games into training samples (position + move + evaluation value)
• Data cleaning: Filtering low-quality or anomalous data
• Network training: Using GPU-accelerated training loops
• Quantization conversion: Converting the trained network into an embedded format loadable by C++

Scale and Quality of NNUE Training Data:

NNUE training requires large-scale datasets. The training data collected by the Pikafish community reaches millions or even tens of millions of positions. The data covers:

• Various position types from opening to endgame
• Various evaluation ranges from advantage to disadvantage
• Various positions from simple material configurations to complex multi-piece structures

The quality of training data directly affects NNUE evaluation accuracy. The Pikafish community has done extensive work in data cleaning and preprocessing, including:

• Removing duplicate or similar positions
• Filtering obvious anomalies (such as intermediate states of already decided games)
• Balancing the distribution of different position types in the data

12.4 Pikafish Technical Architecture

Pikafish’s code architecture is based on Stockfish, but deeply adapted for Xiangqi. Its core modules include:

1. Position Representation:

Pikafish uses bitboard representation for board state. Each piece type (7 red + 7 black = 14 types) uses a 64-bit integer to represent its position. Since the Xiangqi board has only 90 intersection points, the upper 26 bits of the bitboard can be used to store other state information.

2. Move Generator:

Pikafish’s move generator is highly optimized, using:

• Precomputed piece move tables
• Cannon “jump capture” detection algorithm (requires checking whether there is exactly one piece serving as a “cannon mount” between the cannon and the target piece)
• Horse “hobbling leg” detection
• Elephant “blocked eye” detection

3. Search Algorithm (PVS Search):

Pikafish uses Stockfish’s standard PVS search, combined with the following pruning techniques:

• Null Move Pruning: Boldly assumes that even if the opponent gets a free move, the position is still not losing, in non-endgame phases
• LMR (Late Move Reductions): Reduces search depth for moves that are ordered later
• SEE (Static Exchange Evaluation): Evaluates the net gain/loss of capture exchange sequences
• Razor pruning, Futility pruning, etc.

4. Lazy SMP Parallel Search:

Pikafish uses Lazy SMP (Lazy Symmetric Multi-Processing) for parallel search. The basic idea of Lazy SMP is:

• Multiple search threads share one transposition table
• Each thread performs search independently, without task allocation
• Threads communicate indirectly through the shared transposition table

Although Lazy SMP is less efficient in hardware resource utilization than precise task allocation strategies, it is simple to implement and has good scalability, especially performing well on high-core-count hardware with 16+ threads.

5. NNUE Evaluation Network:

Pikafish’s NNUE network structure is adapted for Xiangqi based on Stockfish’s HalfKP feature set. HalfKP uses “our king position + each opponent piece position” as features, utilizing board symmetry to reduce the number of features.

The latest version of Pikafish uses the ATT++ (Attention-based NNUE) architecture, introducing attention mechanisms to improve the network’s ability to model large-scale spatial patterns.

12.5 Most Important Pikafish Release Versions

Pikafish’s development history includes several important milestone versions:

As of 2026, Pikafish’s development continues, with the community maintaining active contributions and updates.

12.6 Fishtest Testing Framework

Fishtest is the distributed testing framework used by the Pikafish community. Fishtest was originally developed by the Stockfish community for running large-scale engine tests on computing resources contributed by open source community participants.

How Fishtest Works:

1. Test Submission: A developer submits a patch to Fishtest, claiming that the patch is expected to improve playing strength.

2. Task Distribution: The Fishtest server decomposes the test task into multiple groups of games and distributes them to community contributors’ computers.

3. Game Execution: Each contributor’s computer runs a specified number of games (typically using standard test time controls: 15s+0.5s or 60s+0.6s, etc.).

4. Result Reporting: Each computer reports the test results back to the Fishtest server.

5. SPRT Check: The server performs SPRT (Sequential Probability Ratio Test) on the accumulated results to determine whether the patch “passed” (ELO improvement significant), “failed” (ELO change not significant or negative), or “needs more data.”

How SPRT Works:

SPRT is a statistical hypothesis testing method that continuously accumulates data until there is sufficient evidence to make a judgment. SPRT requires setting:

• H0 (Null Hypothesis): The patch does not change playing strength (ELO change = 0)
• H1 (Alternative Hypothesis): The patch improves playing strength (ELO change > 0)
• Type I Error (α): The probability of incorrectly accepting H1
• Type II Error (β): The probability of incorrectly accepting H0

As the number of test games increases, SPRT calculates the Likelihood Ratio and determines whether the result has reached the accept/reject threshold. The advantage of SPRT is that it can make a judgment at the earliest possible point, avoiding unnecessary test games.

Impact of Fishtest on the Xiangqi Community:

After Pikafish introduced the Fishtest framework, the testing methodology for Xiangqi engines underwent a qualitative leap:

• Changed from “adjusting parameters by feel” to “data-driven statistical validation”
• Every modification must pass statistical significance testing to be accepted
• Test data is open and transparent, viewable by any community member

12.7 Specific Architecture Used by the Pikafish Engine

Pikafish is based on Stockfish and uses a complete PVS search architecture. Its core search-related components include:

Search Framework:

• Main Search (principal search function)
• QSearch (quiescence search, only examining capture moves)
• RootSearch (root node search, the main function for iterative deepening)

Pruning Techniques:

• Null Move Pruning
• Razoring
• Futility Pruning
• Late Move Pruning
• SEE Pruning (Static Exchange Evaluation Pruning)
• ProbCut (probability-based pruning, using shallow search results for pruning decisions)

Move Ordering:

• Hash Move (transposition table best move)
• Winning Captures (moves that win material)
• Promotions (pawn/soldier promotion — in Xiangqi, value changes after crossing the river)
• Equal Captures (equal exchange capture moves)
• Killer Moves
• History Moves (history heuristic moves)
• Losing Captures (moves that lose material)
• Other Moves

12.8 Test Data for Pikafish Versions

All version improvements of Pikafish have undergone rigorous double-blind randomized controlled testing (through the Fishtest platform). The following are test results for several representative versions:

Version 2022-10-22:

This version improved performance in long time control (LTC) games and initially fixed misjudgment issues in endgame position evaluation. The NNUE network file used data trained from previous versions.

Version 2022-12-26:

This was one of the most important early version improvements for Pikafish. New features included:

• 60-move rule and threefold repetition detection (basically compliant with Asian rules)
• Introduction of the WDL (Win/Draw/Lose) model
• New NNUE compression architecture

Test Results:

• Number of games: 1,548
• Win rate: 53.84%
• ELO improvement: +26.20 (95% confidence interval: [15.87, 36.90])

Version 2024-08-31:

Introduced a completely new ATT++ NNUE network architecture, bringing a significant improvement in playing strength and a reduction in network file size. Also updated cyclic rule logic.

Version 2025-06-23:

An important performance optimization version:

• Larger L1 cache size, performing better in long time control games
• Introduced mid-mirror input feature encoding, improving evaluation symmetry in mirrored positions
• Improved stalemate detection in quiescence search
• Optimized AVX512 instruction set performance

12.9 Pikafish Technical Documentation and Documentation Ecosystem

The Pikafish project has a relatively complete documentation system, reflecting its engineering maturity as a mature open source project:

• README.md: Project overview, compilation guide, license description
• AUTHORS: Complete list of all contributors
• UCI & Commands Guide: Complete command reference for the UCI protocol
• Advanced Topics: In-depth technical discussions covering NNUE evaluation, Fishtest testing, compilation optimization, etc.
• DeepWiki: Third-party maintained in-depth technical documentation covering NNUE architecture, feature transformation, search system, etc.

This comprehensive documentation ecosystem is crucial for attracting new contributors and lowering the barrier to contribution.

12.10 Pikafish’s Contribution to Xiangqi Research

The emergence of Pikafish is not just a technical event; it has also greatly promoted changes in the way Xiangqi research is conducted:

Democratization of Research:

Before Pikafish, top-tier analysis tools cost hundreds to thousands of RMB (such as commercial engines like Xiangqi Cyclone and Mingshou). As a free and open source engine, Pikafish allows any enthusiast with an ordinary computer to access world-class analysis tools. This has greatly lowered the barrier to high-level Xiangqi analysis.

Educational Applications:

Pikafish is widely used in Xiangqi teaching scenarios. Coaches can use Pikafish to analyze students’ games, generate position training exercises, and simulate opponents of different levels.

Cultural Preservation:

The development history of Pikafish itself is accumulating an open digital cultural heritage for the Xiangqi software community. Every Commit on GitHub, every Issue discussion, and every test game is recording the history of community collaboration.

---