EP.74 Customizing WebSocket Server for Multilingual Support

In this episode, we'll explore how to customize a WebSocket server to support multiple languages (Multilingual Support) in a real-time chat application. This feature enables users to communicate in their preferred languages without the need for developing separate apps for each language or region.

Adding multilingual support is a powerful enhancement for applications targeting global audiences, as it greatly improves usability and user satisfaction across different cultures.

🔸 Why Multilingual Support Matters in WebSocket Chat

1. Broader User Reach:
Users from different countries can choose the language they're most comfortable with, allowing you to serve a global audience.

2. Better Communication Experience:
Users don’t need to rely on external translation tools — they can chat naturally in their own language.

3. Expanding into New Markets:
Supporting multiple languages opens doors to new regional markets and user bases.

4. Enhanced User Experience (UX):
Users feel more connected and comfortable using an app when they can use it in their native language.

🔸 How to Add Multilingual Support to a WebSocket Server

1. Managing Language Preferences on the Server

1.1 Storing User Language Settings
You can store users' preferred languages in the database or in a session to personalize message responses.

ALTER TABLE users ADD COLUMN language VARCHAR(10) DEFAULT 'en';

1.2 Sending Messages Based on Language Preference
Here’s a simple example using Go, Gorilla WebSocket, and PostgreSQL.

✅ Full WebSocket Server Example in Go (with Multilingual Support)

package main

import (
    "log"
    "net/http"
    "github.com/gorilla/websocket"
    "database/sql"
    _ "github.com/lib/pq"
)

var clients = make(map[*websocket.Conn]string)
var db *sql.DB

type Message struct {
    User    string `json:"user"`
    Message string `json:"message"`
}

var upgrader = websocket.Upgrader{
    CheckOrigin: func(r *http.Request) bool {
        return true
    },
}

func init() {
    var err error
    db, err = sql.Open("postgres", "user=username dbname=chatapp sslmode=disable")
    if err != nil {
        log.Fatal(err)
    }
}

func handleConnections(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println(err)
        return
    }
    defer conn.Close()

    lang := r.URL.Query().Get("lang")
    if lang == "" {
        lang = "en"
    }
    clients[conn] = lang

    for {
        var msg Message
        err := conn.ReadJSON(&msg)
        if err != nil {
            log.Println(err)
            delete(clients, conn)
            break
        }
        translateAndBroadcast(msg, lang)
    }
}

func translateAndBroadcast(msg Message, lang string) {
    translatedMessage := msg.Message
    if lang == "es" {
        translatedMessage = "¡Hola, " + msg.User + "!"
    }

    for client := range clients {
        err := client.WriteJSON(Message{
            User:    msg.User,
            Message: translatedMessage,
        })
        if err != nil {
            log.Println(err)
            client.Close()
            delete(clients, client)
        }
    }
}

func main() {
    http.HandleFunc("/", handleConnections)
    log.Println("Server started on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

2. Translating Messages Dynamically

Messages can be translated using:

External APIs such as Google Translate API
Predefined translation files (e.g., .json, .yaml) loaded into the app

3. Updating the UI to Support Language Selection

On the client side, allow users to choose their preferred language via a dropdown:

<select id="languageSelector" onchange="changeLanguage()">
    <option value="en">English</option>
    <option value="es">Español</option>
    <option value="fr">Français</option>
</select>

<script>
function changeLanguage() {
    var selectedLanguage = document.getElementById("languageSelector").value;
    // Send the language preference to WebSocket
    socket.send(JSON.stringify({ language: selectedLanguage }));
}
</script>

🔸 Testing Multilingual Support

Make sure to test the following:

✅ Language Switching: Ensure the server sends messages in the selected language.
✅ Message Translation: Confirm that messages are being translated properly.
✅ Performance: The server should maintain stable performance even when translating for multiple users in real-time.

💡 Challenge: Build It Better

Try integrating real-time auto-translation so users can communicate in their native languages without barriers — even across language differences!

🔜 Coming Next in EP.75:

Using Redis for User State Management in WebSocket

In the next episode, we’ll explore how Redis can be used to manage user presence, chat rooms, and real-time status updates efficiently.

Read more

🔵 Facebook: Superdev School (Superdev)

📸 Instagram: superdevschool

🎬 TikTok: superdevschool

🌐 Website: www.superdev.school