diff --git a/src/client/api.ts b/src/client/api.ts
index 2f9d76ee..6d5148e7 100644
--- a/src/client/api.ts
+++ b/src/client/api.ts
@@ -42,6 +42,7 @@ export function useSocket(
     onMessage?: MessageHandler,
     onOpen?: () => void,
 ): SendMessage {
+    // handle sending a message and opening it
     const { sendMessage } = useWebSocket(WEBSOCKET_URL, {
         onOpen: () => {
             console.log("Connection established");
@@ -50,6 +51,7 @@ export function useSocket(
                 onOpen();
             }
         },
+        // handle what to do with the message
         onMessage: (msg: MessageEvent) => {
             const message = parseMessage(msg.data.toString());
             console.log("Handle message: " + message.toJson());
@@ -60,6 +62,7 @@ export function useSocket(
         },
     });
 
+    // handle how a message is sent
     const sendMessageHandler = useMemo(() => {
         return (message: Message) => {
             console.log("Sending message: " + message.toJson());
@@ -81,6 +84,7 @@ export async function post(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ): Promise<any> {
     try {
+        // run a post to the provided api path with the provided query
         let normalizedUrl = `/api${apiPath}`;
         if (query) {
             normalizedUrl += `?${new URLSearchParams(query)}`;
diff --git a/src/client/chessboard/board-container.tsx b/src/client/chessboard/board-container.tsx
index b298104a..f8120c77 100644
--- a/src/client/chessboard/board-container.tsx
+++ b/src/client/chessboard/board-container.tsx
@@ -9,6 +9,11 @@ interface BoardContainerProps extends PropsWithChildren {
     rotation: number;
 }
 
+/**
+ * A container to deal with chessboard resizing
+ * @param props - width handler and inner elements
+ * @returns
+ */
 export function BoardContainer(props: BoardContainerProps) {
     const [transform, setTransform] = useState<Transform | undefined>();
 
@@ -20,6 +25,7 @@ export function BoardContainer(props: BoardContainerProps) {
         setTransform(transform);
     };
 
+    // returns the resizable container
     return (
         <ResizeSensor onResize={handleResize}>
             <div id="chess-container">
diff --git a/src/client/chessboard/board-transform.ts b/src/client/chessboard/board-transform.ts
index 623b6f74..90279bff 100644
--- a/src/client/chessboard/board-transform.ts
+++ b/src/client/chessboard/board-transform.ts
@@ -17,7 +17,10 @@ export function computeChessboardTransform(
     const width = Math.min(canvasHeight, canvasWidth) * scale;
     const height = width;
 
+    // shifts the x and y
     const xShift = (canvasWidth - width) / 2;
     const yShift = (canvasHeight - height) / 2;
+
+    // return the shift
     return { left: xShift, top: yShift, height, width };
 }
diff --git a/src/client/chessboard/chessboard-wrapper.tsx b/src/client/chessboard/chessboard-wrapper.tsx
index 4e481c60..d09cd2c4 100644
--- a/src/client/chessboard/chessboard-wrapper.tsx
+++ b/src/client/chessboard/chessboard-wrapper.tsx
@@ -9,6 +9,9 @@ import { customSquareRenderer } from "./custom-square-renderer";
 import { CustomSquareContext } from "./custom-square-context";
 import { BoardOrientation } from "react-chessboard/dist/chessboard/types";
 
+/**
+ * an interface of relevant properties for chessboard
+ */
 interface ChessboardWrapperProps {
     /**
      * The chess.js instance displayed by this class.
@@ -28,6 +31,13 @@ interface ChessboardWrapperProps {
     onMove: (move: Move) => void;
 }
 
+/**
+ * Creates a chessboard that uses our custom properties inside a board container
+ *
+ * These include width, moves, promotions, piece dragging, square highlighting, and
+ * @param props - chess(ChessEngine), side, onMove
+ * @returns JSX.Element chessboard
+ */
 export function ChessboardWrapper(props: ChessboardWrapperProps): JSX.Element {
     const { chess, side, onMove } = props;
 
@@ -40,6 +50,7 @@ export function ChessboardWrapper(props: ChessboardWrapperProps): JSX.Element {
         Square | undefined
     >();
 
+    // promotion states
     const [isPromoting, setIsPromoting] = useState(false);
 
     const [manualPromotionSquare, setManualPromotionSquare] = useState<
@@ -64,12 +75,17 @@ export function ChessboardWrapper(props: ChessboardWrapperProps): JSX.Element {
         );
     };
 
+    /**
+     * make to move passed in and unset lastClickedSquare
+     *
+     * @param move - the move made
+     */
     const doMove = (move: Move): void => {
         onMove(move);
         setLastClickedSquare(undefined);
     };
 
-    //set the side to their respective colors
+    //set the side to their respective colors and orientations
     switch (props.side) {
         case Side.WHITE:
             if (orientation !== "white") setOrientation("white");
@@ -95,9 +111,11 @@ export function ChessboardWrapper(props: ChessboardWrapperProps): JSX.Element {
     if (width !== undefined) {
         chessboard = (
             <Chessboard
-                boardOrientation={orientation}
+                // set up the board
+                boardOrientation={side === Side.WHITE ? "white" : "black"}
                 boardWidth={width}
                 position={chess.fen}
+                // do a promotion check
                 onPromotionCheck={(from: Square, to: Square) => {
                     const promoting = chess.checkPromotion(from, to);
                     setIsPromoting(promoting);
@@ -105,6 +123,7 @@ export function ChessboardWrapper(props: ChessboardWrapperProps): JSX.Element {
                 }}
                 showPromotionDialog={manualPromotionSquare !== undefined}
                 promotionToSquare={manualPromotionSquare}
+                // handle dragging and dropping pieces
                 onPieceDrop={(
                     from: Square,
                     to: Square,
@@ -130,17 +149,20 @@ export function ChessboardWrapper(props: ChessboardWrapperProps): JSX.Element {
                                 promotion: isPromoting ? piece : undefined,
                             });
                         }
+
                         // Reset state
                         setIsPromoting(false);
                         return true;
                     }
                     return false;
                 }}
+                // when you start dragging, unset clicked square
                 onPieceDragBegin={(_, square: Square) => {
                     if (square !== lastClickedSquare) {
                         setLastClickedSquare(undefined);
                     }
                 }}
+                // handle square clicking
                 onSquareClick={(square: Square) => {
                     setManualPromotionSquare(undefined);
 
@@ -149,11 +171,13 @@ export function ChessboardWrapper(props: ChessboardWrapperProps): JSX.Element {
                         lastClickedSquare !== undefined &&
                         isLegalMove(lastClickedSquare, square);
 
+                    // check if the square is legal
                     if (isSquareLegalMove) {
                         if (chess.checkPromotion(lastClickedSquare, square)) {
                             // Manually show promotion dialog
                             setManualPromotionSquare(square);
                         } else {
+                            // make the move normally
                             doMove({
                                 from: lastClickedSquare,
                                 to: square,
@@ -178,6 +202,7 @@ export function ChessboardWrapper(props: ChessboardWrapperProps): JSX.Element {
         );
     }
 
+    // return the created chessboard inside the board container
     return (
         <BoardContainer
             side={side}
diff --git a/src/client/chessboard/custom-square-renderer.tsx b/src/client/chessboard/custom-square-renderer.tsx
index 56a29de4..ac8e54ee 100644
--- a/src/client/chessboard/custom-square-renderer.tsx
+++ b/src/client/chessboard/custom-square-renderer.tsx
@@ -8,6 +8,9 @@ import {
 } from "./svg-components";
 import { CustomSquareContext } from "./custom-square-context";
 
+/**
+ * A renderer for the square dots and piece highlighting
+ */
 export const customSquareRenderer = forwardRef<
     HTMLDivElement,
     CustomSquareProps
@@ -19,6 +22,7 @@ export const customSquareRenderer = forwardRef<
     let lastMoveHighlight: ReactElement | null = null;
     let clickedPieceHighlight: ReactElement | null = null;
 
+    // highlight the last move made
     const lastMove = chess.getLastMove();
     if (
         lastMove !== undefined &&
@@ -32,6 +36,7 @@ export const customSquareRenderer = forwardRef<
         );
     }
 
+    // highlight clicked pieces
     if (
         lastClickedSquare !== undefined &&
         lastClickedSquare === props.square &&
@@ -46,6 +51,7 @@ export const customSquareRenderer = forwardRef<
         );
     }
 
+    // highlight legal squares and capture opportunities
     if (legalSquares.includes(props.square)) {
         // Square should be highlighted
         if (chess.hasPiece(props.square)) {
@@ -57,11 +63,12 @@ export const customSquareRenderer = forwardRef<
                 />
             );
         } else {
-            //Square is empty
+            // Square is empty
             selectElement = <CenterDot />;
         }
     }
 
+    // return all the highlights inside a div
     return (
         <div style={props.style} ref={ref}>
             {clickedPieceHighlight}
diff --git a/src/client/chessboard/svg-components.tsx b/src/client/chessboard/svg-components.tsx
index 1c7567f0..f0d3d30e 100644
--- a/src/client/chessboard/svg-components.tsx
+++ b/src/client/chessboard/svg-components.tsx
@@ -80,6 +80,9 @@ export function SquareHighlight(props: PieceSquareProps) {
     );
 }
 
+/**
+ * SVG of the piece clicked
+ */
 export function ClickedPiece(props: PieceSquareProps) {
     return (
         <div
diff --git a/src/client/debug/debug.tsx b/src/client/debug/debug.tsx
index e0d66dcc..37c44d93 100644
--- a/src/client/debug/debug.tsx
+++ b/src/client/debug/debug.tsx
@@ -15,10 +15,12 @@ export function Debug() {
     const [selectedRobotId, setSelectedRobotId] = useState<
         string | undefined
     >();
-    const navigate = useNavigate();
 
+    // helper functions
+    const navigate = useNavigate();
     const sendMessage = useSocket();
 
+    // get all the registered robots
     useEffect(() => {
         const fetchIds = async () => {
             const response = await get("/get-ids");
@@ -27,6 +29,7 @@ export function Debug() {
         fetchIds();
     }, [setRobotIds]);
 
+    // create the select and move buttons
     let body: ReactNode;
     if (robotIds === undefined) {
         body = <Spinner intent="primary" />;
@@ -65,6 +68,7 @@ export function Debug() {
         );
     }
 
+    // return the dialog with buttons for home and simulator
     return (
         <Card>
             <Button
diff --git a/src/client/debug/drive-robot.tsx b/src/client/debug/drive-robot.tsx
index f36bb324..fe23ce3a 100644
--- a/src/client/debug/drive-robot.tsx
+++ b/src/client/debug/drive-robot.tsx
@@ -21,12 +21,12 @@ function almostEqual(v1: number, v2: number, epsilon: number = 0.01): boolean {
  * A component which can be used to drive an individual robot around.
  */
 export function DriveRobot(props: DriveRobotProps) {
-    //state variable for handling the power levels of the robot
+    // state variable for handling the power levels of the robot
     const [power, setPower] = useState({ left: 0, right: 0 });
     const [prevPad, setPrevPad] = useState({ left: 0, right: 0 });
     const [prev, setPrev] = useState({ left: 0, right: 0 });
 
-    //useEffect hook to send the power levels to the robot if there is a change in the power levels
+    // useEffect hook to send the power levels to the robot if there is a change in the power levels
     useEffect(() => {
         if (
             almostEqual(prev.left, power.left) &&
@@ -40,6 +40,7 @@ export function DriveRobot(props: DriveRobotProps) {
         setPrev({ left: power.left, right: power.right });
     }, [props, power.left, power.right, prev]);
 
+    // allow use of a gamepad
     useEffect(() => {
         if (!navigator.getGamepads) {
             console.log("Gamepad API not supported");
@@ -67,6 +68,7 @@ export function DriveRobot(props: DriveRobotProps) {
                     ) {
                         continue;
                     }
+                    // set power based on pad values
                     setPower({ left: padLeftPower, right: padRightPower });
                     setPrevPad({ left: padLeftPower, right: padRightPower });
                 }
@@ -83,6 +85,7 @@ export function DriveRobot(props: DriveRobotProps) {
         };
     }, [props, prevPad]);
 
+    // the move types and corresponding motor powers
     const handleStopMove = useCallback(() => {
         setPower({ left: 0, right: 0 });
     }, []);
@@ -100,6 +103,7 @@ export function DriveRobot(props: DriveRobotProps) {
         setPower({ left: -0.5, right: 0.5 });
     }, []);
 
+    // handle when the left and right powers change
     const handleLeftPowerChange = useCallback(
         (value: number) => {
             setPower({ left: value, right: power.right });
@@ -113,6 +117,7 @@ export function DriveRobot(props: DriveRobotProps) {
         [power.left],
     );
 
+    /** use wasd and arrows to control robots */
     const hotkeys = useMemo(
         () => [
             {
@@ -189,6 +194,7 @@ export function DriveRobot(props: DriveRobotProps) {
         ],
     );
 
+    // show instructions and on screen buttons
     const { handleKeyDown, handleKeyUp } = useHotkeys(hotkeys);
 
     const convertJoystickXYToMotorPowers = useCallback(
diff --git a/src/client/debug/drive-slider.tsx b/src/client/debug/drive-slider.tsx
index 6fc28623..15c62706 100644
--- a/src/client/debug/drive-slider.tsx
+++ b/src/client/debug/drive-slider.tsx
@@ -5,6 +5,11 @@ interface DriveSliderProps {
     onChange: (value: number) => void;
 }
 
+/**
+ * creates a slider to show power values in debug driving
+ * @param props - the value of the slider
+ * @returns
+ */
 export function DriveSlider(props: DriveSliderProps) {
     return (
         <Slider
diff --git a/src/client/debug/select-robot.tsx b/src/client/debug/select-robot.tsx
index 4ac479de..ac7052d2 100644
--- a/src/client/debug/select-robot.tsx
+++ b/src/client/debug/select-robot.tsx
@@ -1,6 +1,13 @@
 import { Button, MenuItem } from "@blueprintjs/core";
 import { ItemRenderer, Select } from "@blueprintjs/select";
 
+/**
+ * Creates a robot menu item
+ *
+ * @param robotId - id of the robot
+ * @param param1 - handlers for active, focus, and click
+ * @returns a menu item for the robot id
+ */
 const renderRobotIds: ItemRenderer<string> = (
     robotId,
     { modifiers, handleFocus, handleClick },
@@ -17,6 +24,9 @@ const renderRobotIds: ItemRenderer<string> = (
     );
 };
 
+/**
+ * Ids, selected id, and on robot selected function
+ */
 interface SelectRobotProps {
     robotIds: string[];
     selectedRobotId: string | undefined;
@@ -24,12 +34,16 @@ interface SelectRobotProps {
 }
 
 /**
- * Creates a selector for a robot.
+ * Creates the robot selector dialog
+ *
+ * @param props - robot ids and select function
+ * @returns - select dropdown
  */
 export function SelectRobot(props: SelectRobotProps) {
     const hasSelection = props.selectedRobotId !== undefined;
 
     return (
+        // get all the robot ids in the list for selection
         <Select<string>
             items={props.robotIds}
             itemRenderer={renderRobotIds}
diff --git a/src/client/debug/set-robot-variable.tsx b/src/client/debug/set-robot-variable.tsx
index 8bbc11b2..e1a010d5 100644
--- a/src/client/debug/set-robot-variable.tsx
+++ b/src/client/debug/set-robot-variable.tsx
@@ -8,6 +8,11 @@ interface SetRobotVariableProps {
     sendMessage: SendMessage;
 }
 
+/**
+ * set a variable for a robot
+ * @param props - function for setting the variable
+ * @returns - setup form
+ */
 export function SetRobotVariable(props: SetRobotVariableProps): JSX.Element {
     const [variableName, setVariableName] = useState("");
     const [variableValue, setVariableValue] = useState("");
diff --git a/src/client/debug/simulator.tsx b/src/client/debug/simulator.tsx
index c2393c81..6c8c799e 100644
--- a/src/client/debug/simulator.tsx
+++ b/src/client/debug/simulator.tsx
@@ -12,8 +12,14 @@ import "./simulator.scss";
 
 const tileSize = 60;
 const robotSize = tileSize / 2;
-
 const cellCount = 12;
+
+/**
+ * Creates a robot simulator for testing robot commands
+ *
+ * does not require physical robots to be connected
+ * @returns the simulator screen as a card
+ */
 export function Simulator() {
     const navigate = useNavigate();
 
@@ -26,6 +32,7 @@ export function Simulator() {
               payload: { robotId: string; state: SimulatedRobotLocation };
           };
 
+    /** compress robot states for performance */
     const robotStateReducer = (
         state: RobotState,
         action: Action,
@@ -48,6 +55,7 @@ export function Simulator() {
         { message: SimulatorUpdateMessage; ts: Date }[]
     >([]);
 
+    // update the simulator when a message comes in
     useSocket((message) => {
         if (message instanceof SimulatorUpdateMessage) {
             dispatch({
@@ -58,6 +66,7 @@ export function Simulator() {
         }
     });
 
+    // fetch the current state of the robots and update all the sim robots
     const fetchRobotState = async () => {
         const { robotState, messages } = await get(
             "/get-simulator-robot-state",
@@ -72,6 +81,7 @@ export function Simulator() {
         fetchRobotState();
     }, []);
 
+    // get /do-smth to move the robot randomly
     const moveRandomBot = async () => {
         const response = await get("/do-smth");
         if (!response.ok) {
@@ -86,6 +96,12 @@ export function Simulator() {
         }
     }, [messageLog]);
 
+    /**
+     * make the simulator screen
+     *
+     * made by creating an array for the entire chessboard
+     * add all the robots on top of the board
+     */
     return (
         <Card>
             <Button
@@ -187,6 +203,11 @@ export function Simulator() {
     );
 }
 
+/**
+ * open a simulator frame in a editor
+ * @param frame - the frame to view
+ * @returns nothing
+ */
 const openInEditor = async (frame: StackFrame) => {
     if (!frame) {
         console.warn("No stack frame provided for opening in editor");
@@ -200,6 +221,11 @@ const openInEditor = async (frame: StackFrame) => {
     await fetch(`/__open-in-editor?${params.toString()}`);
 };
 
+/**
+ * the message log, used to show the commands sent to the robot
+ * @param props - the message and time
+ * @returns the clickable message box
+ */
 function LogEntry(props: { message: SimulatorUpdateMessage; ts: Date }) {
     const { message, ts } = props;
 
@@ -287,6 +313,11 @@ function LogEntry(props: { message: SimulatorUpdateMessage; ts: Date }) {
     );
 }
 
+/**
+ * Creates a robot icon to show in the simulator
+ * @param props - the robot position and id
+ * @returns the robot icon scaled to the board
+ */
 function Robot(props: {
     pos: SimulatedRobotLocation;
     robotId: string;
diff --git a/src/client/game/draw-dialog.tsx b/src/client/game/draw-dialog.tsx
index 2be7462b..47e2d311 100644
--- a/src/client/game/draw-dialog.tsx
+++ b/src/client/game/draw-dialog.tsx
@@ -20,6 +20,11 @@ interface DrawDialogProps {
     sendMessage: SendMessage;
 }
 
+/**
+ * allows the player to offer a draw to the other people
+ * @param props - function for sending messages
+ * @returns - draw dialog
+ */
 export function OfferDrawDialog(props: DrawDialogProps) {
     const [isOpen, setIsOpen] = useState(true);
     const actions = (
@@ -61,6 +66,11 @@ export function OfferDrawDialog(props: DrawDialogProps) {
     );
 }
 
+/**
+ * Allow a player to accept another player's draw request
+ * @param props - function for sending messages
+ * @returns - draw accept dialog
+ */
 export function AcceptDrawDialog(props: DrawDialogProps) {
     const [isOpen, setIsOpen] = useState(true);
     const actions = (
diff --git a/src/client/game/game-end-dialog.tsx b/src/client/game/game-end-dialog.tsx
index 943acbff..36dc7795 100644
--- a/src/client/game/game-end-dialog.tsx
+++ b/src/client/game/game-end-dialog.tsx
@@ -20,10 +20,17 @@ interface GameEndDialogProps {
     reason: GameEndReason;
     side: Side;
 }
-
+/**
+ * creates the game ending dialog with a continue button
+ *
+ * @param props - the game end reason and side
+ * @returns
+ */
 export function GameEndDialog(props: GameEndDialogProps) {
     const [isOpen, setIsOpen] = useState(true);
     const navigate = useNavigate();
+
+    /** continue button */
     const actions = (
         <Button
             text="Continue"
@@ -34,6 +41,8 @@ export function GameEndDialog(props: GameEndDialogProps) {
             }}
         />
     );
+
+    // return the dialog with the button and game over reason
     return (
         <Dialog
             isOpen={isOpen}
@@ -53,7 +62,15 @@ export function GameEndDialog(props: GameEndDialogProps) {
     );
 }
 
+/**
+ * returns the appropriate game over icon based on the reason and side
+ *
+ * @param reason - the reason the game ended
+ * @param side - the current side
+ * @returns game over icon
+ */
 function gameOverIcon(reason: GameEndReason, side: Side) {
+    // check which side won
     const whiteWon =
         reason === GameFinishedReason.BLACK_CHECKMATED ||
         reason === GameInterruptedReason.BLACK_RESIGNED;
@@ -61,9 +78,12 @@ function gameOverIcon(reason: GameEndReason, side: Side) {
         reason === GameFinishedReason.WHITE_CHECKMATED ||
         reason === GameInterruptedReason.WHITE_RESIGNED;
 
+    // checks which side is asking and assigns win/lost accordingly
     const won = side === Side.WHITE ? whiteWon : blackWon;
     const lost = side === Side.WHITE ? blackWon : whiteWon;
     // const draw = !blackWon && !whiteWon;
+
+    // return the correct icon and intent
     if (won) {
         return (
             <Icon
@@ -91,6 +111,12 @@ function gameOverIcon(reason: GameEndReason, side: Side) {
     );
 }
 
+/**
+ * returns the game over reason message string
+ *
+ * @param reason - the game end reason
+ * @returns the game end message string
+ */
 function gameOverMessage(reason: GameEndReason) {
     switch (reason) {
         case GameFinishedReason.WHITE_CHECKMATED:
diff --git a/src/client/game/game.tsx b/src/client/game/game.tsx
index 0bf88112..fa02514d 100644
--- a/src/client/game/game.tsx
+++ b/src/client/game/game.tsx
@@ -24,7 +24,7 @@ import { NonIdealState, Spinner } from "@blueprintjs/core";
 import { AcceptDrawDialog, OfferDrawDialog } from "./draw-dialog";
 
 /**
- * Creates a MessageHandler function.
+ * Creates a MessageHandler function to handle move messages and game interruptions.
  */
 function getMessageHandler(
     chess: ChessEngine,
@@ -43,7 +43,11 @@ function getMessageHandler(
         }
     };
 }
-
+/**
+ * Creates required message, game, and move handling functions before inserting them into a chessboard wrapper
+ *
+ * @returns chessboard wrapper with current side and message handler
+ */
 export function Game(): JSX.Element {
     const [chess, setChess] = useState(new ChessEngine());
     const [gameInterruptedReason, setGameInterruptedReason] =
@@ -51,6 +55,7 @@ export function Game(): JSX.Element {
     const [gameHoldReason, setGameHoldReason] = useState<GameHoldReason>();
     const [rotation, setRotation] = useState<number>(0);
 
+    /** send any messages using our defined message handler inside a message socket for handling */
     const sendMessage = useSocket(
         getMessageHandler(
             chess,
@@ -60,6 +65,7 @@ export function Game(): JSX.Element {
         ),
     );
 
+    // checks if a game is currently active
     const { isPending, data, isError } = useEffectQuery(
         "game-state",
         async () => {
@@ -74,6 +80,7 @@ export function Game(): JSX.Element {
         false,
     );
 
+    // if a game is pending, show a loading screen while waiting
     if (isPending) {
         return (
             <NonIdealState
@@ -81,12 +88,14 @@ export function Game(): JSX.Element {
                 title="Loading..."
             />
         );
+        // go to /home if error
     } else if (isError) {
         return <Navigate to="/home" />;
     }
 
     const side = data.side;
 
+    // check if the game has ended or been interrupted
     let gameEndReason: GameEndReason | undefined = undefined;
     const gameFinishedReason = chess.getGameFinishedReason();
     if (gameFinishedReason !== undefined) {
@@ -96,6 +105,7 @@ export function Game(): JSX.Element {
         gameEndReason = gameInterruptedReason;
     }
 
+    /** create a game end dialog with the game end reason, if defined */
     const gameEndDialog =
         gameEndReason !== undefined ?
             <GameEndDialog reason={gameEndReason} side={side} />
@@ -115,11 +125,13 @@ export function Game(): JSX.Element {
             :   null
         :   null;
 
+    /** make moves by making a copy of the chessboard and sending the move message */
     const handleMove = (move: Move): void => {
         setChess(chess.copy(move));
         sendMessage(new MoveMessage(move));
     };
 
+    // return the chessboard wrapper, navbar, and potential end dialog
     return (
         <>
             <NavbarMenu
diff --git a/src/client/game/navbar-menu.tsx b/src/client/game/navbar-menu.tsx
index aca811db..ede1556d 100644
--- a/src/client/game/navbar-menu.tsx
+++ b/src/client/game/navbar-menu.tsx
@@ -24,6 +24,12 @@ interface NavbarMenuProps {
     setRotation: Dispatch<React.SetStateAction<number>>; //set state type
 }
 
+/**
+ * Creates a navbar with a title and the abort, resign, and debug buttons
+ *
+ * @param props - message handler for abort/resign
+ * @returns
+ */
 export function NavbarMenu(props: NavbarMenuProps): JSX.Element {
     // Store react router state for game
     const navigate = useNavigate();
diff --git a/src/client/home.tsx b/src/client/home.tsx
index bcdb67ff..42ac9b5e 100644
--- a/src/client/home.tsx
+++ b/src/client/home.tsx
@@ -5,13 +5,14 @@ import { NonIdealState, Spinner } from "@blueprintjs/core";
 /**
  * The home route.
  *
- * Redirects to /game or /lobby automatically based on a route query parameter.
+ * Redirects to /game or /lobby automatically based on whether there is an active game.
  */
 export function Home() {
     const { isPending, data } = useEffectQuery("client-information", () =>
         get("/client-information"),
     );
 
+    // show loading if the message is pending
     if (isPending) {
         return (
             <NonIdealState
diff --git a/src/client/puzzle/puzzle.tsx b/src/client/puzzle/puzzle.tsx
index bb6d901c..ce140fc5 100644
--- a/src/client/puzzle/puzzle.tsx
+++ b/src/client/puzzle/puzzle.tsx
@@ -1,3 +1,8 @@
+/**
+ * Allows the client to choose a chess puzzle to play
+ *
+ * @returns puzzle selection
+ */
 export function Puzzle() {
     return <></>;
 }
diff --git a/src/client/setup/lobby.tsx b/src/client/setup/lobby.tsx
index 05a023a6..84a9451b 100644
--- a/src/client/setup/lobby.tsx
+++ b/src/client/setup/lobby.tsx
@@ -6,18 +6,25 @@ import { useSocket, useEffectQuery, get } from "../api";
 import { ClientType } from "../../common/client-types";
 import { Navigate } from "react-router-dom";
 
+/**
+ * check for an active game and waits for one or forwards to setup
+ *
+ * @returns a setup base with the loading screen or a redirect to /game
+ */
 export function Lobby() {
     const { isPending, data } = useEffectQuery("client-information", () =>
         get("/client-information"),
     );
     const navigate = useNavigate();
 
+    // use a socket to wait for game started
     useSocket((message) => {
         if (message instanceof GameStartedMessage) {
             navigate("/game");
         }
     });
 
+    // show a loading screen if the message is pending
     if (isPending) {
         return (
             <SetupBase>
@@ -29,6 +36,7 @@ export function Lobby() {
         );
     }
 
+    // navigate to setup if the client is a host, or show a loading screen if waiting
     if (data.clientType === ClientType.HOST) {
         return <Navigate to="/setup" />;
     } else {
diff --git a/src/client/setup/setup-base.tsx b/src/client/setup/setup-base.tsx
index c424f7a6..384630ec 100644
--- a/src/client/setup/setup-base.tsx
+++ b/src/client/setup/setup-base.tsx
@@ -9,6 +9,12 @@ interface SetupBaseProps extends PropsWithChildren {
     actions?: ReactNode;
 }
 
+/**
+ * Create the background chessboard and applies a dialog on top
+ *
+ * @param props - any dialogs that need to be shown on screen
+ * @returns
+ */
 export function SetupBase(props: SetupBaseProps): JSX.Element {
     return (
         <>
diff --git a/src/client/setup/setup-game.tsx b/src/client/setup/setup-game.tsx
index 224b0b02..8ae3a4e3 100644
--- a/src/client/setup/setup-game.tsx
+++ b/src/client/setup/setup-game.tsx
@@ -5,6 +5,7 @@ import { Difficulty, GameType } from "../../common/client-types";
 import { Side } from "../../common/game-types";
 import { post } from "../api";
 
+/** User's desired side, b/w/r */
 enum DesiredSide {
     WHITE = "white",
     BLACK = "black",
@@ -15,6 +16,12 @@ interface SetupGameProps {
     gameType: GameType;
 }
 
+/**
+ * Creates the dialog for setting up human and computer games
+ *
+ * @param props - the chosen game type
+ * @returns setup dialog
+ */
 export function SetupGame(props: SetupGameProps) {
     const navigate = useNavigate();
     const [difficulty, setDifficulty] = useState(Difficulty.BEGINNER);
@@ -22,6 +29,9 @@ export function SetupGame(props: SetupGameProps) {
         DesiredSide.WHITE,
     );
 
+    /**
+     * create the difficulty slide if the game type is computer
+     */
     const difficultySlider =
         props.gameType === GameType.COMPUTER ?
             <DifficultySlider
@@ -30,13 +40,14 @@ export function SetupGame(props: SetupGameProps) {
             />
         :   null;
 
+    /** the select side dropdown */
     const selectSide = (
         <SelectSide
             desiredSide={desiredSide}
             onDesiredSideChange={setDesiredSide}
         />
     );
-
+    /** difficulty and side buttons */
     const options = (
         <>
             {difficultySlider}
@@ -44,17 +55,20 @@ export function SetupGame(props: SetupGameProps) {
         </>
     );
 
+    // the title for the dialog
     const title =
         props.gameType === GameType.COMPUTER ?
             "Play Against the Computer"
         :   "Setup Game";
 
+    // handles passing user choices to the api
     const submit = (
         <Button
             text="Play"
             icon="arrow-right"
             intent="primary"
             onClick={async () => {
+                // convert the side selected to the side enum
                 let selectedSide: Side;
                 if (desiredSide === DesiredSide.RANDOM) {
                     selectedSide =
@@ -66,6 +80,7 @@ export function SetupGame(props: SetupGameProps) {
                         :   Side.BLACK;
                 }
 
+                // pass the user choice to api
                 let promise: Promise<unknown>;
                 if (props.gameType === GameType.COMPUTER) {
                     promise = post("/start-computer-game", {
@@ -106,6 +121,12 @@ interface DifficultySliderProps {
     onDifficultyChange: Dispatch<Difficulty>;
 }
 
+/**
+ * Creates a difficulty slider from 0 to 3
+ *
+ * @param props - difficulty change handler
+ * @returns slider
+ */
 function DifficultySlider(props: DifficultySliderProps) {
     return (
         <>
@@ -115,6 +136,7 @@ function DifficultySlider(props: DifficultySliderProps) {
                     intent="primary"
                     value={props.difficulty}
                     onChange={props.onDifficultyChange}
+                    // return string based on user chosen value
                     labelRenderer={(value) => {
                         if (value === Difficulty.BABY) {
                             return "Baby";
@@ -139,6 +161,11 @@ interface SelectSideProps {
     onDesiredSideChange: Dispatch<DesiredSide>;
 }
 
+/**
+ * Creates a dialog for the user to choose their side
+ * @param props - function for handling user side choice
+ * @returns - user side dialog
+ */
 function SelectSide(props: SelectSideProps) {
     return (
         <>
diff --git a/src/client/setup/setup.tsx b/src/client/setup/setup.tsx
index e12ab56b..21c6812a 100644
--- a/src/client/setup/setup.tsx
+++ b/src/client/setup/setup.tsx
@@ -13,6 +13,11 @@ enum SetupType {
     PUZZLE = "puzzle",
 }
 
+/**
+ * Lets the host choose a game type and includes the debug button
+ *
+ * @returns A setup base with the proper setup dialog
+ */
 export function Setup(): JSX.Element {
     const [setupType, setSetupType] = useState(SetupType.MAIN);
     const { isPending, data } = useEffectQuery("client-information", () =>
@@ -30,6 +35,7 @@ export function Setup(): JSX.Element {
         );
     }
 
+    //if the client is a host, let them choose a game type
     if (data.clientType === ClientType.HOST) {
         return (
             <SetupBase>
@@ -55,10 +61,19 @@ export function Setup(): JSX.Element {
     }
 }
 
+/**
+ * Triggers a state change in setup type
+ */
 interface SetupMainProps {
     onPageChange: Dispatch<SetupType>;
 }
 
+/**
+ * The initial buttons for choosing game types
+ *
+ * @param props - the hook for changing setup type
+ * @returns Setup buttons and debug button
+ */
 function SetupMain(props: SetupMainProps) {
     const navigate = useNavigate();
     const debugButton = (
@@ -70,6 +85,7 @@ function SetupMain(props: SetupMainProps) {
         />
     );
 
+    /** computer, human, and puzzle buttons */
     const actions = (
         <>
             <Button
@@ -96,6 +112,7 @@ function SetupMain(props: SetupMainProps) {
         </>
     );
 
+    // return all the buttons and the title
     return (
         <>
             {debugButton}
diff --git a/src/common/chess-engine.ts b/src/common/chess-engine.ts
index 8e37ba63..8c986306 100644
--- a/src/common/chess-engine.ts
+++ b/src/common/chess-engine.ts
@@ -4,6 +4,11 @@ import { GameFinishedReason } from "./game-end-reasons";
 import { Difficulty } from "./client-types";
 import { Move, PieceType, Side } from "./game-types";
 
+/**
+ * Creates the engine to manage chess game
+ *
+ * includes movement, ai moves, castling, en passant, and game finished
+ */
 export class ChessEngine {
     private chess: Chess;
 
@@ -30,18 +35,22 @@ export class ChessEngine {
         return copy;
     }
 
+    /** get the board position */
     get fen(): string {
         return this.chess.fen();
     }
 
+    /** get the board history */
     get pgn(): string {
         return this.chess.pgn();
     }
 
+    /** load a board from history */
     loadPgn(pgn: string) {
         this.chess.loadPgn(pgn);
     }
 
+    /** get the last move made */
     getLastMove() {
         const moves = this.chess.history({ verbose: true });
         return moves.length > 0 ? moves[moves.length - 1] : undefined;
@@ -144,6 +153,11 @@ export class ChessEngine {
         return this.getPieceTypeFromSquare(move.from) as PieceType;
     }
 
+    /**
+     * gets ALL legal moves from the provided square
+     * @param square - from square
+     * @returns - possible to squares
+     */
     getLegalMoves(square?: Square) {
         return this.chess.moves({
             square,
@@ -151,6 +165,11 @@ export class ChessEngine {
         });
     }
 
+    /**
+     * returns a square's legal moves as a map
+     * @param square - from square
+     * @returns - possible to squares
+     */
     getLegalSquares(square?: Square): Square[] {
         return this.getLegalMoves(square).map((move) => move.to);
     }
@@ -177,6 +196,11 @@ export class ChessEngine {
         return from[1] === "2" && to[1] === "1";
     }
 
+    /**
+     * makes an ai move based on the selected difficulty
+     * @param difficulty - a value from 0 to 4 for the ai
+     * @returns - the move made
+     */
     makeAiMove(difficulty: Difficulty): Move {
         // result is an object e.g. { "A1": "A2" }
         const result = aiMove(this.fen, difficulty);
@@ -196,6 +220,10 @@ export class ChessEngine {
         return this.makeMove({ from, to });
     }
 
+    /**
+     * checks if and how the game has ended
+     * @returns - a game finished reason from the enum
+     */
     getGameFinishedReason(): GameFinishedReason | undefined {
         if (this.chess.isCheckmate()) {
             // If it's your turn, you lost
diff --git a/src/common/game-end-reasons.ts b/src/common/game-end-reasons.ts
index df5894bb..4e6cf522 100644
--- a/src/common/game-end-reasons.ts
+++ b/src/common/game-end-reasons.ts
@@ -1,5 +1,8 @@
 export type GameEndReason = GameFinishedReason | GameInterruptedReason;
 
+/**
+ * map possible end reasons to their string versions
+ */
 export enum GameFinishedReason {
     /**
      * White is checkmated.
diff --git a/src/common/game-types.ts b/src/common/game-types.ts
index 6cf6201a..46ab194e 100644
--- a/src/common/game-types.ts
+++ b/src/common/game-types.ts
@@ -29,9 +29,18 @@ export function oppositeSide(side: Side) {
     return side === Side.WHITE ? Side.BLACK : Side.WHITE;
 }
 
+/**
+ * get the robot's start heading based on the side it is on
+ * @param side - the current side
+ * @returns angle in radians
+ */
 export function getStartHeading(side: Side) {
     return side === Side.WHITE ? 90 * DEGREE : 270 * DEGREE;
 }
+
+/**
+ * holds the piece side, type, robot, and square
+ */
 export class Piece {
     constructor(
         public readonly side: Side,
@@ -41,6 +50,9 @@ export class Piece {
     ) {}
 }
 
+/**
+ * the movement shown as FROM one square TO another, and if it is a promotion
+ */
 export interface Move {
     from: Square;
     to: Square;
diff --git a/src/common/message/drive-robot-message.ts b/src/common/message/drive-robot-message.ts
new file mode 100644
index 00000000..7080c5f0
--- /dev/null
+++ b/src/common/message/drive-robot-message.ts
@@ -0,0 +1,38 @@
+import { Message, MessageType } from "./message";
+
+/**
+ * A message including left and right motor power
+ */
+export class DriveRobotMessage extends Message {
+    constructor(
+        public readonly id: string,
+        public readonly leftPower: number,
+        public readonly rightPower: number,
+    ) {
+        super();
+    }
+
+    protected type = MessageType.DRIVE_ROBOT;
+
+    /**
+     * @returns an object with id, left power, and right power
+     */
+    protected toObj(): object {
+        return {
+            ...super.toObj(),
+            id: this.id,
+            leftPower: this.leftPower,
+            rightPower: this.rightPower,
+        };
+    }
+}
+
+/**
+ * An abstract message used to stop a robot.
+ * This message looks to the server like a DriveRobotMessage with power set to 0.
+ */
+export class StopRobotMessage extends DriveRobotMessage {
+    constructor(public readonly id: string) {
+        super(id, 0, 0);
+    }
+}
diff --git a/src/common/message/game-message.ts b/src/common/message/game-message.ts
index 732c921d..80641cd1 100644
--- a/src/common/message/game-message.ts
+++ b/src/common/message/game-message.ts
@@ -6,6 +6,9 @@ import {
     GameFinishedReason,
 } from "../game-end-reasons";
 
+/**
+ * A message that includes a position and pgn
+ */
 export class PositionMessage extends Message {
     constructor(public readonly pgn: string) {
         super();
@@ -18,6 +21,9 @@ export class PositionMessage extends Message {
     }
 }
 
+/**
+ * A message that includes a move
+ */
 export class MoveMessage extends Message {
     constructor(public readonly move: Move) {
         super();
@@ -32,6 +38,10 @@ export class MoveMessage extends Message {
         };
     }
 }
+
+/**
+ * A message for starting games
+ */
 export class GameStartedMessage extends Message {
     constructor() {
         super();
@@ -40,6 +50,9 @@ export class GameStartedMessage extends Message {
     protected type = MessageType.GAME_STARTED;
 }
 
+/**
+ * A message that contains why the game was interrupted
+ */
 export class GameInterruptedMessage extends Message {
     constructor(public readonly reason: GameInterruptedReason) {
         super();
@@ -55,6 +68,10 @@ export class GameInterruptedMessage extends Message {
     }
 }
 
+/**
+ * A message that contains why the game has finished
+ *
+ */
 export class GameFinishedMessage extends Message {
     constructor(public readonly reason: GameFinishedReason) {
         super();
@@ -70,6 +87,9 @@ export class GameFinishedMessage extends Message {
     }
 }
 
+/**
+ * A message that contains why the game was temporarily held
+ */
 export class GameHoldMessage extends Message {
     constructor(public readonly reason: GameHoldReason) {
         super();
diff --git a/src/common/message/message.ts b/src/common/message/message.ts
index 923fa1a1..a2dad25b 100644
--- a/src/common/message/message.ts
+++ b/src/common/message/message.ts
@@ -4,10 +4,6 @@
  * To add a new message, first add a member to MessageType, then create a corresponding class which extends `Message` and implements the `type` method and the `toObj` method.
  * Finally, add a corresponding case to `parseMessage` in `./parse-message`.
  */
-
-/**
- * A collection of WebSocket message types.
- */
 export enum MessageType {
     /**
      * A client-server message used to register a websocket with the server.
diff --git a/src/common/message/robot-message.ts b/src/common/message/robot-message.ts
index e020b36a..9396848a 100644
--- a/src/common/message/robot-message.ts
+++ b/src/common/message/robot-message.ts
@@ -1,5 +1,8 @@
 import { Message, MessageType } from "./message";
 
+/**
+ * send a robot message
+ */
 abstract class RobotMessage extends Message {
     constructor(public readonly id: string) {
         super();
@@ -13,6 +16,9 @@ abstract class RobotMessage extends Message {
     }
 }
 
+/**
+ * A message to set a variable on the robot
+ */
 export class SetRobotVariableMessage extends RobotMessage {
     constructor(
         id: string,
@@ -33,6 +39,9 @@ export class SetRobotVariableMessage extends RobotMessage {
     }
 }
 
+/**
+ * A message to drive the robot based on left and right motor power
+ */
 export class DriveRobotMessage extends RobotMessage {
     constructor(
         id: string,
diff --git a/src/common/message/simulator-message.ts b/src/common/message/simulator-message.ts
index 70f80bca..5b539534 100644
--- a/src/common/message/simulator-message.ts
+++ b/src/common/message/simulator-message.ts
@@ -12,6 +12,9 @@ export type StackFrame = {
     columnNumber: number;
 };
 
+/**
+ * An update message for the simulator with the robot id and position
+ */
 export class SimulatorUpdateMessage extends Message {
     protected type = MessageType.SIMULATOR_UPDATE;
 
diff --git a/src/server/api/api.ts b/src/server/api/api.ts
index 63186eee..bfd8dabf 100644
--- a/src/server/api/api.ts
+++ b/src/server/api/api.ts
@@ -41,10 +41,12 @@ export let gameManager: GameManager | null = null;
  * The websocket is used to stream moves to and from the client.
  */
 export const websocketHandler: WebsocketRequestHandler = (ws, req) => {
+    // on close, delete the cookie id
     ws.on("close", () => {
         socketManager.handleSocketClosed(req.cookies.id);
     });
 
+    // if there is an actual message, forward it to appropriate handler
     ws.on("message", (data) => {
         const message = parseMessage(data.toString());
         console.log("Received message: " + message.toJson());
@@ -69,11 +71,19 @@ export const websocketHandler: WebsocketRequestHandler = (ws, req) => {
 
 export const apiRouter = Router();
 
+/**
+ * client information endpoint
+ *
+ * finds the client type and checks if the game is active
+ * used when a client connects to the server
+ */
+
 apiRouter.get("/client-information", (req, res) => {
     const clientType = clientManager.getClientType(req.cookies.id);
-    //loading saves from file if found
+    // loading saves from file if found
     const oldSave = SaveManager.loadGame(req.cookies.id);
     if (oldSave) {
+        // if the game was an ai game, create a computer game manager with the ai difficulty
         if (oldSave.aiDifficulty !== -1) {
             gameManager = new ComputerGameManager(
                 new ChessEngine(oldSave.game),
@@ -87,6 +97,7 @@ apiRouter.get("/client-information", (req, res) => {
                 oldSave.aiDifficulty,
                 oldSave.host !== req.cookies.id,
             );
+            // create a new human game manger with appropriate clients
         } else {
             gameManager = new HumanGameManager(
                 new ChessEngine(oldSave.game),
@@ -108,6 +119,12 @@ apiRouter.get("/client-information", (req, res) => {
     });
 });
 
+/**
+ * game state endpoint
+ *
+ * gets the game state from the game manager
+ * returns an object with the side, game pgn, and the game end reason
+ */
 apiRouter.get("/game-state", (req, res) => {
     if (gameManager === null) {
         console.warn("Invalid attempt to fetch game state");
@@ -117,9 +134,16 @@ apiRouter.get("/game-state", (req, res) => {
     return res.send(gameManager.getGameState(clientType));
 });
 
+/**
+ * start computer game endpoint
+ *
+ * creates a new computer game manager based on the requests's side and difficulty
+ * returns a success message
+ */
 apiRouter.post("/start-computer-game", (req, res) => {
     const side = req.query.side as Side;
     const difficulty = parseInt(req.query.difficulty as string) as Difficulty;
+    // create a new computer game manager
     gameManager = new ComputerGameManager(
         new ChessEngine(),
         socketManager,
@@ -130,8 +154,16 @@ apiRouter.post("/start-computer-game", (req, res) => {
     return res.send({ message: "success" });
 });
 
+/**
+ * start human game endpoint
+ *
+ * creates a new human game engine based on the request's side
+ *
+ * returns a success message
+ */
 apiRouter.post("/start-human-game", (req, res) => {
     const side = req.query.side as Side;
+    // create a new human game manager
     gameManager = new HumanGameManager(
         new ChessEngine(),
         socketManager,
@@ -142,11 +174,17 @@ apiRouter.post("/start-human-game", (req, res) => {
     return res.send({ message: "success" });
 });
 
+/**
+ * Returns all registered robot ids
+ */
 apiRouter.get("/get-ids", (_, res) => {
     const ids = Array.from(robotManager.idsToRobots.keys());
     return res.send({ ids });
 });
 
+/**
+ * move a random robot forward and turn 45 degrees
+ */
 apiRouter.get("/do-smth", async (_, res) => {
     const robotsEntries = Array.from(virtualRobots.entries());
     const [, robot] =
@@ -157,12 +195,16 @@ apiRouter.get("/do-smth", async (_, res) => {
     res.send({ message: "success" });
 });
 
+/**
+ * get the current state of the virtual robots for the simulator
+ */
 apiRouter.get("/get-simulator-robot-state", (_, res) => {
     if (!USE_VIRTUAL_ROBOTS) {
         return res.status(400).send({ message: "Simulator is not enabled." });
     }
     const robotsEntries = Array.from(virtualRobots.entries());
 
+    // get all of the robots and their positions
     const robotState = Object.fromEntries(
         robotsEntries.map(([id, robot]) => {
             let headingRadians = robot.headingRadians;
@@ -176,6 +218,8 @@ apiRouter.get("/get-simulator-robot-state", (_, res) => {
             return [id, { position, headingRadians: headingRadians }];
         }),
     );
+
+    //send the robots and any tunnel messages
     return res.send({
         robotState,
         messages: Array.from(VirtualBotTunnel.messages),
@@ -202,7 +246,14 @@ apiRouter.get("/get-puzzles", (_, res) => {
     });
 });
 
+/**
+ * sends a drive message through the tcp connection
+ *
+ * @param message - the robot id and left/right motor powers
+ * @returns - boolean if successful
+ */
 function doDriveRobot(message: DriveRobotMessage): boolean {
+    // check if robot is registered
     if (!tcpServer) {
         console.warn("Attempted to drive robot without TCP server.");
         return false;
@@ -214,11 +265,15 @@ function doDriveRobot(message: DriveRobotMessage): boolean {
         return false;
     } else {
         const tunnel = tcpServer.getTunnelFromId(message.id);
+
+        // check if robot is connected
         if (!tunnel.connected) {
             console.warn(
                 "attempted manual move for disconnected robot ID " + message.id,
             );
             return false;
+
+            // send the robot message
         } else {
             tunnel.send({
                 type: "DRIVE_TANK",
@@ -230,6 +285,11 @@ function doDriveRobot(message: DriveRobotMessage): boolean {
     return true;
 }
 
+/**
+ * set a variable on the robot
+ * @param message - the robot id and variable information to change
+ * @returns - boolean completed successfully
+ */
 function doSetRobotVariable(message: SetRobotVariableMessage): boolean {
     if (!tcpServer) {
         console.warn("Attempted to set robot variable without TCP server.");
diff --git a/src/server/api/client-manager.ts b/src/server/api/client-manager.ts
index b40de054..524b7058 100644
--- a/src/server/api/client-manager.ts
+++ b/src/server/api/client-manager.ts
@@ -5,6 +5,8 @@ import { Message } from "../../common/message/message";
 
 /**
  * A class which maps client ids to their corresponding sockets (if any).
+ *
+ * gets, sends, and assigns client information
  */
 export class ClientManager {
     constructor(
@@ -14,6 +16,10 @@ export class ClientManager {
         private spectatorIds: Set<string> = new Set([]),
     ) {}
 
+    /**
+     * get the host's socket
+     * @returns the host socket
+     */
     public getHostSocket(): WebSocket | undefined {
         if (this.hostId !== undefined) {
             return this.socketManager.getSocket(this.hostId);
@@ -21,6 +27,11 @@ export class ClientManager {
         return undefined;
     }
 
+    /**
+     * finds the host and sends a message
+     * @param message - the message to be sent
+     * @returns if the socket was found
+     */
     public sendToHost(message: Message): boolean {
         const socket = this.getHostSocket();
         if (socket !== undefined) {
@@ -29,6 +40,11 @@ export class ClientManager {
         return socket !== undefined;
     }
 
+    /**
+     * finds the client and sends a message
+     * @param message - the message to be sent
+     * @returns if the socket was found
+     */
     public sendToClient(message: Message): boolean {
         const socket = this.getClientSocket();
         if (socket !== undefined) {
@@ -37,6 +53,11 @@ export class ClientManager {
         return socket !== undefined;
     }
 
+    /**
+     * send an update message to all spectators
+     * @param message - the message to send
+     * @returns if it completed successfully
+     */
     public sendToSpectators(message: Message): boolean {
         if (this.spectatorIds.size !== 0) {
             for (const item of this.spectatorIds) {
@@ -55,6 +76,10 @@ export class ClientManager {
         return undefined;
     }
 
+    /**
+     * @param id - the cookie id of the request
+     * @returns the client type
+     */
     public getClientType(id: string): ClientType {
         if (id === this.hostId) {
             return ClientType.HOST;
@@ -64,6 +89,10 @@ export class ClientManager {
         return ClientType.SPECTATOR;
     }
 
+    /**
+     * assigns the passed id to either host/client
+     * @param id - the cookie id of the request
+     */
     public assignPlayer(id: string): void {
         if (this.hostId === undefined || id === this.hostId) {
             this.hostId = id;
@@ -74,6 +103,10 @@ export class ClientManager {
         }
     }
 
+    /**
+     * gets the ids of all currently connected clients
+     * @returns - list of ids, if available
+     */
     public getIds(): undefined | string[] {
         if (this.hostId && this.clientId) {
             return [this.hostId, this.clientId];
diff --git a/src/server/api/game-manager.ts b/src/server/api/game-manager.ts
index a6f2ff7c..98878c49 100644
--- a/src/server/api/game-manager.ts
+++ b/src/server/api/game-manager.ts
@@ -18,6 +18,9 @@ import {
 } from "../../common/game-end-reasons";
 import { SaveManager } from "./save-manager";
 
+/**
+ * The manager for game communication
+ */
 export abstract class GameManager {
     protected gameInterruptedReason: GameInterruptedReason | undefined =
         undefined;
@@ -29,10 +32,11 @@ export abstract class GameManager {
          * The side the host is playing.
          */
         protected hostSide: Side,
-        //true if host and client get reversed
+        // true if host and client get reversed
         protected reverse: boolean,
     ) {}
 
+    /** check if game ended */
     public isGameEnded(): boolean {
         return (
             this.gameInterruptedReason !== undefined ||
@@ -40,6 +44,7 @@ export abstract class GameManager {
         );
     }
 
+    /** get game end reason */
     public getGameEndReason(): GameEndReason | undefined {
         return this.gameInterruptedReason ?? this.chess.getGameFinishedReason();
     }
@@ -70,6 +75,9 @@ export abstract class GameManager {
     ): void;
 }
 
+/**
+ * game manager for handling human communications
+ */
 export class HumanGameManager extends GameManager {
     constructor(
         chess: ChessEngine,
@@ -84,10 +92,18 @@ export class HumanGameManager extends GameManager {
         clientManager.sendToSpectators(new GameStartedMessage());
     }
 
+    /**
+     * handles messages between players
+     * @param message - the message to be sent
+     * @param id - id of the sender
+     */
     public handleMessage(message: Message, id: string): void {
+        // check which type the id is
         const clientType = this.clientManager.getClientType(id);
         let sendToPlayer: SendMessage;
         let sendToOpponent: SendMessage;
+
+        // decide whether the host is the player or the opponent
         if (clientType === ClientType.HOST) {
             sendToPlayer = this.clientManager.sendToHost.bind(
                 this.clientManager,
@@ -103,11 +119,14 @@ export class HumanGameManager extends GameManager {
                 this.clientManager,
             );
         }
+
+        //bind all spectators
         const sendToSpectators = this.clientManager.sendToSpectators.bind(
             this.clientManager,
         );
         const ids = this.clientManager.getIds();
         const currentSave = SaveManager.loadGame(id);
+        // update the internal chess object if it is a move massage
         if (message instanceof MoveMessage) {
             this.chess.makeMove(message.move);
             if (ids) {
@@ -131,12 +150,16 @@ export class HumanGameManager extends GameManager {
             }
             sendToOpponent(message);
             sendToSpectators(message);
+
+            // end the game if it is interrupted
         } else if (message instanceof GameInterruptedMessage) {
             this.gameInterruptedReason = message.reason;
             // propagate back to both sockets
             sendToPlayer(message);
             sendToOpponent(message);
             sendToSpectators(message);
+
+            //end the game in save manager
             if (ids) {
                 if (currentSave?.host === ids[0])
                     SaveManager.endGame(ids[0], ids[1]);
@@ -171,10 +194,15 @@ export class HumanGameManager extends GameManager {
     }
 }
 
+/**
+ * game manager for making and sending ai moves
+ */
 export class ComputerGameManager extends GameManager {
     // The minimum amount of time to wait responding with a move.
     MINIMUM_DELAY = 500;
 
+    // Create the game manager
+    // if the player is black have the computer make the first move
     constructor(
         chess: ChessEngine,
         socketManager: SocketManager,
@@ -190,6 +218,12 @@ export class ComputerGameManager extends GameManager {
         }
     }
 
+    /**
+     * handle messages between the server and the player
+     * @param message - the message to send
+     * @param id - id of the sender
+     * @returns when the game ends
+     */
     public handleMessage(message: Message, id: string): void {
         if (message instanceof MoveMessage) {
             this.chess.makeMove(message.move);
diff --git a/src/server/api/save-manager.ts b/src/server/api/save-manager.ts
index 19affeb2..6bacd525 100644
--- a/src/server/api/save-manager.ts
+++ b/src/server/api/save-manager.ts
@@ -12,7 +12,7 @@
 
 import { Side } from "../../common/game-types";
 
-//Save files contain a date in ms and pgn string
+// Save files contain a date in ms and pgn string
 export interface iSave {
     host: string;
     date: number;
@@ -114,7 +114,7 @@ export class SaveManager {
      * Searches through saves, removing ones older than 3 hours
      */
 
-    //Save game and save file are separate for future-proofing in case we change to a database.
+    // Save game and save file are separate for future-proofing in case we change to a database.
     public static removeOld() {
         const date = new Date().getTime();
 
@@ -122,7 +122,7 @@ export class SaveManager {
         file.forEach((f) => {
             const save = FileManager.loadFile(f);
             if (save.date > date + 10800000) {
-                //3 hours in ms
+                // 3 hours in ms
                 FileManager.deleteFile(f);
             }
         });
diff --git a/src/server/api/socket-manager.ts b/src/server/api/socket-manager.ts
index 8b82cd7b..52bf707c 100644
--- a/src/server/api/socket-manager.ts
+++ b/src/server/api/socket-manager.ts
@@ -11,10 +11,18 @@ export class SocketManager {
         this.sockets[id] = socket;
     }
 
+    /**
+     * deletes the socket at the provided id
+     * @param id - id to be deleted
+     */
     public handleSocketClosed(id: string): void {
         delete this.sockets[id];
     }
 
+    /**
+     * gets the socket at the provided id
+     * @param id - id of the desired socket
+     */
     public getSocket(id: string): WebSocket {
         return this.sockets[id];
     }
@@ -32,6 +40,11 @@ export class SocketManager {
         return false;
     }
 
+    /**
+     * send a message to all current sockets
+     * @param message - message to be sent
+     * @returns isSuccessful
+     */
     public sendToAll(message: Message): boolean {
         const sockets = Object.values(this.sockets);
         for (const socket of sockets) {
diff --git a/src/server/api/tcp-interface.ts b/src/server/api/tcp-interface.ts
index e4d8bb62..ce21aea9 100644
--- a/src/server/api/tcp-interface.ts
+++ b/src/server/api/tcp-interface.ts
@@ -9,6 +9,9 @@ import {
 import EventEmitter from "node:events";
 import { randomUUID } from "node:crypto";
 
+/**
+ * The tunnel for handling communications to the robots
+ */
 export class BotTunnel {
     connected: boolean = false;
     dataBuffer: Buffer | undefined;
@@ -16,6 +19,12 @@ export class BotTunnel {
     id: string | undefined;
     emitter: EventEmitter;
 
+    /**
+     * take the robot socket and creates an emitter to notify dependencies
+     *
+     * @param socket - socket of the incoming connections
+     * @param onHandshake - handshake handler
+     */
     constructor(
         private socket: net.Socket | null,
         private onHandshake: (packetContent: string) => void,
@@ -27,6 +36,11 @@ export class BotTunnel {
         return this.socket!.readyState === "open";
     }
 
+    /**
+     * get the most relevant identifier possible
+     *
+     * @returns - a robot identifier
+     */
     getIdentifier(): string {
         if (this.id !== undefined) {
             return "ID: " + this.id;
@@ -39,6 +53,10 @@ export class BotTunnel {
         }
     }
 
+    /**
+     * log when data comes in
+     * @param data - the incoming data
+     */
     onData(data: Buffer) {
         console.log(
             "connection data from %s: %j",
@@ -48,6 +66,10 @@ export class BotTunnel {
         this.handleData(data);
     }
 
+    /**
+     * log errors and update connection status
+     * @param err - the error message
+     */
     onError(err: Error) {
         console.error(
             "Connection error from %s: %s",
@@ -57,11 +79,19 @@ export class BotTunnel {
         this.connected = false;
     }
 
+    /**
+     * log when a connection is removed or lost
+     */
     onClose() {
         console.log("Lost connection to %s", this.getIdentifier());
         this.connected = false;
     }
 
+    /**
+     * Sets up the data buffer for it to be handled by the queue
+     *
+     * @param data - data to be handled
+     */
     handleData(data: Buffer) {
         if (this.dataBuffer !== undefined) {
             this.dataBuffer = Buffer.concat([this.dataBuffer, data]);
@@ -72,15 +102,24 @@ export class BotTunnel {
         this.handleQueue();
     }
 
+    /**
+     * handles the incoming data and check if it is valid
+     *
+     * emits result for further handling
+     *
+     * @returns - nothing if nothing happened and nothing if something happened
+     */
     handleQueue() {
         if (this.dataBuffer === undefined || this.dataBuffer.length < 3) {
             this.dataBuffer = undefined;
             return;
         }
 
+        // get the data and find the terminator
         let str = this.dataBuffer.toString();
         const terminator = str.indexOf(";");
 
+        // if there is no terminator, wait for it
         if (terminator === -1) {
             if (str.length > 200) {
                 // Invalid state, reset buf
@@ -93,6 +132,7 @@ export class BotTunnel {
 
         str = str.substring(0, terminator);
 
+        // check if the buffer is the correct length based on where the terminator is
         if (this.dataBuffer.length > terminator) {
             this.dataBuffer = this.dataBuffer.subarray(terminator + 1);
         } else {
@@ -104,20 +144,24 @@ export class BotTunnel {
 
             // Parse packet based on type
             switch (packet.type) {
+                // register new robot
                 case "CLIENT_HELLO": {
                     this.onHandshake(packet.macAddress);
                     this.send(this.makeHello(packet.macAddress));
                     this.connected = true;
                     break;
                 }
+                // respond to pings
                 case "PING_SEND": {
                     this.send({ type: "PING_RESPONSE" });
                     break;
                 }
+                // emit a action complete for further processing
                 case "ACTION_SUCCESS": {
                     this.emitter.emit("actionComplete", { success: true });
                     break;
                 }
+                // emit a action fail for further processing
                 case "ACTION_FAIL": {
                     this.emitter.emit("actionComplete", {
                         success: false,
@@ -139,10 +183,15 @@ export class BotTunnel {
         }
     }
 
+    /**
+     * send packets to robot
+     * @param packet - packet to send
+     */
     send(packet: Packet) {
         const str = packetToJson(packet);
         const msg = str + ";";
 
+        // If the connection isn't active, there is no robot
         if (!this.isActive()) {
             console.error(
                 "Connection to",
@@ -160,6 +209,10 @@ export class BotTunnel {
         this.socket!.write(msg);
     }
 
+    /**
+     * Wait for the socket to respond to the sent action
+     * @returns - if the action was completed or rejected
+     */
     async waitForActionResponse(): Promise<void> {
         return new Promise((res, rej) => {
             this.emitter.once("actionComplete", (args) => {
@@ -199,9 +252,19 @@ export class BotTunnel {
     }
 }
 
+/**
+ * Handles tcp tunnels and maintains a list of connections
+ */
 export class TCPServer {
     private server: net.Server;
 
+    /**
+     * creates a tcp server on port from server config and registers passed in ids with their corresponding bot tunnels
+     *
+     * when a robot connects, bind it to the server
+     *
+     * @param connections - bot connections in a id:BotTunnel array
+     */
     constructor(private connections: { [id: string]: BotTunnel } = {}) {
         this.server = net.createServer();
         this.server.on("connection", this.handleConnection.bind(this));
@@ -213,15 +276,24 @@ export class TCPServer {
         });
     }
 
+    /**
+     * When a robot connects, add the tunnel to the robot connections at its id
+     *
+     * assign a random id to new robots
+     *
+     * @param socket - the incoming connection socket information
+     */
     private handleConnection(socket: net.Socket) {
         const remoteAddress = socket.remoteAddress + ":" + socket.remotePort;
         console.log("New client connection from %s", remoteAddress);
 
         socket.setNoDelay(true);
 
+        // create a new bot tunnel for the connection
         const tunnel = new BotTunnel(
             socket,
             ((mac: string) => {
+                // add the new robot to the array if it isn't in bots config
                 console.log("Adding robot with mac", mac, "to arr");
                 let id: string;
                 if (!(mac in config["bots"])) {
@@ -241,15 +313,25 @@ export class TCPServer {
             }).bind(this),
         );
 
+        // bind the sockets to the corresponding functions
         socket.on("data", tunnel.onData.bind(tunnel));
         socket.once("close", tunnel.onClose.bind(tunnel));
         socket.on("error", tunnel.onError.bind(tunnel));
     }
 
+    /**
+     * get the robot tunnel based on the robot id string
+     * @param id - id string
+     * @returns - tcp tunnel
+     */
     public getTunnelFromId(id: string): BotTunnel {
         return this.connections[id];
     }
 
+    /**
+     * get a list of connected ids
+     * @returns - list of id keys
+     */
     public getConnectedIds(): string[] {
         return Object.keys(this.connections);
     }
diff --git a/src/server/robot/position.ts b/src/server/robot/position.ts
index bf9ba072..1709aa67 100644
--- a/src/server/robot/position.ts
+++ b/src/server/robot/position.ts
@@ -1,5 +1,8 @@
 import { Pair } from "../utils/pair";
 
+/**
+ * x,y positions
+ */
 export class Position extends Pair<Position> {
     constructor(
         public readonly x: number,
diff --git a/src/server/simulator.ts b/src/server/simulator.ts
index 8497abaf..f13c3af6 100644
--- a/src/server/simulator.ts
+++ b/src/server/simulator.ts
@@ -13,6 +13,11 @@ import { socketManager } from "./api/managers";
 
 const srcDir = path.resolve(__dirname, "../");
 
+/**
+ * get the current error stack
+ * @param justMyCode - no clue
+ * @returns - the stack of the error
+ */
 function getStack(justMyCode = true) {
     // inspired by https://stackoverflow.com/a/56651526
     const err = new Error();
@@ -34,6 +39,11 @@ function getStack(justMyCode = true) {
     return cleanedStack;
 }
 
+/**
+ * parse the stack for important information like file, function, and line
+ * @param stack - the stack to parse
+ * @returns the stack frames as readable objects
+ */
 const parseErrorStack = (stack: string): StackFrame[] => {
     const lines = stack.split("\n");
     const frames = lines.slice(1).map((line) => {
@@ -52,6 +62,9 @@ const parseErrorStack = (stack: string): StackFrame[] => {
     return frames;
 };
 
+/**
+ * A mock of the regular robot tunnel for the simulator robots
+ */
 export class VirtualBotTunnel extends BotTunnel {
     connected = true;
 
@@ -134,6 +147,9 @@ export class VirtualBotTunnel extends BotTunnel {
     }
 }
 
+/**
+ * virtual robots that can be moved around
+ */
 export class VirtualRobot extends Robot {
     public getTunnel(): BotTunnel {
         return virtualBotTunnels.get(this.id)!;
@@ -144,6 +160,9 @@ const virtualBotIds = Array(32)
     .fill(undefined)
     .map((_, i) => `virtual-robot-${(i + 1).toString()}`);
 
+/**
+ * a map of all the created virtual robots with ids, positions, and homes
+ */
 export const virtualRobots = new Map<string, VirtualRobot>(
     virtualBotIds.map((id) => {
         const realRobotConfig = config[id.replace("virtual-", "")];
@@ -162,6 +181,7 @@ export const virtualRobots = new Map<string, VirtualRobot>(
     }),
 );
 
+/** a map of all the current virtual robot tunnels */
 const virtualBotTunnels = new Map<string, BotTunnel>(
     virtualBotIds.map((id) => [id, new VirtualBotTunnel(id)]),
 );
diff --git a/src/server/utils/pair.ts b/src/server/utils/pair.ts
index 6ddf62af..3b9b009e 100644
--- a/src/server/utils/pair.ts
+++ b/src/server/utils/pair.ts
@@ -1,3 +1,6 @@
+/**
+ * pair operations
+ */
 export abstract class Pair<T extends Pair<T>> {
     constructor(
         // Pair is implemented atomically and doesn't support mutation
diff --git a/src/server/utils/square.ts b/src/server/utils/square.ts
index 0ebebeaf..5c520481 100644
--- a/src/server/utils/square.ts
+++ b/src/server/utils/square.ts
@@ -3,12 +3,24 @@ import { Position } from "../robot/position";
 
 const FILE_LOOKUP = "abcdefgh";
 
+/**
+ * convert physical position to pgn square
+ *
+ * @param position - physical position
+ * @returns - pgn square
+ */
 export function positionToSquare(position: Position): Square {
     const letter = FILE_LOOKUP[Math.floor(position.x)];
     const number = Math.floor(position.y) + 1;
     return (letter + number) as Square;
 }
 
+/**
+ * convert pgn square to physical position
+ *
+ * @param position - pgn square
+ * @returns - physical position
+ */
 export function squareToPosition(square: Square): Position {
     const i = FILE_LOOKUP.indexOf(square.charAt(0));
     const j = parseInt(square.charAt(1)) - 1;
diff --git a/src/server/utils/tcp-packet.ts b/src/server/utils/tcp-packet.ts
index bb5a431e..2fa4bb6a 100644
--- a/src/server/utils/tcp-packet.ts
+++ b/src/server/utils/tcp-packet.ts
@@ -24,28 +24,56 @@ const MotorPower = Float.withConstraint((n) => -1 <= n && n <= 1, {
 // MUST be kept in sync with chessBotArduino/include/packet.h PacketType
 export const SERVER_PROTOCOL_VERSION = 1;
 
+/**
+ * A hello message from the client
+ */
 export const CLIENT_HELLO = Record({
     type: Literal("CLIENT_HELLO"),
     macAddress: String,
 });
+
+/**
+ * A hello message from the server
+ */
 export const SERVER_HELLO = Record({
     type: Literal("SERVER_HELLO"),
     protocol: Uint32,
     config: Array(Tuple(String /*type*/, String /*value*/)),
 });
+
+/**
+ * send a ping
+ */
 export const PING_SEND = Record({ type: Literal("PING_SEND") });
+
+/**
+ * respond to a ping
+ */
 export const PING_RESPONSE = Record({ type: Literal("PING_RESPONSE") });
 
+/**
+ * query a value
+ *
+ * could be float, unsigned, or int
+ */
 export const QUERY_VAR = Record({
     type: Literal("QUERY_VAR"),
     var_id: VarId,
     var_type: Union(Literal("float"), Literal("uint32"), Literal("int32")),
 });
+
+/**
+ * respond to a query
+ */
 export const QUERY_RESPONSE = Record({
     type: Literal("QUERY_RESPONSE"),
     var_id: VarId,
     var_val: Union(Float, Uint32, Int32),
 });
+
+/**
+ * send a message to set a variable by id
+ */
 export const SET_VAR = Record({
     type: Literal("SET_VAR"),
     var_id: VarId,
@@ -66,21 +94,33 @@ export const SET_VAR = Record({
     ),
 );
 
+/**
+ * send a turn command
+ */
 export const TURN_BY_ANGLE = Record({
     type: Literal("TURN_BY_ANGLE"),
     deltaHeadingRadians: Float,
 });
+
+/**
+ * send a drive command with tile distance
+ */
 export const DRIVE_TILES = Record({
     type: Literal("DRIVE_TILES"),
     tileDistance: Float,
 });
-
+/** success message */
 export const ACTION_SUCCESS = Record({ type: Literal("ACTION_SUCCESS") });
+
+/** error message with reason */
 export const ACTION_FAIL = Record({
     type: Literal("ACTION_FAIL"),
     reason: String,
 });
 
+/**
+ * start a tank drive with left and right motor powers
+ */
 export const DRIVE_TANK = Record({
     type: Literal("DRIVE_TANK"),
     left: MotorPower,
@@ -105,6 +145,11 @@ export const Packet = Union(
 );
 export type Packet = Static<typeof Packet>;
 
+/**
+ * convert json to a packet to be sent over tcp
+ * @param jsonStr - string to be converted
+ * @returns - the object packet
+ */
 export function jsonToPacket(jsonStr: string): Packet {
     const obj = JSON.parse(jsonStr);
     if (!Packet.guard(obj)) {
@@ -113,6 +158,11 @@ export function jsonToPacket(jsonStr: string): Packet {
     return obj as Packet;
 }
 
+/**
+ * convert a packet to readable json
+ * @param packet - packet to be converted
+ * @returns - json string
+ */
 export function packetToJson(packet: Packet): string {
     if (!Packet.guard(packet)) {
         throw new Error("Invalid packet: " + JSON.stringify(packet));