Rust retro chat App – A Custom TUI Chat with Client & Server (Cursive Library)

Introducing Retro Chat, a custom Terminal User Interface (TUI) chat application built entirely in Rust! ⚡ This project features both client and server implementations, allowing seamless real-time communication over a network. Designed with a retro aesthetic, it brings back the old-school chatroom vibes with modern Rust performance! 🦀

Key Features:
✅ Built with Rust – High performance & memory safety
✅ TUI Interface – Classic, terminal-based chat experience
✅ Client-Server Model – Supports multiple users
✅ Real-time Messaging – Fast, efficient, and lightweight
✅ Connection Logs – Monitor user activity easily

Rut Book: https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html
Rust Full Course: https://www.youtube.com/watch?v=rQ_J9WH6CGk&t=11s
GitHub Repo: https://github.com/BekBrace/rust-retro-chat

Timestamps:
0:00 - Introduction and thanking viewers for support.
0:26 - Apology for sound quality issues during the server file creation.
1:17 - Introduction to creating a retro chat application in Rust.
1:40 - Starting with the server file and creating a new project using cargo new.
2:14 - Adding dependencies in Cargo.toml (Cursive, Tokio, Serde, Chrono).
3:02 - Explanation of serialization and deserialization using Serde.
4:07 - Creating the server file and importing necessary libraries (Tokio, TCP listener, etc.).
5:08 - Explanation of asynchronous runtime using Tokio.
6:03 - Transforming the main function from synchronous to asynchronous using Tokio.
7:02 - Setting up TCP listener and broadcast channels for message distribution.
8:02 - Explanation of buffered reading and writing for efficient I/O operations.
10:05 - Defining the ChatMessage struct and MessageType enum.
13:45 - Creating the ChatMessage struct with fields: username, content, timestamp, and message type.
15:15 - Defining the MessageType enum for user messages and system notifications.
16:01 - Explanation of Tokio and its role in asynchronous programming.
19:03 - Setting up the main server loop to handle incoming connections.
22:02 - Creating a broadcast channel for message distribution.
23:10 - Accepting new connections and displaying connection information.
25:27 - Spawning a new task to handle each connection asynchronously.
26:29 - Creating the handle_connection function to manage individual client connections.
29:04 - Reading the username sent by the client and cleaning it.
31:35 - Sending a system notification when a user joins the chat.
33:38 - Serializing the join message to JSON format.
35:09 - Broadcasting the join message to all connected clients.
36:13 - Running the server and checking for errors.
38:14 - Handling incoming messages from clients and broadcasting them.
40:29 - Handling incoming broadcasts and sending them to the client.
43:34 - Sending a system notification when a user leaves the chat.
44:35 - Logging disconnection information to the console.
45:28 - Invoking the handle_connection function inside the server loop.
46:28 - Running the server and confirming it works without errors.
47:46 - Introduction to creating the client side of the application.
48:11 - Importing modules from the Cursive library for UI development.
50:01 - Setting up the main function and creating a custom retro theme.
52:16 - Fetching the username from command line arguments.
54:47 - Initializing the Cursive UI framework and applying the retro theme.
55:55 - Creating a header to display the chat title and username.
58:29 - Creating a message area with a scrollable text view.
1:01:02 - Creating an input area for typing messages.
1:02:29 - Creating help text for user commands (e.g., /clear, /quit).
1:03:40 - Assembling the main layout with header, messages, and input areas.
1:07:02 - Adding global key bindings for quitting and inserting commands.
1:08:13 - Establishing a connection to the chat server.
1:10:06 - Splitting the stream into reader and writer for handling messages.
1:12:26 - Sending the username to the server and handling incoming messages.
1:14:52 - Spawning an asynchronous task to handle incoming messages from other users.
1:17:20 - Running the client and testing the connection with the server.
1:18:52 - Handling user input and sending messages to the server.
1:20:11 - Adding functionality for commands like /help, /clear, and /quit.
1:22:01 - Finalizing the client setup and running the application.
1:38:36 - Running the server and multiple clients to test the chat application.
1:39:10 - Testing user interactions, sending messages, and using commands.
1:40:47 - Testing user disconnection and system notifications.
1:41:08 - Testing the /clear and /quit commands.
1:41:25 - Final demonstration of the chat application working as expected.
1:41:31 - Thanking viewers for watching and encouraging comments and questions.
1:41:36 - Closing remarks and farewell.

Видео Rust retro chat App – A Custom TUI Chat with Client & Server (Cursive Library) канала BekBrace