diff --git a/rustsweeper/.gitignore b/rustsweeper/.gitignore
new file mode 100644
index 0000000..ea8c4bf
--- /dev/null
+++ b/rustsweeper/.gitignore
@@ -0,0 +1 @@
+/target
diff --git a/rustsweeper/Cargo.toml b/rustsweeper/Cargo.toml
new file mode 100644
index 0000000..592e34e
--- /dev/null
+++ b/rustsweeper/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "rustsweeper"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+rand = "0.8.5"
+colored = "2.2.0"
+console = "0.15.10"
diff --git a/rustsweeper/src/main.rs b/rustsweeper/src/main.rs
new file mode 100644
index 0000000..1072534
--- /dev/null
+++ b/rustsweeper/src/main.rs
@@ -0,0 +1,285 @@
+use std::io::{stdin,stdout,Write};
+use rand::Rng;
+use colored::*;
+use colored::Color::TrueColor;
+use console::Term;
+
+fn output_board(board: &Vec<Vec<i64>>, state: &Vec<Vec<char>>, x_hovered: i64, y_hovered: i64) {
+    print!("{}[2J", 27 as char);
+    for y in 0..board.len() {
+        for x in 0..board[y].len() {
+            let background_color: u8;;
+
+            if state[y][x] != 'u' {
+                background_color = 128;
+            }
+            else {
+                background_color = 196;
+            }
+
+            if x == x_hovered as usize && y == y_hovered as usize {
+                print!("{}", "X".truecolor(0,0,0).on_truecolor(background_color,background_color,background_color));
+            }
+            else if state[y][x] == 'u' {
+                if board[y][x] == -1 {
+                    print!("{}","N".truecolor(128,64,0).on_truecolor(background_color,background_color,background_color));
+                }
+                else if board[y][x] == 0 {
+                    print!("{}"," ".on_truecolor(background_color,background_color,background_color));
+                }
+                else if board[y][x] == 1 {
+                    print!("{}", "1".truecolor(1,0,254).on_truecolor(background_color,background_color,background_color));
+                }
+                else if board[y][x] == 2 {
+                    print!("{}", "2".truecolor(1,127,1).on_truecolor(background_color,background_color,background_color));
+                }
+                else if board[y][x] == 3 {
+                    print!("{}", "3".truecolor(254,0,0).on_truecolor(background_color,background_color,background_color));
+                }
+                else if board[y][x] == 4 {
+                    print!("{}", "4".truecolor(1,0,128).on_truecolor(background_color,background_color,background_color));
+                }
+                else if board[y][x] == 5 {
+                    print!("{}", "5".truecolor(129,1,2).on_truecolor(background_color,background_color,background_color));
+                }
+                else if board[y][x] == 6 {
+                    print!("{}", "6".truecolor(0,128,129).on_truecolor(background_color,background_color,background_color));
+                }
+                else if board[y][x] == 7 {
+                    print!("{}", "7".truecolor(0,0,0).on_truecolor(background_color,background_color,background_color));
+                } 
+                else if board[y][x] == 8 {
+                    print!("{}", "8".truecolor(128,128,128).on_truecolor(background_color,background_color,background_color));
+                }
+            }
+            else if state[y][x] == 'm' {
+                print!("{}", "m".truecolor(228,16,32).on_truecolor(background_color,background_color,background_color));
+            }
+            else if state[y][x] == '?' {
+                print!("{}", "?".truecolor(0,0,0).on_truecolor(background_color,background_color,background_color));
+            }
+            else {
+                print!("{}"," ".on_truecolor(background_color,background_color,background_color));
+            }
+        }
+        println!();
+    }
+}
+
+fn input() -> String{
+    let mut s=String::new();
+    let _=stdout().flush();
+    stdin().read_line(&mut s).expect("Did not enter a correct string");
+    if let Some('\n')=s.chars().next_back() {
+        s.pop();
+    }
+    if let Some('\r')=s.chars().next_back() {
+        s.pop();
+    }
+    return s;
+}
+
+fn place_nails(board: &mut Vec<Vec<i64>>, number_of_nails: i64, width: i64, height: i64) {
+    for _nail in 0..number_of_nails {
+        // Generate coordinates for nails, if there is already a nail there, then generate new
+        // coordinates, should add case for if there are more mines than locations, but why would
+        // someone do that?
+        let mut x_coord = rand::thread_rng().gen_range(0..width);
+        let mut y_coord = rand::thread_rng().gen_range(0..height);
+        while board[y_coord as usize][x_coord as usize] == -1 {
+            x_coord = rand::thread_rng().gen_range(0..width);
+            y_coord = rand::thread_rng().gen_range(0..height);
+        }
+
+        board[y_coord as usize][x_coord as usize] = -1;
+    }
+}
+
+fn determine_nails_in_range(board: &mut Vec<Vec<i64>>) {
+    for x in 0..board.len() {
+        for y in 0..board[x].len() {
+            if board[x][y] != -1 {
+                let mut num_of_nails = 0;
+                
+                for i in -1..2 {
+                    for j in -1..2 {
+                        // Check if index is in range (>= 0 and < length of vector)     
+                        if (x as i64 + i >= 0 && (x as i64 + i) < board.len() as i64) && (y as i64 + j >= 0 && (y as i64 + j) < board[x].len() as i64) {
+                            if board[(x as i64 + i) as usize][(y as i64 + j) as usize] == -1 {
+                                num_of_nails += 1; // Increment the nail count
+                            }
+                        }
+                    }
+                }
+
+                board[x][y] = num_of_nails;
+            }
+        }
+    }
+}
+
+fn find_connected_coordinates(grid: &Vec<Vec<i64>>, start_row: usize, start_col: usize) -> Vec<(usize, usize)> {
+    let rows = grid.len();
+    let cols = grid[0].len();
+    let target_value = grid[start_row][start_col];
+
+    // Directions for 8 possible moves (vertical, horizontal, and diagonal)
+    let directions: [(i64, i64); 8] = [
+        (-1, 0), // Up
+        (1, 0),  // Down
+        (0, -1), // Left
+        (0, 1),  // Right
+        (-1, -1),// Top-left diagonal
+        (-1, 1), // Top-right diagonal
+        (1, -1), // Bottom-left diagonal
+        (1, 1),  // Bottom-right diagonal
+    ];
+
+    // Visited cells
+    let mut visited = vec![vec![false; cols]; rows];
+
+    // Vector to store the reachable coordinates
+    let mut result = Vec::new();
+
+    // DFS function
+    fn dfs(
+        grid: &Vec<Vec<i64>>, 
+        row: usize, 
+        col: usize, 
+        target_value: i64, 
+        visited: &mut Vec<Vec<bool>>, 
+        result: &mut Vec<(usize, usize)>, 
+        directions: &[(i64, i64)],  
+    ) {
+        // Check if the position is out of bounds or already visited or doesn't match the target value
+        if row >= grid.len() || col >= grid[0].len() || visited[row][col] || grid[row][col] != target_value {
+            return;
+        }
+
+        // Mark the cell as visited and add the coordinate to the result
+        visited[row][col] = true;
+        result.push((row, col));
+
+        // Flag to check if we're at the boundary of the connected region
+        let mut is_boundary = false;
+
+        for &direction in directions.iter() {
+            let (dx, dy) = direction;
+            let new_row = row as i64 + dx;
+            let new_col = col as i64 + dy;
+
+            if new_row >= 0 && new_row < grid.len() as i64 && new_col >= 0 && new_col < grid[0].len() as i64 {
+                let new_row = new_row as usize;
+                let new_col = new_col as usize;
+
+                if grid[new_row][new_col] != target_value {
+                    is_boundary = true;
+                }
+
+                dfs(grid, new_row, new_col, target_value, visited, result, directions);
+            }
+        }
+
+        if is_boundary {
+            for &direction in directions.iter() {
+                let (dx, dy) = direction;
+                let new_row = row as i64 + dx;
+                let new_col = col as i64 + dy;
+
+                if new_row >= 0 && new_row < grid.len() as i64 && new_col >= 0 && new_col < grid[0].len() as i64 {
+                    let new_row = new_row as usize;
+                    let new_col = new_col as usize;
+
+                    // Add cells with a different value to the result
+                    if grid[new_row][new_col] != target_value && !visited[new_row][new_col] {
+                        result.push((new_row, new_col));
+                    }
+                }
+            }
+        }
+    }
+
+    dfs(grid, start_row, start_col, target_value, &mut visited, &mut result, &directions);
+
+    result
+}
+
+fn uncover(board: &Vec<Vec<i64>>, state: &mut Vec<Vec<char>>, x_hovered: usize, y_hovered: usize, alive: &mut bool) {
+            state[y_hovered][x_hovered] = 'u';
+            if board[y_hovered][x_hovered] == -1 {
+                *alive = false;
+            }
+
+            if board[y_hovered][x_hovered] == 0 { 
+                let connected = find_connected_coordinates(&board, y_hovered, x_hovered);
+                for (y,x) in connected.iter() {
+                    state[*y][*x] = 'u';
+                }
+            }
+}
+
+fn main() {
+    let stdout = Term::buffered_stdout();
+
+    let mut board: Vec<Vec<i64>> = Vec::new();
+    let mut state: Vec<Vec<char>> = Vec::new(); // u = uncovered, c = covered, m = marked
+
+    let height: i64 = 10;
+    let width: i64 = 30;
+    let number_of_nails: i64 = 50;
+
+    let mut x_hovered: i64 = 0;
+    let mut y_hovered: i64 = 0;
+
+    let mut alive: bool = true;
+
+    for y in 0..height {
+        board.push(Vec::new());
+        state.push(Vec::new());
+        for x in 0..width {
+            board[y as usize].push(0);
+            state[y as usize].push('c');
+            //board[x as usize][y as usize] = -1;
+        }
+    }
+    place_nails(&mut board, number_of_nails, width, height);
+    determine_nails_in_range(&mut board);
+    output_board(&board, &state, x_hovered, y_hovered);
+
+    'gameloop: loop {
+        if let Ok(character) = stdout.read_char() {
+            match character {
+                'w' => if y_hovered > 0 { y_hovered -= 1 },
+                'a' => if x_hovered > 0 { x_hovered -= 1},
+                's' => if y_hovered < height-1 { y_hovered += 1 },
+                'd' => if x_hovered < width-1 {x_hovered += 1},
+                'u' => uncover(&board, &mut state, x_hovered as usize, y_hovered as usize, &mut alive),
+                'm' => {
+                    if state[y_hovered as usize][x_hovered as usize] == 'm' {
+                        state[y_hovered as usize][x_hovered as usize] = 'c'
+                    }
+                    else {
+                        state[y_hovered as usize][x_hovered as usize] = 'm'
+                    }
+                },
+                '?' => {
+                    if state[y_hovered as usize][x_hovered as usize] == '?' {
+                        state[y_hovered as usize][x_hovered as usize] = 'c'
+                    }
+                    else {
+                        state[y_hovered as usize][x_hovered as usize] = '?'
+                    }
+                },
+                'q' => break 'gameloop,
+                _ => (),
+            }
+        }
+        if alive {
+            output_board(&board, &state, x_hovered, y_hovered);
+        }
+        else if alive == false {
+            print!("GAME OVER");
+            break 'gameloop;
+        }
+    }
+}