Hello and welcome,

Disclaimer… I did not read the book Mazes for programmers.

I do not like the use of Agent to store visited cells, just to manage a map. It is started/stopped in the same function.

It’s possible to do without processes. I translated your code to Rust, for fun (and learning).

pub struct RecursiveBacktrack {
    visited: HashMap<Coordinate, bool>
}

impl RecursiveBacktrack {
    pub fn new() -> Self {
        Self {
            visited: HashMap::new(),
        }
    }

    pub fn carve(&mut self, grid: &mut Grid) {
        let mut rng = thread_rng();

        let x: usize = rng.gen_range(0, grid.width);
        let y: usize = rng.gen_range(0, grid.height);

        let starting_coordinate = Coordinate(x, y);

        self.do_carve(grid, starting_coordinate, starting_coordinate)
    }

    fn do_carve(&mut self, grid: &mut Grid, current: Coordinate, last: Coordinate) {
        match self.visited.get(&current) {
            Some(_) => (),
            None => {
                self.visited.insert(current, true);
                grid.open_passage(current, last);

                let mut neighbors = grid.neighbors(&current);
                neighbors.shuffle(&mut thread_rng());

                for neighbor in neighbors {
                    self.do_carve(grid, neighbor, current);
                }
            },
        }
    }
}

and the result

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |
+---+---+   +   +   +---+   +   +   +   +   +---+   +   +   +   +---+   +   +   +
|               |           |   |       |   |           |   |   |       |   |    
+---+   +---+---+   +---+   +---+   +---+   +   +---+---+   +   +   +---+   +   +
|       |           |   |       |   |       |   |           |   |   |       |    
+---+---+   +---+   +   +   +---+   +---+   +---+   +---+   +---+   +   +---+   +
|           |   |   |       |           |           |   |           |   |   |   |
+---+---+---+   +   +   +---+   +---+   +   +---+   +   +   +---+   +   +   +   +
|           |   |   |   |       |   |   |   |   |   |   |   |   |   |       |    
+---+---+---+   +   +   +---+   +---+   +   +   +---+   +   +---+   +---+---+---+
|   |           |   |       |           |   |           |                        
+---+   +---+---+   +---+   +   +---+---+   +---+---+   +---+   +---+---+   +---+
|               |       |   |   |               |   |       |   |           |    
+---+---+---+   +---+---+   +   +   +---+---+   +   +   +---+   +---+---+---+   +
|       |   |               |       |       |   |   |   |       |                
+---+   +   +---+---+   +---+---+---+   +---+   +   +---+   +   +   +---+---+---+
|                       |               |           |       |   |   |   |        
+---+---+---+---+---+   +   +---+---+---+   +---+---+   +---+   +   +   +   +---+
|           |       |   |               |   |           |   |       |   |   |    
+---+---+   +   +---+---+   +---+---+   +   +---+   +---+   +---+---+---+   +   +
|       |   |   |           |       |   |       |                           |   |
+---+   +---+   +   +   +   +---+   +   +---+   +---+   +---+---+---+   +   +   +
|   |       |   |   |   |   |   |           |       |   |               |   |   |
+---+---+   +   +   +---+   +---+   +---+   +---+---+   +   +   +---+---+   +   +
|       |   |   |                   |   |           |   |   |   |   |       |    
+---+   +   +   +---+   +---+   +---+---+   +---+   +   +   +   +   +   +   +---+
|   |   |           |   |   |   |           |   |   |   |   |   |   |   |   |    
+---+   +   +---+   +---+---+   +   +---+---+   +   +   +   +   +   +---+---+   +
|       |   |   |               |                   |   |   |   |               |
+---+---+   +   +---+---+---+   +---+   +   +---+---+   +---+   +   +   +---+   +
|       |   |               |       |   |   |   |               |   |   |        
+---+---+   +---+   +   +---+   +   +   +---+   +   +---+---+   +---+   +---+---+
|               |   |           |   |   |       |   |       |               |    
+---+   +---+   +---+   +---+---+---+   +---+---+   +   +---+   +---+---+   +   +
|       |   |       |   |                           |   |   |           |   |    
+---+---+   +---+   +---+   +   +---+---+---+---+---+   +   +---+---+---+   +---+
|   |           |           |   |                       |                        
+---+   +---+   +   +---+   +---+   +---+   +---+   +---+---+---+---+---+---+---+
|       |   |   |   |   |       |   |   |   |   |   |           |           |    
+---+   +   +   +   +   +   +   +   +   +   +   +   +   +---+   +   +---+   +   +

I don’t know if Agent are used to solve the maze, but You can generate without

I did not benchmark, but I am sure calling a pure function will be faster than starting and passing messages to an Agent

I refactored to use a map instead of an agent and it confirmed your suggestion. The result was over 3 times faster. Thanks!

Whenever You want speed, real speed, You can use an ETS table.

It is blazing fast.