diff --git a/10_Blackjack/rust/Cargo.toml b/10_Blackjack/rust/Cargo.toml
new file mode 100644
index 00000000..1c2935d4
--- /dev/null
+++ b/10_Blackjack/rust/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "rust"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+rand = "0.8.5"
\ No newline at end of file
diff --git a/10_Blackjack/rust/README.md b/10_Blackjack/rust/README.md
new file mode 100644
index 00000000..f84e546c
--- /dev/null
+++ b/10_Blackjack/rust/README.md
@@ -0,0 +1,3 @@
+Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html)
+
+Conversion to [Rust](https://www.rust-lang.org/) by Anthony Rubick [AnthonyMichaelTDM](https://github.com/AnthonyMichaelTDM)
\ No newline at end of file
diff --git a/10_Blackjack/rust/src/main.rs b/10_Blackjack/rust/src/main.rs
new file mode 100644
index 00000000..e3a0a459
--- /dev/null
+++ b/10_Blackjack/rust/src/main.rs
@@ -0,0 +1,634 @@
+use rand::{prelude::{thread_rng, SliceRandom}};
+use std::{io, io::{stdout, Write}};
+
+/**
+ * todo list:
+ * 
+ * allow splitting
+ */
+
+
+//DATA
+//enums
+enum PlayerType {
+    Player,
+    Dealer,
+}
+impl ToString for PlayerType {
+    fn to_string(&self) -> String {
+        match self {
+            &PlayerType::Dealer => return String::from("Dealer"),
+            &PlayerType::Player => return String::from("Player"),
+        }
+    }
+}
+enum Play {
+    Stand,
+    Hit,
+    DoubleDown,
+    Split,
+}
+impl ToString for Play {
+    fn to_string(&self) -> String {
+        match self {
+            &Play::Hit => return String::from("Hit"),
+            &Play::Stand => return String::from("Stand"),
+            &Play::DoubleDown => return String::from("Double Down"),
+            &Play::Split => return String::from("Split")
+        }
+    }
+}
+//structs
+struct CARD<'a> {
+    name: &'a str,
+    value: u8,
+}
+impl<'a> CARD<'a> {
+    /**
+     * creates a new card from the passed card name
+     */
+    fn new(card_name: &str) -> CARD {
+        return CARD { name: card_name, value: CARD::determine_value_from_name(card_name) };
+    }
+
+    /**
+     * returns the value associated with a card with the passed name
+     * return 0 if the passed card name doesn't exist
+     */
+    fn determine_value_from_name(card_name: &str) -> u8 {
+        //DATA
+        let value:u8;
+
+        match card_name.to_ascii_uppercase().as_str() {
+            "ACE" => value = 11,
+            "2" => value = 2,
+            "3" => value = 3,
+            "4" => value = 4,
+            "5" => value = 5,
+            "6" => value = 6,
+            "7" => value = 7,
+            "8" => value = 8,
+            "9" => value = 9,
+            "10" => value = 10,
+            "JACK" => value = 10,
+            "QUEEN" => value = 10,
+            "KING" => value = 10,
+            _ => value = 0,
+        }
+
+        return value;
+    }
+}
+struct HAND<'a> {
+    cards: Vec<CARD<'a>>,
+}
+impl<'a> HAND<'a> {
+    /**
+     * returns a new empty hand
+     */
+    fn new() -> HAND<'a> {
+        return HAND { cards: Vec::new()};
+    }
+    
+    /**
+     * add a passed card to this hand 
+     */
+    fn add_card(&mut self, card: CARD<'a>) {
+        self.cards.push(card);
+    }
+
+    /**
+     * returns the total points of the cards in this hand
+     */
+    fn get_total(&self) -> usize {
+        let mut total:usize = 0;
+        for card in &self.cards {
+            total += card.value as usize;
+        }
+
+        //if there is an ACE, and the hand would otherwise bust, treat the ace like it's worth 1
+        if total > 21 && self.cards.iter().any(|c| -> bool {*c.name == *"ACE"}) {
+            total -= 10;
+        }
+
+        return total;
+    }
+
+    /**
+     * adds the cards in hand into the discard pile
+     */
+    fn discard_hand(&mut self, deck: &mut DECKS<'a>) {
+        let len = self.cards.len();
+        for _i in 0..len {
+            deck.discard_pile.push(self.cards.pop().expect("hand empty"));
+        }
+    }
+}
+struct DECKS<'a> {
+    deck: Vec<CARD<'a>>, //cards in the deck
+    discard_pile: Vec<CARD<'a>> //decks discard pile
+}
+impl<'a> DECKS<'a> {
+    /**
+     * creates a new full and shuffled deck, and an empty discard pile
+     */
+    fn new() -> DECKS<'a> {
+        //returns a number of full decks of 52 cards, shuffles them
+        //DATA
+        let mut deck = DECKS{deck: Vec::new(), discard_pile: Vec::new()};
+        let number_of_decks = 3; 
+
+        //fill deck
+        for _n in 0..number_of_decks { //fill deck with number_of_decks decks worth of cards
+            for card_name in CARD_NAMES { //add 4 of each card, totaling one deck with 4 of each card
+                deck.deck.push( CARD::new(card_name) );
+                deck.deck.push( CARD::new(card_name) );
+                deck.deck.push( CARD::new(card_name) );
+                deck.deck.push( CARD::new(card_name) );
+            }
+        }
+
+        //shuffle deck
+        deck.shuffle();
+
+        //return deck
+        return deck;
+    }
+
+    /**
+     * shuffles the deck
+     */
+    fn shuffle(&mut self) {
+        self.deck.shuffle(&mut thread_rng());
+    }
+
+    /**
+     * draw card from deck, and return it
+     * if deck is empty, shuffles discard pile into it and tries again
+     */
+    fn draw_card(&mut self) -> CARD<'a> {
+        match self.deck.pop() {
+            Some(card) => return card,
+            None => {
+                let len = self.discard_pile.len();
+
+                if len > 0 {//deck is empty, shuffle discard pile into deck and try again
+                    println!("deck is empty, shuffling");
+                    for _i in 0..len {
+                        self.deck.push( self.discard_pile.pop().expect("discard pile empty") )
+                    }
+                    self.shuffle();
+                    return self.draw_card();
+                } else { //discard pile and deck are empty, should never happen
+                    panic!("discard pile empty");
+                }
+            }
+        }
+    }
+}
+
+struct PLAYER<'a> {
+    hand: HAND<'a>,
+    balance: usize,
+    bet: usize,
+    wins: usize,
+    player_type: PlayerType,
+    index: usize,
+
+}
+impl<'a> PLAYER<'a> {
+    /**
+     * creates a new player of the given type
+     */
+    fn new(player_type: PlayerType, index: usize) -> PLAYER<'a> {
+        return PLAYER { hand: HAND::new(), balance: STARTING_BALANCE, bet: 0, wins: 0, player_type: player_type, index: index};
+    }
+
+    fn get_name(&self) -> String {
+        format!("{}{}", self.player_type.to_string(),self.index)
+    }
+
+    /**
+     * gets a bet from the player
+     */
+    fn get_bet(&mut self) {
+        if let PlayerType::Player = self.player_type {
+            if self.balance < 1 {
+                println!("{} is out of money :(", self.get_name());
+                self.bet = 0;
+            }
+            self.bet = get_number_from_user_input(format!("{}\tBet?",self.get_name()).as_str(), 1, self.balance);
+        }
+    }
+
+    /**
+     * returns a string of the players hand
+     * 
+     * if player is a dealer, returns the first card in the hand followed by *'s for every other card
+     * if player is a player, returns every card and the total
+     */
+    fn hand_as_string(&self, hide_dealer:bool) -> String {
+        if !hide_dealer {
+            return format!(
+                "{}\n\ttotal points = {}", //message
+                { //cards in hand
+                    let mut s:String = String::new();
+                    for cards_in_hand in self.hand.cards.iter().rev() {
+                        s += format!("{}\t", cards_in_hand.name).as_str();
+                    }
+                    s
+                },
+                self.hand.get_total() //total points in hand
+            );
+        }
+        else {
+            match &self.player_type {
+                &PlayerType::Dealer =>  { //if this is a dealer
+                    return format!(
+                        "{}*",//message 
+                        { //*'s for other cards
+                            let mut s:String = String::new();
+                            let mut cards_in_hand = self.hand.cards.iter();
+                            cards_in_hand.next();//consume first card drawn
+                            for c in cards_in_hand.rev() {
+                                s += format!("{}\t", c.name).as_str();
+                            }
+                            s
+                        }
+                    );
+                },
+                &PlayerType::Player => { //if this is a player
+                    return format!(
+                        "{}\n\ttotal points = {}", //message
+                        { //cards in hand
+                            let mut s:String = String::new();
+                            for cards_in_hand in self.hand.cards.iter().rev() {
+                                s += format!("{}\t", cards_in_hand.name).as_str();
+                            }
+                            s
+                        },
+                        self.hand.get_total() //total points in hand
+                    );
+                }
+            }
+        }
+    }
+
+    /** 
+     * get the players 'play'
+     */
+    fn get_play(&self) -> Play {
+        /*
+         do different things depending on what type of player this is:
+         if it's a dealer, use an algorithm to determine the play
+         if it's a player, ask user for input
+         */
+        match &self.player_type { 
+            &PlayerType::Dealer => {
+                if self.hand.get_total() > 16 { // if total value of hand is greater than 16, stand
+                    return Play::Stand;
+                } else { //otherwise hit
+                    return Play::Hit;
+                }
+            },
+            &PlayerType::Player => {
+                let valid_results:Vec<char>;
+                if self.hand.cards.len() > 2 {//if there are more than 2 cards in the hand, at least one turn has happened, so splitting and doubling down are not allowed
+                    valid_results = vec!['s','S','h','H'];
+                } else {
+                    valid_results = vec!['s','S','h','H','d','D','/'];
+                }
+                let play = get_char_from_user_input("\tWhat is your play?", &valid_results);
+                match play {
+                    's' | 'S' => return Play::Stand,
+                    'h' | 'H' => return Play::Hit,
+                    'd' | 'D' => return Play::DoubleDown,
+                    '/'       => return Play::Split,
+                    _ => panic!("get_char_from_user_input() returned invalid character"),
+                }
+            },
+        }
+    }
+}
+
+struct GAME<'a> {
+    players: Vec<PLAYER<'a>>, //last item in this is the dealer
+    decks: DECKS<'a>,
+    games_played:usize,
+}
+impl<'a> GAME<'a> {
+    /**
+     * creates a new game
+     */
+    fn new(num_players:usize) -> GAME<'a> {
+        //DATA
+        let mut players: Vec<PLAYER> = Vec::new();
+
+        //add dealer
+        players.push(PLAYER::new(PlayerType::Dealer,0));
+        //create human player(s) (at least one)
+        players.push(PLAYER::new(PlayerType::Player,1));
+        for i in 2..=num_players { //one less than num_players players
+            players.push(PLAYER::new(PlayerType::Player,i));
+        }
+
+        //ask if they want instructions
+        if let 'y'|'Y' = get_char_from_user_input("Do you want instructions? (y/n)", &vec!['y','Y','n','N']) {
+            instructions();
+        }
+        println!();
+
+        //return a game
+        return GAME { players: players, decks: DECKS::new(), games_played: 0}
+    }
+
+    /**
+     * prints the score of every player
+     */
+    fn _print_stats(&self) {
+        println!("{}", self.stats_as_string());
+    }
+
+    /**
+     * returns a string of the wins, balance, and bets of every player
+     */
+    fn stats_as_string(&self) -> String {
+        format!("Scores:\n{}",{
+            let mut s = String::new();
+            self.players.iter().for_each(|p| {
+                //format the presentation of player stats
+                match p.player_type {
+                    PlayerType::Player => s+= format!("{} Wins:\t{}\t\tBalance:\t{}\t\tBet\t{}\n",p.get_name(),p.wins,p.balance,p.bet).as_str(),
+                    PlayerType::Dealer => s+= format!("{} Wins:\t{}\n",p.get_name(),p.wins).as_str()
+                }
+            });
+            s
+        })
+    }
+
+    /**
+     * plays a round of blackjack
+     */
+    fn play_game(&mut self) {
+        //DATA
+        let scores;
+        let game = self.games_played; //save it here so we don't have borrowing issues
+        let mut player_hands_message: String = String::new();//cache it here so we don't have borrowing issues
+        
+        //deal cards to each player
+        for _i in 0..2 { // do this twice
+            //draw card for each player
+            self.players.iter_mut().for_each(|player| {player.hand.add_card( self.decks.draw_card() );});
+        }
+
+        //get everyones bets
+        self.players.iter_mut().for_each(|player| player.get_bet());
+        scores = self.stats_as_string(); //save it here so we don't have borrowing issues later
+        
+        //play game for each player
+        for player in self.players.iter_mut() {
+            //turn loop, ends when player finishes their turn
+            loop{
+                //clear screen
+                clear();
+                //print welcome
+                welcome();
+                //print game state
+                println!("\n\t\t\tGame {}", game);
+                //print scores
+                println!("{}",scores);
+                //print hands of all players
+                print!("{}", player_hands_message);
+                println!("{} Hand:\t{}", player.get_name(), player.hand_as_string(true));
+
+                if let PlayerType::Player = player.player_type { //player isn't the dealer
+                    if player.bet == 0 {//player is out of money
+                        break;//exit turn loop
+                    }
+                }
+
+                //play through turn
+                //check their hand value for a blackjack(21) or bust
+                let score = player.hand.get_total();
+                if score >= 21 {
+                    if score == 21 { // == 21
+                        println!("\tBlackjack! (21 points)");
+                    } else { // > 21
+                        println!("\tBust      ({} points)", score);
+                    }
+                    break; //end turn
+                }
+
+                //get player move
+                let play = player.get_play();
+                //process play
+                match play {
+                    Play::Stand => {
+                        println!("\t{}", play.to_string());
+                        break; //end turn
+                    },
+                    Play::Hit => {
+                        println!("\t{}", play.to_string());
+                        //give them a card
+                        player.hand.add_card( self.decks.draw_card() );
+                    },
+                    Play::DoubleDown => {
+                        println!("\t{}", play.to_string());
+
+                        //double their balance if there's enough money, othewise go all-in
+                        if player.bet * 2 < player.balance { 
+                            player.bet *= 2;
+                        }
+                        else {
+                            player.bet = player.balance;
+                        }
+                        //give them a card
+                        player.hand.add_card( self.decks.draw_card() );
+                    },
+                    Play::Split => {
+
+                    },
+                }
+            }
+            
+            //add player to score cache thing
+            player_hands_message += format!("{} Hand:\t{}\n", player.get_name(), player.hand_as_string(true)).as_str();
+        }
+
+        //determine winner
+        let mut top_score = 0; //player with the highest points
+        let mut num_winners = 1;
+        for player in self.players.iter_mut().enumerate().filter( |x| -> bool {x.1.hand.get_total()<=21}) { //players_who_didnt_bust
+            let score = player.1.hand.get_total();
+            if score > top_score {
+                top_score = score;
+                num_winners = 1;
+            } else if score == top_score {
+                num_winners += 1;
+            }
+        }
+
+        //print winner(s)
+        self.players.iter_mut().filter(|x|->bool{x.hand.get_total()==top_score}).for_each(|x| {//for each player with the top score
+            print!("{} ", x.get_name());//print name
+            x.wins += 1;//increment their wins
+        });
+        if num_winners > 1 {println!("all tie with {}\n\n\n", top_score);} 
+        else {println!("wins with {}!\n\n\n",top_score);}
+
+        //handle bets
+        //remove money from losers
+        self.players.iter_mut().filter(|p| p.hand.get_total()!=top_score).for_each( |p| p.balance -= p.bet); //for every player who didn't get the winning score, remove their bet from their balance
+        //add money to winner
+        self.players.iter_mut().filter(|p| p.hand.get_total()==top_score).for_each(|p| p.balance += p.bet); //for each player who got the winning score, add their bet to their balance
+
+        //discard hands
+        self.players.iter_mut().for_each(|player| {player.hand.discard_hand(&mut self.decks);});
+
+        //increment games_played
+        self.games_played += 1;
+    }
+
+
+
+}
+
+const CARD_NAMES: [&str;13] = ["ACE","2","3","4","5","6","7","8","9","10","JACK","QUEEN","KING"];
+const STARTING_BALANCE: usize = 100;
+
+fn main() {
+    //DATA
+    let mut game: GAME;
+
+    //print welcome message
+    welcome();
+
+    //create game    
+    game = GAME::new( get_number_from_user_input("How many players should there be (at least 1)?", 1, 7) );
+
+    //game loop, play game until user wants to stop
+    loop {
+        //play round
+        game.play_game();
+
+        //ask if they want to play again
+        match get_char_from_user_input("Play Again? (y/n)", &vec!['y','Y','n','N']) {
+            'y' | 'Y' => continue,
+            'n' | 'N' => break,
+            _ => break,
+        }
+    }
+}
+
+/**
+ * prints the welcome screen
+ */
+fn welcome() {
+    //welcome message
+    print!("
+                            BLACK JACK
+              CREATIVE COMPUTING  MORRISTOWN, NEW JERSEY    
+    \n\n");
+}
+
+/**
+ * prints the instructions
+ */
+fn instructions() {
+    println!("
+    THIS IS THE GAME OF 21. AS MANY AS 7 PLAYERS MAY PLAY THE
+    GAME. ON EACH DEAL, BETS WILL BE ASKED FOR, AND THE
+    PLAYERS' BETS SHOULD BE TYPED IN. THE CARDS WILL THEN BE
+    DEALT, AND EACH PLAYER IN TURN PLAYS HIS HAND. THE
+    FIRST RESPONSE SHOULD BE EITHER 'D', INDICATING THAT THE
+    PLAYER IS DOUBLING DOWN, 'S', INDICATING THAT HE IS
+    STANDING, 'H', INDICATING HE WANTS ANOTHER CARD, OR '/',
+    INDICATING THAT HE WANTS TO SPLIT HIS CARDS. AFTER THE
+    INITIAL RESPONSE, ALL FURTHER RESPONSES SHOULD BE 'S' OR
+    'H', UNLESS THE CARDS WERE SPLIT, IN WHICH CASE DOUBLING
+    DOWN IS AGAIN PERMITTED. IN ORDER TO COLLECT FOR
+    BLACKJACK, THE INITIAL RESPONSE SHOULD BE 'S'.
+    NUMBER OF PLAYERS
+
+    NOTE:'/' (splitting) is not currently implemented, and does nothing
+    
+    PRESS ENTER TO CONTINUE
+    ");
+    io::stdin().read_line(&mut String::new()).expect("Failed to read line");
+}
+
+/**
+ * gets a usize integer from user input
+ */
+fn get_number_from_user_input(prompt: &str, min:usize, max:usize) -> usize {
+    //input loop
+    return loop {
+        let mut raw_input = String::new(); // temporary variable for user input that can be parsed later
+
+        //print prompt
+        println!("{}", prompt);
+        stdout().flush().expect("Failed to flush to stdout.");
+        //read user input from standard input, and store it to raw_input
+        //raw_input.clear(); //clear input
+        io::stdin().read_line(&mut raw_input).expect( "CANNOT READ INPUT!");
+
+        //from input, try to read a number
+        match raw_input.trim().parse::<usize>() {
+            Ok(i) => {
+                if i < min || i > max { //input out of desired range
+                    println!("INPUT OUT OF VALID RANGE.  TRY AGAIN.  {}-{}",min,max);
+                    continue; // run the loop again
+                } 
+                else {
+                    break i;// this escapes the loop, returning i 
+                }
+            },
+            Err(e) => {
+                println!("INVALID INPUT.  TRY AGAIN.  {}", e.to_string().to_uppercase());
+                continue; // run the loop again
+            }
+        };
+    };
+}
+
+/**
+ * gets a character from user input
+ * returns the first character they type
+ */
+fn get_char_from_user_input(prompt: &str, valid_results: &Vec<char>) -> char {
+    //input loop
+    return loop {
+        let mut raw_input = String::new(); // temporary variable for user input that can be parsed later
+
+        //print prompt
+        println!("{}", prompt);
+        stdout().flush().expect("Failed to flush to stdout.");
+        //read user input from standard input, and store it to raw_input
+        //raw_input.clear(); //clear input
+        io::stdin().read_line(&mut raw_input).expect( "CANNOT READ INPUT!");
+
+        //from input, try to read a valid character
+        match raw_input.trim().chars().nth(0) {
+            Some(i) => {
+                if !valid_results.contains(&i) { //input out of desired range
+                    println!("INPUT IS NOT VALID CHARACTER.  TRY AGAIN.");
+                    continue; // run the loop again
+                } 
+                else {
+                    break i;// this escapes the loop, returning i 
+                }
+            },
+            None => {
+                println!("INVALID INPUT.  TRY AGAIN.");
+                continue; // run the loop again
+            }
+        };
+    };
+}
+
+/**
+ * clear std out
+ */
+fn clear() {
+    println!("\x1b[2J\x1b[0;0H");
+}