Core Features

Review CometChat iOS UI Kit core features for messaging, media sharing, receipts, typing indicators, presence, reactions, threads, and search.

AI Integration Quick Reference

{
  "category": "messaging",
  "features": [
    {"name": "instantMessaging", "description": "Send and receive text messages in real-time", "component": "CometChatMessageList", "enabledByDefault": true},
    {"name": "mediaSharing", "description": "Share images, videos, audio files, and documents", "component": "CometChatMessageComposer", "enabledByDefault": true},
    {"name": "readReceipts", "description": "Show when messages are delivered and read", "component": "CometChatMessageList", "enabledByDefault": true},
    {"name": "typingIndicators", "description": "Show when users are typing in real-time", "component": "CometChatMessageHeader", "enabledByDefault": true},
    {"name": "userPresence", "description": "Display online/offline status for users", "component": "CometChatConversations", "enabledByDefault": true},
    {"name": "reactions", "description": "Let users react to messages with emojis", "component": "CometChatMessageList", "enabledByDefault": true},
    {"name": "mentions", "description": "Tag users in messages with @mentions", "component": "CometChatMessageComposer", "enabledByDefault": true},
    {"name": "threadedConversations", "description": "Reply to specific messages in threads", "component": "CometChatThreadedMessageHeader", "enabledByDefault": true},
    {"name": "threadSubscription", "description": "Subscribe to or unsubscribe from a thread's replies — a bell in the thread screen's top bar, plus an option in the message action sheet", "component": "CometChatMessageHeader, CometChatMessageList", "enabledByDefault": true},
    {"name": "groupChat", "description": "Create and manage group conversations", "component": "CometChatGroups", "enabledByDefault": true},
    {"name": "search", "description": "Search across conversations and messages", "component": "CometChatSearch", "enabledByDefault": true}
  ],
  "relatedComponents": ["CometChatMessageList", "CometChatConversations", "CometChatMessageList", "CometChatMessageComposer"]
}

CometChat UI Kit provides production-ready components that work together to deliver a complete chat experience. This guide shows how to implement each core feature with copy-paste code examples.

Instant Messaging

Send and receive text messages in real-time.

import UIKit
import CometChatUIKitSwift
import CometChatSDK

class ChatViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // For one-on-one chat
        let messagesVC = MessagesVC()   // your own VC — see /ui-kit/ios/ios-conversation
        
        // Set the user to chat with
        CometChat.getUser(UID: "cometchat-uid-1") { user in
            DispatchQueue.main.async {
                messagesVC.set(user: user)
                self.navigationController?.pushViewController(messagesVC, animated: true)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
}

Components Used:

• MessageComposer - Text input and send button
• MessageList - Displays sent and received messages
• Messages - Complete messaging screen (includes both)

Media Sharing

Share multiple images, videos, audio files, and documents in a single send. Tapping the attachment button opens a multi-select picker; the picks stage in a preview tray above the input box with per-file upload progress, and send together with an optional caption. Everything works out of the box:

import UIKit
import CometChatUIKitSwift
import CometChatSDK

class MediaChatViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        let messagesVC = MessagesVC()   // your own VC — see /ui-kit/ios/ios-conversation
        
        // The message composer includes multi-attachment media sharing:
        // - Multi-select photos and videos from the library
        // - Camera capture
        // - Multiple documents and audio files
        // - Clipboard paste (images, videos, documents, audio)
        // Picks stage in a preview tray, upload with progress, and send
        // as one batch with the composer text as the caption.
        
        CometChat.getUser(UID: "cometchat-uid-1") { user in
            DispatchQueue.main.async {
                messagesVC.set(user: user)
                self.navigationController?.pushViewController(messagesVC, animated: true)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
}

Received messages render with per-type bubbles: a media grid for images and videos (with a fullscreen viewer — swipe, zoom, per-photo download, share), playback rows for audio files, and a connected card stack for documents. Messages from one send are grouped visually in the list. Per-message file count and per-file size limits come from your app’s dashboard settings; violations surface directly in the tray.

See Message Composer — Multiple Attachments for configuration and Message Bubble Styling for the bubbles.

Supported Media Types:

Type	Bubble Component
Images	Image Bubble · multiple: Media Grid Bubble
Videos	Video Bubble · multiple: Media Grid Bubble
Audio	Audio Bubble (voice notes) · Audio Files Bubble
Files	File Bubble · multiple: Files Bubble

Read Receipts

Show when messages are delivered and read.

import UIKit
import CometChatUIKitSwift
import CometChatSDK

class ReceiptsViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Read receipts are enabled by default
        let messagesVC = MessagesVC()   // your own VC — see /ui-kit/ios/ios-conversation
        
        // To hide receipts:
        // messagesVC.hideReceipts = true
        
        CometChat.getUser(UID: "cometchat-uid-1") { user in
            DispatchQueue.main.async {
                messagesVC.set(user: user)
                self.navigationController?.pushViewController(messagesVC, animated: true)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
    
    // View detailed message information
    func showMessageInfo(for message: BaseMessage) {
        let messageInfo = CometChatMessageInformation()
        messageInfo.set(message: message)
        navigationController?.pushViewController(messageInfo, animated: true)
    }
}

Receipt States:

• ✓ Sent - Message sent to server
• ✓✓ Delivered - Message delivered to recipient’s device
• ✓✓ (blue) Read - Recipient has seen the message

Components Used:

• Conversations - Shows receipt status on last message
• MessageList - Shows receipts on each message
• MessageInformation - Detailed delivery/read info

Mark As Unread

Let users mark messages as unread to revisit later.

import UIKit
import CometChatUIKitSwift
import CometChatSDK

class UnreadMessagesViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        let messagesVC = MessagesVC()   // your own VC — see /ui-kit/ios/ios-conversation
        
        // Enable starting from first unread message
        messagesVC.scrollToUnreadMessages = true
        
        CometChat.getUser(UID: "cometchat-uid-1") { user in
            DispatchQueue.main.async {
                messagesVC.set(user: user)
                self.navigationController?.pushViewController(messagesVC, animated: true)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
    
    // Mark a message as unread programmatically
    func markAsUnread(message: BaseMessage) {
        CometChat.markAsUnread(
            baseMessage: message
        ) { _ in
            print("Marked as unread")
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
}

Typing Indicators

Show when users are typing in real-time.

import UIKit
import CometChatUIKitSwift
import CometChatSDK

class TypingIndicatorViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Typing indicators are enabled by default in:
        // - CometChatConversations (shows "typing..." in conversation list)
        // - CometChatMessageHeader (shows "typing..." below user name)
        
        let messagesVC = MessagesVC()   // your own VC — see /ui-kit/ios/ios-conversation
        
        CometChat.getUser(UID: "cometchat-uid-1") { user in
            DispatchQueue.main.async {
                messagesVC.set(user: user)
                self.navigationController?.pushViewController(messagesVC, animated: true)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
    
    // Send typing indicator manually
    func startTyping(to receiverUID: String) {
        let typingIndicator = TypingIndicator(
            receiverID: receiverUID,
            receiverType: .user
        )
        CometChat.startTyping(indicator: typingIndicator)
    }
    
    func stopTyping(to receiverUID: String) {
        let typingIndicator = TypingIndicator(
            receiverID: receiverUID,
            receiverType: .user
        )
        CometChat.endTyping(indicator: typingIndicator)
    }
}

Components Used:

• Conversations - Shows typing in conversation list
• MessageHeader - Shows typing below user/group name

User Presence

Display online/offline status for users.

import UIKit
import CometChatUIKitSwift
import CometChatSDK

class PresenceViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // User presence is shown automatically in:
        // - CometChatConversations (green dot for online users)
        // - CometChatMessageHeader (shows "Online" or "Last seen")
        // - CometChatUsers (green dot for online users)
        // - CometChatGroupMembers (green dot for online members)
        
        let conversations = CometChatConversations()
        
        // To hide user status:
        // conversations.hideUserStatus = true
        
        navigationController?.pushViewController(conversations, animated: true)
    }
    
    // Listen for presence changes
    func listenForPresenceChanges() {
        CometChat.addUserListener("presence-listener", self)
    }
}

extension PresenceViewController: CometChatUserDelegate {
    func onUserOnline(user: User) {
        print("\(user.name ?? "") is now online")
    }
    
    func onUserOffline(user: User) {
        print("\(user.name ?? "") went offline")
    }
}

Reactions

Let users react to messages with emojis.

import UIKit
import CometChatUIKitSwift
import CometChatSDK

class ReactionsViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Reactions are enabled by default
        // Users can long-press a message to add reactions
        
        let messagesVC = MessagesVC()   // your own VC — see /ui-kit/ios/ios-conversation
        
        CometChat.getUser(UID: "cometchat-uid-1") { user in
            DispatchQueue.main.async {
                messagesVC.set(user: user)
                self.navigationController?.pushViewController(messagesVC, animated: true)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
    
    // Add reaction programmatically
    func addReaction(to message: BaseMessage, emoji: String) {
        CometChat.addReaction(
            messageId: message.id,
            reaction: emoji
        ) { message in
            print("Reaction added")
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
    
    // Remove reaction
    func removeReaction(from message: BaseMessage, emoji: String) {
        CometChat.removeReaction(
            messageId: message.id,
            reaction: emoji
        ) { message in
            print("Reaction removed")
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
}

Mentions

Tag users in messages with @mentions.

import UIKit
import CometChatUIKitSwift
import CometChatSDK

class MentionsViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Mentions are enabled by default
        // Type @ in the composer to see mention suggestions
        
        let messagesVC = MessagesVC()   // your own VC — see /ui-kit/ios/ios-conversation
        
        CometChat.getGroup(GUID: "group-123") { group in
            DispatchQueue.main.async {
                messagesVC.set(group: group)
                self.navigationController?.pushViewController(messagesVC, animated: true)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
    
    // Send message with mention programmatically
    func sendMessageWithMention(to groupID: String, mentionedUser: User) {
        let textMessage = TextMessage(
            receiverUid: groupID,
            text: "Hey @\(mentionedUser.name ?? ""), check this out!",
            receiverType: .group
        )
        
        // Add mentioned users
        textMessage.mentionedUsers = [mentionedUser]
        
        CometChat.sendTextMessage(message: textMessage) { message in
            print("Message with mention sent")
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
}

Rich Text Formatting

Rich Text Formatting allows users to style their messages with bold, italic, strikethrough, code, code blocks, blockquotes, ordered/unordered lists, and links. This brings richer expression to conversations and helps users emphasize key points.

enableRichTextFormatting and showRichTextFormattingOptions are true by default. See the CompactMessageComposer Rich Text Formatting section for full configuration details.

Rich text formatting in message bubbles (rendering formatted text in the MessageList) is supported from UI Kit version 5.2.11 onwards. Earlier versions will display the raw markdown syntax instead of formatted text.

Component	Functionality
CompactMessageComposer	Provides a built-in rich text editor with formatting toolbar and text selection menu items for bold, italic, strikethrough, code, links, lists, blockquotes, and code blocks.
MessageList	Renders formatted messages with the appropriate styling applied, displaying rich text formatting as intended by the sender.

Threaded Conversations

Reply to specific messages in threads.

import UIKit
import CometChatUIKitSwift
import CometChatSDK

class ThreadedMessagesViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Threaded messages are enabled by default
        // Users can tap "Reply in thread" on any message
        
        let messagesVC = MessagesVC()   // your own VC — see /ui-kit/ios/ios-conversation
        
        CometChat.getUser(UID: "cometchat-uid-1") { user in
            DispatchQueue.main.async {
                messagesVC.set(user: user)
                self.navigationController?.pushViewController(messagesVC, animated: true)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
    
    // Open thread view for a message
    // Note: Thread replies are handled automatically by CometChatMessageList
    // when user taps "Reply in thread". The thread view uses CometChatThreadedMessageHeader
    // combined with CometChatMessageList and CometChatMessageComposer.
    func openThread(for parentMessage: BaseMessage, user: User) {
        // Create a view controller to host the threaded messages
        let threadVC = UIViewController()
        threadVC.view.backgroundColor = .systemBackground
        
        // Create threaded message header
        let threadedHeader = CometChatThreadedMessageHeader()
        threadedHeader.set(parentMessage: parentMessage)
        threadedHeader.set(controller: threadVC)
        threadedHeader.translatesAutoresizingMaskIntoConstraints = false
        
        // Create message list for thread replies
        let messageList = CometChatMessageList()
        messageList.set(user: user)
        messageList.set(parentMessageId: parentMessage.id)
        messageList.set(controller: threadVC)
        messageList.translatesAutoresizingMaskIntoConstraints = false
        
        // Create composer for thread replies
        let composer = CometChatMessageComposer()
        composer.set(user: user)
        composer.set(parentMessageId: parentMessage.id)
        composer.set(controller: threadVC)
        composer.translatesAutoresizingMaskIntoConstraints = false
        
        // Add to view
        threadVC.view.addSubview(threadedHeader)
        threadVC.view.addSubview(messageList)
        threadVC.view.addSubview(composer)
        
        // Layout constraints
        NSLayoutConstraint.activate([
            threadedHeader.topAnchor.constraint(equalTo: threadVC.view.safeAreaLayoutGuide.topAnchor),
            threadedHeader.leadingAnchor.constraint(equalTo: threadVC.view.leadingAnchor),
            threadedHeader.trailingAnchor.constraint(equalTo: threadVC.view.trailingAnchor),
            
            messageList.topAnchor.constraint(equalTo: threadedHeader.bottomAnchor),
            messageList.leadingAnchor.constraint(equalTo: threadVC.view.leadingAnchor),
            messageList.trailingAnchor.constraint(equalTo: threadVC.view.trailingAnchor),
            messageList.bottomAnchor.constraint(equalTo: composer.topAnchor),
            
            composer.leadingAnchor.constraint(equalTo: threadVC.view.leadingAnchor),
            composer.trailingAnchor.constraint(equalTo: threadVC.view.trailingAnchor),
            composer.bottomAnchor.constraint(equalTo: threadVC.view.safeAreaLayoutGuide.bottomAnchor)
        ])
        
        navigationController?.pushViewController(threadVC, animated: true)
    }
    
    // Send reply in thread programmatically
    func sendThreadReply(parentMessage: BaseMessage, text: String) {
        let reply = TextMessage(
            receiverUid: parentMessage.receiverUid,
            text: text,
            receiverType: parentMessage.receiverType
        )
        reply.parentMessageId = parentMessage.id
        
        CometChat.sendTextMessage(message: reply) { message in
            print("Thread reply sent")
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
}

Component Used:

• ThreadedMessages - Displays thread replies

Thread Subscription

Available since v5.1.22

Let users subscribe to a thread to be notified about its replies, or unsubscribe to mute it. Users are subscribed automatically when they start a thread, reply in one, or are @-mentioned in one — subscribing explicitly is how they opt in to a thread they haven’t participated in yet.

On by default — there is no dashboard flag for this feature, so CometChatThreadSubscriptionConfig.setEnabled(false) is the only way to remove it. See Turning the Feature Off.

import UIKit
import CometChatUIKitSwift
import CometChatSDK

class ThreadSubscriptionViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

        let messageListView = CometChatMessageList()

        // The "Subscribe to thread" / "Unsubscribe from thread" option is
        // added to the message action sheet on parent messages only. Hide it
        // on one screen with hideThreadSubscriptionOption.
    }

}

// Stay in step with a toggle made anywhere in the kit.
extension ViewController: CometChatThreadEventListener {
    func ccThreadSubscriptionChanged(parentMessageId: Int, isSubscribed: Bool) {
        // update your own control, if you draw one
    }
}

See the Thread Subscription guide for the full feature.

Group Chat

Create and manage group conversations.

import UIKit
import CometChatUIKitSwift
import CometChatSDK

class GroupChatViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        showGroupsList()
    }
    
    // Show all groups
    func showGroupsList() {
        let groups = CometChatGroups()
        
        groups.set(onItemClick: { [weak self] group, _ in
            self?.openGroupChat(group: group)
        })
        
        navigationController?.pushViewController(groups, animated: true)
    }
    
    // Open chat for a group
    func openGroupChat(group: Group) {
        let messagesVC = MessagesVC()   // your own VC — see /ui-kit/ios/ios-conversation
        messagesVC.set(group: group)
        navigationController?.pushViewController(messagesVC, animated: true)
    }
    
    // Create a new group
    func createGroup(name: String, type: CometChat.groupType) {
        let group = Group(
            guid: UUID().uuidString,
            name: name,
            groupType: type,
            password: nil
        )
        
        CometChat.createGroup(group: group) { createdGroup in
            print("Group created: \(createdGroup.name ?? "")")
            DispatchQueue.main.async {
                self.openGroupChat(group: createdGroup)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
    
    // Join a public group
    func joinGroup(guid: String) {
        CometChat.joinGroup(
            GUID: guid,
            groupType: .public,
            password: nil
        ) { group in
            print("Joined group: \(group.name ?? "")")
            DispatchQueue.main.async {
                self.openGroupChat(group: group)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
}

Related Guide: Groups

Quoted Reply

Reply to specific messages with context.

import UIKit
import CometChatUIKitSwift
import CometChatSDK

class QuotedReplyViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Quoted reply is enabled by default
        // Users can swipe right on a message or tap "Reply" in message actions
        
        let messagesVC = MessagesVC()   // your own VC — see /ui-kit/ios/ios-conversation
        
        CometChat.getUser(UID: "cometchat-uid-1") { user in
            DispatchQueue.main.async {
                messagesVC.set(user: user)
                self.navigationController?.pushViewController(messagesVC, animated: true)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
}

Pin & Save Messages

Available since v5.1.22

Keep important messages in reach. Pinning highlights a message for everyone in the conversation and is restricted to group owners, admins and moderators — everyone else sees the pin indicator and the pinned list. Saving bookmarks a message privately for the acting user and spans every conversation, so saves are listed on a user-level screen rather than a per-conversation one.

import UIKit
import CometChatUIKitSwift
import CometChatSDK

class PinSaveMessagesViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

        let messageListView = CometChatMessageList()

        // Both are off by default — opt in, and each feature must also be
        // enabled for your app (CometChat.isPinMessageEnabled() and
        // CometChat.isSaveMessageEnabled()).
        messageListView.enablePinMessage = true
        messageListView.enableSaveMessage = true

        // Pinned messages are per-conversation.
        let pinnedVC = CometChatPinnedMessages(group: group)
        pinnedVC.set(onMessageClicked: { [weak self] message in
            self?.navigationController?.popViewController(animated: true)
            messageListView.goToMessage(withId: message.id)
        })
        navigationController?.pushViewController(pinnedVC, animated: true)

        // Saved messages span every conversation, so open this from app chrome.
        let savedVC = CometChatSavedMessages()
        savedVC.hideNavigationBar = false
        navigationController?.pushViewController(savedVC, animated: true)
    }
}

Components Used:

• MessageList - Adds Pin, Unpin, Save and Unsave to the message options, and shows the bubble indicators
• Pinned Messages - The messages pinned in one conversation
• Saved Messages - The current user’s saved messages, across every conversation
• Conversations - Lets users pin a whole conversation to the top of their list

See the Pin & Save Messages guide for end-to-end wiring.

Pin Conversations

Available since v5.1.22

Keep the chats that matter at the top. Users pin a conversation from its swipe action; pinned conversations show an indicator and stay above the rest of the list. An admin can also pin a conversation for everyone — those rows are not the user’s to unpin, so the affordance is not offered.

import UIKit
import CometChatUIKitSwift
import CometChatSDK

class PinConversationsViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

        let conversationsView = CometChatConversations()

        // Off by default — opt in, and the feature must also be enabled
        // for your app.
        conversationsView.enablePinConversation = true
    }
}

Component Used:

• Conversations - Provides the pin/unpin option, the row indicator, and pinned-first ordering

Search

Search across conversations and messages.

import UIKit
import CometChatUIKitSwift
import CometChatSDK

class SearchViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Search is available in:
        // - CometChatConversations (search bar at top)
        // - CometChatMessageHeader (search button)
        
        let conversations = CometChatConversations()
        
        // Search is enabled by default
        // To hide search:
        // conversations.hideSearch = true
        
        navigationController?.pushViewController(conversations, animated: true)
    }
    
    // Open dedicated search screen
    func openSearch() {
        let search = CometChatSearch()
        navigationController?.pushViewController(search, animated: true)
    }
}

Components Used:

• Search - Dedicated search screen
• MessageHeader - Search within conversation
• Conversations - Search conversations

Moderation

Automatically filter inappropriate content.

import UIKit
import CometChatUIKitSwift
import CometChatSDK

class ModerationViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Moderation is handled automatically based on your
        // CometChat dashboard settings
        
        // Blocked messages are displayed appropriately
        // based on your moderation rules
        
        let messagesVC = MessagesVC()   // your own VC — see /ui-kit/ios/ios-conversation
        
        CometChat.getUser(UID: "cometchat-uid-1") { user in
            DispatchQueue.main.async {
                messagesVC.set(user: user)
                self.navigationController?.pushViewController(messagesVC, animated: true)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
}

Configure moderation rules in your CometChat Dashboard.

Report Message

Allow users to report inappropriate messages.

import UIKit
import CometChatUIKitSwift
import CometChatSDK

class ReportMessageViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Report message is available in message actions
        // Users can long-press a message and select "Report"
        
        let messagesVC = MessagesVC()   // your own VC — see /ui-kit/ios/ios-conversation
        
        CometChat.getUser(UID: "cometchat-uid-1") { user in
            DispatchQueue.main.async {
                messagesVC.set(user: user)
                self.navigationController?.pushViewController(messagesVC, animated: true)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
}

View and manage reported messages in Flagged Messages.