Knight Chess: A Chess Variant with Extended Board and Enhanced Knight Dynamics

1. Introduction

Chess has been a subject of intense study in artificial intelligence since Shannon's foundational work on programming a chess-playing computer (Shannon, 1950). While standard chess has been explored exhaustively—culminating in superhuman engines such as Stockfish and AlphaZero—chess variants offer fertile ground for investigating how rule modifications affect strategic depth, computational complexity, and AI design.

The knight is arguably the most distinctive piece in chess. Unlike all other pieces, the knight moves in a non-linear L-shaped pattern and is the only piece capable of jumping over others. In standard chess, each side begins with two knights, and their influence is often considered secondary to bishops, rooks, and queens in the endgame. However, increasing the number of knights fundamentally changes the strategic landscape: fork threats multiply, positional control becomes less predictable, and the interplay between knights and other pieces shifts the balance of tactical versus positional play.

Knight Chess explores this hypothesis through two coordinated rule changes. First, the board is extended from 8×8 to 8×9, adding one additional row that provides strategic depth and allows pieces more room to maneuver during the opening phase. Second, three pawns per side are randomly replaced by knights at the start of each game, giving each player five knights instead of the standard two. The random replacement ensures that no two games begin with the same configuration, introducing a layer of variability that demands adaptive opening strategy.

The key contributions of this work are:

• A formally defined chess variant that significantly alters tactical complexity through knight proliferation and board extension.
• An AI engine based on Minimax with alpha-beta pruning, incorporating an evaluation function specifically designed for the 8×9 board and five-knight dynamics.
• A complete web-based implementation with gamification features including timed play, a token economy, and a leaderboard system.
• Analysis of how increased knight count affects game tree branching factor and AI search performance.

2. Game Design

2.1 Board Extension

The Knight Chess board consists of 8 columns (files a–h) and 9 rows (ranks 1–9), adding one extra rank compared to the standard 8×8 board. The additional rank is inserted between the pawns and the back rank on each side, providing a buffer zone that changes the opening dynamics of the game. Pawns for White begin on rank 3 (instead of rank 2) and pawns for Black begin on rank 7 (instead of rank 7 on a standard board, now rank 7 on the 9-rank board), while back-rank pieces occupy ranks 1–2 and ranks 8–9 respectively.

The extended board has several strategic implications. First, it increases the number of moves required for pawns to reach the promotion rank, making pawn advancement a longer-term commitment. Second, it provides knights with more squares to occupy in the center, amplifying their tactical influence. Third, it slightly delays piece contact between the two sides, leading to richer middlegame positions as both players have additional time to develop their pieces.

2.2 Knight Replacement Mechanics

At the start of each game, three pawns per side are randomly selected and replaced with knights. Combined with the two standard knights already present in the initial setup, each player commands five knights. The random selection ensures positional variety: in some games, the additional knights may cluster on one wing, while in others they are distributed evenly across the board.

This randomized replacement mechanism serves multiple purposes:

• Opening diversity: Traditional chess openings become inapplicable; players must evaluate each starting configuration independently.
• Knight-centric tactics: With five knights, fork opportunities increase dramatically, and defensive patterns must account for simultaneous threats from multiple non-linear attackers.
• Reduced pawn structure rigidity: Fewer pawns mean a more open board, which further benefits knight mobility and tactical play.

2.3 Rules and Win Conditions

Knight Chess follows standard chess rules with the following modifications:

• The board is 8×9 instead of 8×8.
• Each side begins with 5 knights and 5 pawns (instead of 2 knights and 8 pawns).
• Each player has a 10-minute countdown timer; the player whose time expires loses.
• All other piece movements, capture rules, check, checkmate, and castling follow standard chess conventions adapted to the extended board.
• Pawn promotion occurs on the 9th rank (for White) or the 1st rank (for Black).

3. AI Engine

3.1 Minimax Algorithm with Alpha-Beta Pruning

The AI opponent employs the Minimax algorithm (Von Neumann, 1928) with alpha-beta pruning (Knuth & Moore, 1975) to search the game tree. Minimax is a recursive algorithm that evaluates all possible game states to a given depth, assuming both players play optimally. The maximizing player (AI) selects moves that maximize the evaluation score, while the minimizing player (human) is assumed to select moves that minimize it.

Alpha-beta pruning significantly reduces the number of nodes evaluated by eliminating branches that cannot influence the final decision. When a branch is provably worse than an already-explored alternative, the entire subtree is pruned. In the best case, alpha-beta pruning reduces the effective branching factor from b to b^1/2, allowing the search to reach approximately twice the depth within the same computational budget.

The core search procedure can be expressed as follows:

function minimax(node, depth, alpha, beta, maximizingPlayer):
    if depth == 0 or node is terminal:
        return evaluate(node)

    if maximizingPlayer:
        maxEval = -infinity
        for each child of node:
            eval = minimax(child, depth - 1, alpha, beta, false)
            maxEval = max(maxEval, eval)
            alpha = max(alpha, eval)
            if beta <= alpha:
                break   // beta cutoff
        return maxEval

    else:
        minEval = +infinity
        for each child of node:
            eval = minimax(child, depth - 1, alpha, beta, true)
            minEval = min(minEval, eval)
            beta = min(beta, eval)
            if beta <= alpha:
                break   // alpha cutoff
        return minEval

3.2 Evaluation Function

The evaluation function is the critical component that guides the AI's decision-making. For Knight Chess, the evaluation function considers the following factors:

Material valuation: Each piece type is assigned a base value reflecting its relative strength. Given the altered piece composition in Knight Chess, the knight's value is adjusted upward to reflect its increased tactical importance when five are present on the board.

Positional scoring: Piece-square tables assign bonuses or penalties based on board position. Knights receive higher bonuses for central squares on the 8×9 board, reflecting their increased value when controlling the expanded center. The piece-square tables are adapted from standard chess tables but rescaled for the 9-rank board geometry.

Mobility: The number of legal moves available to each side is incorporated as a secondary evaluation factor. Higher mobility generally indicates better piece coordination and more tactical opportunities.

King safety: Proximity of enemy pieces (especially knights) to the king is penalized. With five knights capable of delivering forks from multiple directions, king safety evaluation is weighted more heavily than in standard chess engines.

The composite evaluation function is:

3.3 Difficulty Levels and Search Depth

Knight Chess offers three difficulty levels that control the AI's search depth. Deeper search allows the AI to anticipate more moves ahead, resulting in stronger play at the cost of increased computation time.

The branching factor in Knight Chess is notably higher than in standard chess due to the presence of five knights per side. In standard chess, the average branching factor is approximately 35; in Knight Chess, the additional knight moves increase this to an estimated 42–50 in typical middlegame positions. Alpha-beta pruning mitigates this increase, but the effective search time at depth 5 remains a significant computational task, requiring careful optimization.

4. System Architecture

4.1 Frontend Architecture

The application is built on Next.js, a React-based framework that provides server-side rendering, file-system routing, and API routes within a unified project structure. The user interface is implemented with TypeScript for type safety and Tailwind CSS for responsive styling.

The game board is rendered as a responsive grid component that adapts the 8×9 layout to various screen sizes. Each square is an interactive element supporting click-based piece selection and move execution with visual highlights for legal moves, last move indication, and check alerts.

4.2 Game State Management

The game state is managed through React state hooks and encapsulates the following data:

• Board representation: A 9×8 two-dimensional array where each cell stores the piece type, color, and movement history (for castling and en passant eligibility).
• Turn state: Current player, move count, and game phase (opening, middlegame, endgame).
• Timer state: Remaining time for each player, managed via setInterval with per-second decrements.
• Game status: Active, check, checkmate, stalemate, or timeout.
• Move history: Complete list of moves in algebraic notation for replay and analysis.

4.3 AI Web Worker

The Minimax search is computationally intensive, particularly at depth 5. To prevent the UI from freezing during AI computation, the search algorithm runs in a dedicated Web Worker thread. This architecture separates the AI computation from the main rendering thread, ensuring that the game interface remains responsive while the AI evaluates positions.

The communication flow between the main thread and the AI worker follows a message-passing protocol:

When it is the AI's turn, the current board state and difficulty setting are serialized and sent to the worker. The worker executes the Minimax search, identifies the optimal move, and returns it to the main thread, which then applies the move to the board and updates the UI.

4.4 Authentication

User authentication is handled by NextAuth.js, which supports multiple authentication providers including Google OAuth and email-based sign-in. Authenticated sessions enable persistent player profiles, token balances, and leaderboard participation. Unauthenticated users can play against the AI but do not accumulate tokens or appear on the leaderboard.

5. Gamification

5.1 Token Economy

Knight Chess implements a token-based reward system to incentivize continued play and improvement. Players earn tokens by winning games against the AI, with the reward amount scaled by difficulty level:

The token system provides a persistent measure of player achievement. Tokens accumulate across sessions and serve as a proxy for overall skill progression. This mechanism draws on established gamification research demonstrating that tangible progress indicators increase player retention and motivation (Deterding et al., 2011).

5.2 Leaderboard System

A global leaderboard ranks all authenticated players by their total token count. The leaderboard serves as a social comparison mechanism, encouraging competitive play and providing a visible ranking that rewards consistent high-level performance. The leaderboard updates in real time as games conclude, providing immediate feedback on rank changes.

The leaderboard design follows best practices from competitive gaming platforms: displaying player name, total tokens, number of wins, and current rank. This transparency allows players to set concrete improvement goals and track their progress relative to the broader community.

6. Implementation Details

6.1 Technology Stack

6.2 Performance Considerations

The primary performance challenge is the AI search at depth 5. On a modern browser running on a mid-range device, the Minimax search with alpha-beta pruning at depth 5 completes within 2–8 seconds for typical middlegame positions. Several optimizations contribute to this performance:

• Move ordering: Captures and checks are evaluated first, improving alpha-beta cutoff rates and reducing the effective number of nodes explored.
• Web Worker isolation: Offloading computation to a dedicated thread ensures the UI remains responsive during search.
• Efficient board representation: The board is encoded as a flat array with precomputed move generation tables for each piece type, minimizing allocation overhead during search.
• Early termination: Checkmate and stalemate positions are detected immediately, preventing unnecessary subtree expansion.

6.3 Deployment

Knight Chess is deployed on Vercel's edge network, providing global low-latency access. The application is accessible at https://knight-chess.vercel.app. The serverless architecture handles authentication, leaderboard queries, and token management through Next.js API routes, while all game logic and AI computation execute client-side in the browser.

The source code is publicly available at https://github.com/romizone/knight-chess.

7. Conclusion and Future Work

Knight Chess demonstrates that targeted modifications to classical chess rules—specifically, board extension and knight proliferation—can produce a variant with meaningfully different strategic properties while remaining computationally tractable for traditional game tree search algorithms. The 8×9 board and five-knight configuration increase the average branching factor by approximately 20–40% compared to standard chess, creating richer tactical positions dominated by non-linear piece movement patterns.

The Minimax engine with alpha-beta pruning provides a competent AI opponent across three difficulty levels, with the depth-5 search at the Difficult setting offering a genuine challenge to experienced players. The Web Worker architecture ensures that this computational intensity does not compromise the user experience.

The gamification layer—combining timed play, token rewards, and a leaderboard—adds a competitive dimension that encourages sustained engagement. These elements are lightweight by design, avoiding the complexity of full ELO rating systems while still providing meaningful progress indicators.

Future directions include:

• Neural network evaluation: Replacing the handcrafted evaluation function with a learned evaluation model trained through self-play, following the approach pioneered by AlphaZero (Silver et al., 2018).
• Iterative deepening: Implementing iterative deepening with time management to dynamically adjust search depth based on position complexity and remaining clock time.
• Transposition tables: Adding Zobrist hashing and transposition tables to cache previously evaluated positions and avoid redundant computation.
• Multiplayer mode: Enabling real-time human-vs-human play via WebSocket connections, extending the platform beyond AI-only opponents.
• Opening book: Developing a curated opening book specific to Knight Chess configurations through automated self-play analysis.
• Mobile optimization: Adapting the AI computation budget for lower-powered mobile devices while maintaining competitive play quality.

References