diff --git a/exercises/20_threads/threads1.rs b/exercises/20_threads/threads1.rs
index bf0b8e0d..01f9ff44 100644
--- a/exercises/20_threads/threads1.rs
+++ b/exercises/20_threads/threads1.rs
@@ -3,31 +3,35 @@
 // wait until all the spawned threads have finished and should collect their
 // return values into a vector.
 
-use std::thread;
-use std::time::{Duration, Instant};
+use std::{
+    thread,
+    time::{Duration, Instant},
+};
 
 fn main() {
-    let mut handles = vec![];
+    let mut handles = Vec::new();
     for i in 0..10 {
-        handles.push(thread::spawn(move || {
+        let handle = thread::spawn(move || {
             let start = Instant::now();
             thread::sleep(Duration::from_millis(250));
-            println!("thread {} is complete", i);
+            println!("Thread {i} done");
             start.elapsed().as_millis()
-        }));
+        });
+        handles.push(handle);
     }
 
-    let mut results: Vec<u128> = vec![];
+    let mut results = Vec::new();
     for handle in handles {
-        // TODO: a struct is returned from thread::spawn, can you use it?
+        // TODO: Collect the results of all threads into the `results` vector.
+        // Use the `JoinHandle` struct which is returned by `thread::spawn`.
     }
 
     if results.len() != 10 {
-        panic!("Oh no! All the spawned threads did not finish!");
+        panic!("Oh no! Some thread isn't done yet!");
     }
 
     println!();
     for (i, result) in results.into_iter().enumerate() {
-        println!("thread {} took {}ms", i, result);
+        println!("Thread {i} took {result}ms");
     }
 }
diff --git a/rustlings-macros/info.toml b/rustlings-macros/info.toml
index cacdad90..37afa178 100644
--- a/rustlings-macros/info.toml
+++ b/rustlings-macros/info.toml
@@ -1037,7 +1037,7 @@ hint = """
 https://doc.rust-lang.org/std/thread/fn.spawn.html
 
 A challenge with multi-threaded applications is that the main thread can
-finish before the spawned threads are completed.
+finish before the spawned threads are done.
 https://doc.rust-lang.org/book/ch16-01-threads.html#waiting-for-all-threads-to-finish-using-join-handles
 
 Use the `JoinHandle`s to wait for each thread to finish and collect their
diff --git a/solutions/20_threads/threads1.rs b/solutions/20_threads/threads1.rs
index 4e181989..7f3dd29a 100644
--- a/solutions/20_threads/threads1.rs
+++ b/solutions/20_threads/threads1.rs
@@ -1 +1,37 @@
-// Solutions will be available before the stable release. Thank you for testing the beta version 🥰
+// This program spawns multiple threads that each run for at least 250ms, and
+// each thread returns how much time they took to complete. The program should
+// wait until all the spawned threads have finished and should collect their
+// return values into a vector.
+
+use std::{
+    thread,
+    time::{Duration, Instant},
+};
+
+fn main() {
+    let mut handles = Vec::new();
+    for i in 0..10 {
+        let handle = thread::spawn(move || {
+            let start = Instant::now();
+            thread::sleep(Duration::from_millis(250));
+            println!("Thread {i} done");
+            start.elapsed().as_millis()
+        });
+        handles.push(handle);
+    }
+
+    let mut results = Vec::new();
+    for handle in handles {
+        // Collect the results of all threads into the `results` vector.
+        results.push(handle.join().unwrap());
+    }
+
+    if results.len() != 10 {
+        panic!("Oh no! Some thread isn't done yet!");
+    }
+
+    println!();
+    for (i, result) in results.into_iter().enumerate() {
+        println!("Thread {i} took {result}ms");
+    }
+}