Skip to content
Python Central Hub

Real-time Chat Application

View on GitHub

Abstract

Real-time Chat Application is a Python project that enables users to chat in real time over a network. It demonstrates socket programming, threading, and GUI development. This project is ideal for learning about client-server architecture, concurrency, and event-driven programming.

Prerequisites

  • Python 3.6 or above
  • socket, threading (built-in)
  • tkinter (usually pre-installed)

Before you Start

Ensure Python is installed. No external packages are required. For GUI, make sure Tkinter is available.

Getting Started

  1. Create a folder named real-time-chatreal-time-chat.
  2. Create a file named real_time_chat_application.pyreal_time_chat_application.py.
  3. Copy the code below into your file.
⚙️ Real-time Chat Application
Real-time Chat Application
"""
Real-time Chat Application (WebSocket)
 
A Python application that enables real-time communication between clients using WebSocket.
Features include:
- Real-time messaging between multiple clients.
- Server-side implementation using `websockets` library.
- Client-side implementation for sending and receiving messages.
"""
 
import asyncio
import websockets
 
connected_clients = set()
 
async def handle_client(websocket, path):
    """Handle incoming messages from clients and broadcast them."""
    connected_clients.add(websocket)
    try:
        async for message in websocket:
            print(f"Received message: {message}")
            await broadcast(message)
    except websockets.ConnectionClosed:
        print("Client disconnected")
    finally:
        connected_clients.remove(websocket)
 
async def broadcast(message):
    """Send a message to all connected clients."""
    if connected_clients:  # Ensure there are clients to broadcast to
        await asyncio.wait([client.send(message) for client in connected_clients])
 
async def main():
    """Start the WebSocket server."""
    server = await websockets.serve(handle_client, "localhost", 8765)
    print("Server started on ws://localhost:8765")
    await server.wait_closed()
 
if __name__ == "__main__":
    asyncio.run(main())
Real-time Chat Application
"""
Real-time Chat Application (WebSocket)
 
A Python application that enables real-time communication between clients using WebSocket.
Features include:
- Real-time messaging between multiple clients.
- Server-side implementation using `websockets` library.
- Client-side implementation for sending and receiving messages.
"""
 
import asyncio
import websockets
 
connected_clients = set()
 
async def handle_client(websocket, path):
    """Handle incoming messages from clients and broadcast them."""
    connected_clients.add(websocket)
    try:
        async for message in websocket:
            print(f"Received message: {message}")
            await broadcast(message)
    except websockets.ConnectionClosed:
        print("Client disconnected")
    finally:
        connected_clients.remove(websocket)
 
async def broadcast(message):
    """Send a message to all connected clients."""
    if connected_clients:  # Ensure there are clients to broadcast to
        await asyncio.wait([client.send(message) for client in connected_clients])
 
async def main():
    """Start the WebSocket server."""
    server = await websockets.serve(handle_client, "localhost", 8765)
    print("Server started on ws://localhost:8765")
    await server.wait_closed()
 
if __name__ == "__main__":
    asyncio.run(main())
  1. Run the server and client scripts as described in the code comments.

Explanation

Code Breakdown

  1. Import required modules.
import socket
import threading
import tkinter as tk
import socket
import threading
import tkinter as tk
  1. Server setup.
def start_server():
    # Accepts connections and relays messages
    pass
def start_server():
    # Accepts connections and relays messages
    pass
  1. Client setup.
def start_client():
    # Connects to server and sends/receives messages
    pass
def start_client():
    # Connects to server and sends/receives messages
    pass
  1. GUI for chat.
root = tk.Tk()
root.title('Real-time Chat Application')
# ...setup widgets for chat display and input...
root.mainloop()
root = tk.Tk()
root.title('Real-time Chat Application')
# ...setup widgets for chat display and input...
root.mainloop()

Features

  • Real-time text chat
  • Multiple users
  • Simple GUI
  • Demonstrates sockets and threading

How It Works

  • Server listens for connections
  • Clients connect and send messages
  • Messages are broadcast to all clients
  • GUI displays chat and allows input

GUI Components

  • Text area: Shows chat history
  • Entry box: For message input
  • Send button: Sends message

Use Cases

  • Learn networking basics
  • Build simple chat apps
  • Experiment with concurrency

Next Steps

You can enhance this project by:

  • Adding user authentication
  • Supporting private messages
  • Improving GUI design
  • Adding emojis or file sharing
  • Implementing message history

Enhanced Version Ideas

def add_authentication():
    # Require login for chat
    pass
 
def save_chat_history():
    # Store messages in a file
    pass
def add_authentication():
    # Require login for chat
    pass
 
def save_chat_history():
    # Store messages in a file
    pass

Troubleshooting Tips

  • Connection errors: Check IP and port
  • GUI not showing: Ensure Tkinter is installed
  • Messages not sent: Check server/client status

Conclusion

This project teaches networking, threading, and GUI basics. Extend it for more features and better user experience.

Was this page helpful?

Let us know how we did