diff --git a/coq/README.md b/coq/README.md
index d4f93aa..2b90119 100644
--- a/coq/README.md
+++ b/coq/README.md
@@ -1,8 +1,8 @@
 <p align = "center">
-    <img src = "https://upload.wikimedia.org/wikipedia/commons/d/d8/Coq_logo.png" width = "100">
+    <img src = "https://calebstanford.com/img/2018/coq-vector-logo/coq-logo-large.png" width = "200">
 </p>
 
-# Learn Coq with me
+# Introduction
 <a href = "https://github.com/alhassy/CoqCheatSheet/blob/master/CheatSheet.pdf">
     <img src = "https://img.shields.io/badge/-CheatSheet-blue">
 </a>
@@ -18,12 +18,12 @@ When I feel confident enough, I will film a 1-2h tutorial on Coq and attach it t
 <!-- - [Software Foundations](https://softwarefoundations.cis.upenn.edu/current/index.html) by Benjamin C. Pierce et al. -->
 
 ## ToC
-- [Learn Coq with me](#learn-coq-with-me)
+- [Introduction](#introduction)
   - [ToC](#toc)
   - [Motivation](#motivation)
   - [Installation](#installation)
 - [Basic Coq](#basic-coq)
-  - [Introduction](#introduction)
+  - [Introduction](#introduction-1)
   - [Comment on semantics](#comment-on-semantics)
     - [Type theory](#type-theory)
   - [Basic Concepts + Syntax](#basic-concepts--syntax)
diff --git a/rust/README.md b/rust/README.md
new file mode 100644
index 0000000..b68fe05
--- /dev/null
+++ b/rust/README.md
@@ -0,0 +1,28 @@
+<style>
+    /* Invert rust logo */
+    #rust img {
+        filter: invert(1);
+    }
+</style>
+
+<p align = "center">
+<span id=rust>
+<img src="https://raw.githubusercontent.com/devicons/devicon/master/icons/rust/rust-original.svg" alt="Rust" width="200"/>
+</span>
+</p>
+
+# Introduction
+On my journe to memory safety and due to lots of ridicule from my friends about daily-driving Python, I am currently looking for a systems programming language that is memory safe and has a good ecosystem (i.e. is not hated by everyone). In other words, I am looking for a *practically useful* language that is not Python or C++.
+
+Rust seems to be the perfect fit for this. This repository will document my journey in learning Rust.
+
+The process of learning this language is going to be quite different from my other repositories. I will try to design an embedded project in Rust, instead of focusing on algorithmic problems (i.e. practical problems). This will help me understand the language better and also give me a taste of what it is like to work with Rust in a real-world scenario.
+
+I'm going to try and ***actually document*** my process instead of my usual cheat-sheet style. 
+
+## ToC
+- [Introduction](#introduction)
+  - [ToC](#toc)
+
+
+
diff --git a/swift/README.md b/swift/README.md
index 4d7458f..52fcfd6 100644
--- a/swift/README.md
+++ b/swift/README.md
@@ -2,6 +2,14 @@
 <img src="https://raw.githubusercontent.com/devicons/devicon/master/icons/swift/swift-original.svg" alt="Swift" width="250"/>
 </p>
 
+# Introduction 
+I watched a Swift lecture by an apple guy at FOSDEM 2025. It was pretty cool. Inspired me to think about memory safety, and, needless to say, learn Swift.
+
+
+## ToC
+
+- [Introduction](#introduction)
+  - [ToC](#toc)
 - [General Notes](#general-notes)
   - [Swift project](#swift-project)
     - [Package.swift](#packageswift)
@@ -27,12 +35,11 @@
 - [Project-specific Notes](#project-specific-notes)
   - [Most likely teammates for Software engineering](#most-likely-teammates-for-software-engineering)
 
+
 # General Notes
 There are **NO** semicolons in Swift. The language is designed to be concise and readable. Very pythonic in that sense.
 
-Swift is a statically-typed language. This means that the type of a variable is known at compile time. This is in contrast to dynamically-typed languages like Python, where the type of a variable is determined at runtime.
-
-Swift deals with memory by using Automatic Reference Counting (ARC). This means that the compiler automatically manages memory for you. This is in contrast to languages like C and C++, where you have to manually manage memory.
+Swift is a statically-typed language. This means that the type of a variable is known at compile time. This is in contrast to dynamically-typed languages like Python, where the type of a variable is determined at runtime. It deals with memory by using Automatic Reference Counting (ARC). This means that the compiler automatically manages memory for us.
 
 Swift is a multi-paradigm language. This means that it supports multiple programming paradigms, such as object-oriented programming, functional programming, and procedural programming. We'll get into this later.