Recursion uses the call stack to manage the execution of recursive function calls. Each recursive function call creates a new stack frame, or activation record, on the call stack. The stack keeps track of the state of each function call, including the local variables and the return address, allowing the program to return to the correct point after the recursive calls are completed.

Here's how recursion utilizes the stack:

1. Initial Function Call: When a function is initially called, a stack frame is created for that function, containing the function's local variables and the return address indicating the next instruction to be executed after the function call.
2. Recursive Function Call: Inside the function body, if a recursive call is made, a new stack frame is created for the recursive invocation. The current function's state, including the local variables and return address, is pushed onto the stack.
3. Storing Execution State: Each stack frame holds the execution state of a particular function call, including the current program counter, local variables, and any parameters passed to the function. The stack ensures that this state is preserved for each recursive call, allowing the program to resume execution correctly.
4. Recursive Call Chain: As recursive calls continue, each new function call creates a new stack frame on top of the previous one, forming a chain of recursive function calls. The call stack grows with each recursive invocation, allocating memory for each stack frame.
5. Base Case and Return: When the base case is reached, which serves as the termination condition, the function does not make any further recursive calls. Instead, it starts to unwind the call stack. The return values are propagated up the call stack, and each stack frame is popped off the stack.
6. Stack Unwinding: As the recursive calls complete, the stack frames are popped off the stack one by one, with each function returning to its caller. The return values are used to perform calculations or combine results as necessary.

By utilizing the stack, recursion maintains the execution context for each recursive call and ensures that the program can return to the correct points in the code after the recursive calls are completed. However, it's important to note that deep or excessive recursion can lead to stack overflow if the stack size limit is exceeded. In such cases, iterative or optimized approaches may be considered.