DEV Community: CometChat

Launching Gaming Chat SDK by CometChat on Product Hunt today

CometChat — Thu, 02 Jul 2026 09:39:07 +0000

Focus on building the game. We'll handle the chat. CometChat's Unreal SDK lets players talk to each other right inside the game, mid-match: 1:1 and group messaging, presence, moderation, and 40+ real-time delegates for messages, typing, and reactions. Full Blueprint and C++ support, so it fits your visual graph or your codebase. Ships with a chat panel and toggle button for your HUD, or build your own UI on CometChat's subsystem. Currently in beta, for Windows, macOS, iOS, and Android.

Feel free to check it out and upvote!
[https://www.producthunt.com/products/cometchat?launch=gaming-chat-sdk-by-cometchat]

On-Premises vs. Cloud Deployment for Enterprise Chat: How to Choose

CometChat — Thu, 02 Jul 2026 09:23:36 +0000

Most deployment decisions for enterprise chat get made the wrong way. Either the security team defaults to on-premises because that's what they know, or the engineering team defaults to cloud because that's what's faster. Neither instinct is wrong; they're just answering different questions.

The actual question is: what does your organization specifically need to control, and what are you willing to trade to get it? CometChat supports both deployment models (and the hybrid ground in between), which means this isn't a pitch for one over the other. It's a breakdown of how to figure out which one fits.

What You're Actually Deciding

On-premises and cloud aren't really about technology preference. They're about where responsibility sits.

With on-premises deployment, your infrastructure team owns everything: the servers, the network, the uptime, the patches, the scaling events at 3am when something unexpected happens. With cloud deployment, a vendor's infrastructure handles that layer, and your team operates on top of it.

Both can be secure. Both can be compliant. The difference is who carries the operational weight, and whether your specific requirements can be met by shared infrastructure at all.

The Case for On-Premises

On-premises deployment earns its place in specific situations. If any of these describe your organization, the case is real, not just a security-team default.

You're in a genuinely air-gapped environment. Defense contractors, government agencies, and certain financial institutions operate in environments where internet connectivity to external systems is either prohibited or impossible. For these organizations, cloud isn't a tradeoff; it's off the table. On-premises isn't a choice so much as a constraint.

Data residency requirements are legally binding, not just preferred. Some industries and regions have regulations that specify exactly where data must physically reside. "Our vendor's data center is in the EU" is different from "this data never leaves our infrastructure." If your legal team needs the second version, only on-premises gives you that.

Your security model requires controlling the encryption keys. Many cloud deployments encrypt data at rest and in transit, but the vendor holds the keys. If your compliance posture requires that your team, and only your team, controls the encryption keys for message content, on-premises is the only architecture that delivers that without compromise.

You've been burned by shared infrastructure before. Multi-tenant cloud environments are well-architected, but noisy-neighbor problems (where heavy usage from another tenant on shared infrastructure degrades your service), unexpected outages, and security incidents that originate in adjacent tenants are real risks. Organizations that have experienced these firsthand often have strong reasons to want dedicated infrastructure.

The total cost of ownership math works in your favor. On-premises requires significant upfront investment: hardware, networking, the engineering headcount to run it. But at sufficient scale, owning your infrastructure can be cheaper than paying per-user or per-message fees indefinitely. If your chat deployment is large and long-lived, run the numbers before assuming cloud is cheaper.

The Case for Cloud Deployment

Cloud deployment is the right call for most organizations, not because it's the default, but because the operational tradeoffs favor it in most situations.

You want to move fast without building an ops team. Running real-time messaging infrastructure at scale is not trivial. CometChat's cloud infrastructure already handles connection management, geographic distribution, failover, and message delivery guarantees in production. Your engineering team gets to focus on your product instead.

Your compliance requirements are standard. HIPAA, SOC 2, GDPR, ISO 27001: cloud deployments from reputable providers support all of these. If your compliance needs fit within what established certifications cover, shared infrastructure is a reasonable choice. The vendor's security investment is often more substantial than what most organizations can replicate on their own.

You need to scale unpredictably. Cloud infrastructure handles traffic spikes without requiring you to have provisioned for the peak in advance. If your usage patterns are variable (seasonal surges, rapid user growth, event-driven spikes), elasticity is worth a lot.

Geographic distribution matters for your users. Delivering low-latency messaging to users across multiple regions requires infrastructure in those regions. Building that yourself is a significant investment. Cloud providers have already done it.

You'd rather pay for uptime than engineer it. On-premises high availability requires redundant hardware, failover configuration, and the expertise to maintain it. Cloud providers build this in. If reliability is critical but you don't want to own the infrastructure that delivers it, cloud is the straightforward answer.

The Middle Ground: Private Cloud and Hybrid Deployments
The on-premises vs. cloud framing misses a third option that's increasingly common for enterprises with complex requirements.

Private cloud gives you dedicated infrastructure (not shared with other tenants) hosted in a cloud provider's data center but provisioned exclusively for your organization. You get geographic flexibility and managed infrastructure without the multi-tenant exposure. For organizations that need data residency in specific regions but don't want to run their own hardware, this is often the right fit.

Hybrid deployment combines on-premises and cloud infrastructure for different parts of the system. A common pattern: sensitive message content and user data stored on-premises, while cloud infrastructure handles connection management and delivery. This lets organizations meet strict data requirements without giving up the operational advantages of cloud for the parts that don't require the same level of control.

Neither option is a compromise; they're architectures designed for organizations whose requirements are more complex than a single deployment model can address.

How to Actually Make the Decision

Skip the philosophical debate and answer these directly:

**Do any of your requirements prohibit external infrastructure? **Air-gap requirements, certain government security clearances, and specific regulatory mandates can make this a binary answer. If yes, on-premises is the path.

Who needs to control the encryption keys? If the answer is "us, exclusively," that rules out most standard cloud deployments.

What's your compliance audit going to ask for? Talk to your legal and compliance team before your engineering team. The requirements they're working against will determine whether a vendor's certifications are sufficient or whether you need something more.

What's your actual engineering capacity? On-premises is not set-and-forget. It requires ongoing maintenance, patch management, capacity planning, and incident response. Be honest about whether you have that capacity before committing to it.

**What does the five-year cost look like? **Calculate cloud costs at your projected scale over five years, then compare against on-premises hardware, networking, and headcount. The answer sometimes surprises people in both directions.

What happens when it breaks at 3am? On-premises means your team responds. Cloud means the vendor's team responds (within their SLA). Your preference here is legitimate data.

Where CometChat Fits In

CometChat supports all three deployment models: cloud, on-premises, and private cloud/hybrid, because organizations with different requirements need actual options, not a recommendation that whatever we run happens to be best.

For cloud deployments, CometChat's managed infrastructure handles the real-time messaging layer, geographic distribution, and uptime. Your team builds the product; the infrastructure runs.

For on-premises deployments, CometChat provides the software to run entirely within your data centers. Your team controls the encryption keys, message data stays within your infrastructure, and the deployment can be configured to meet air-gap requirements. The SDKs and APIs are consistent across deployment models, so your development team works against the same interface regardless of where the backend runs.

For organizations that need something in between, private cloud and hybrid configurations are available on enterprise plans: dedicated infrastructure in specific regions, or split architectures where different components live in different environments based on their sensitivity.

Compliance certifications (HIPAA, SOC 2 Type II, ISO 27001, GDPR) cover CometChat's managed cloud infrastructure. For on-premises deployments, your environment will require its own audit, though CometChat's architecture and documentation are designed to support that process.

If you know which deployment model you need, the documentation is a reasonable starting point. If you're still working through the decision, we're worth talking to; this is a choice organizations get wrong more often than they should, and getting it right before you've built on top of the wrong architecture is considerably easier than after.

React UI Kit v7

CometChat — Wed, 24 Jun 2026 06:53:08 +0000

Chat UI looks like a small part of an app right up until you start shaping it to fit. You need to recompose a component, swap one region for your own, match your brand down to the fonts, and keep all of it working when you move to server-side rendering. Each of those is reasonable on its own. Together they are where chat UI work actually lives.

CometChat React UI Kit v7 is built for that part of the job.

Why does this matter to React developers?

Customizing chat UI is where the real work shows up: a custom empty state, a bubble that renders your own message type, a layout that fits your app rather than a default. v7 is built so those are configuration, not custom code you maintain forever.

Components compose from named sub-parts, so you can swap one region without forking the whole thing. Message rendering runs through plugins, so adding a custom message type is a defined interface rather than a patch. Theming is CSS custom properties, so your brand is a set of variables instead of a stylesheet you maintain against someone else's internals.

And each component handles its own data fetching, real-time listeners, and state. You drop it into your layout and move on.

Key features and capabilities

Four frameworks, one package. The same @cometchat/chat-uikit-react package covers React.js (Vite or Create React App), Next.js (App Router with client-side rendering), React Router (SPA, v6+), and Astro (React islands via the client:only directive). Each gets its own step-by-step integration guide.

Compound components.

Components are built from namespace sub-components (Root, View, EmptyState, and others), so you compose only the parts you need and replace a single region without rebuilding the component around it.

Plugin-based message rendering

Message display runs through the CometChatMessagePlugin interface. Twelve plugins ship by default, covering text, image, video, file, audio, polls, stickers, collaborative documents and whiteboards, group and call system messages, and deleted-message placeholders, with no setup. Add your own by passing them to the plugins prop on CometChatProvider.

Theming with CSS custom properties.

Colors, fonts, and dark mode are driven by --cometchat-* variables, with built-in light and dark themes you can override at the variable level.

19 languages built in.

Localization ships with 19 supported languages and customizable translation keys.

Optional voice and video calling

Add calling by installing @cometchat/calls-sdk-javascript. It is a peer dependency you opt into, not weight you carry by default.

SSR-safe and tree-shakable

No browser-only APIs at module scope, which is what lets it work cleanly with the Next.js App Router. The build is ESM-first with dual ESM and CJS output, so unused components drop out of your bundle.

What's interesting about the tech

The piece worth understanding is how messages actually get on screen. Every message in the UI is rendered by a plugin. Not most messages, every message. When the UI Kit needs to render one, it asks the plugin registry to find a match: the registry scans plugins in order and picks the first whose messageTypes includes the message's type and whose messageCategories includes its category. Deleted messages are special-cased to the Delete plugin. First match wins, so plugin order matters, and a message with no matching plugin simply is not displayed.

That last part sounds like a footnote and is not. It makes rendering a closed, predictable system rather than a pile of conditionals, and it means your custom plugins append after the defaults, so the built-ins keep priority for their own types unless you deliberately take one over. Supporting a new message type becomes implementing an interface, not hunting through render logic.

The SSR rule is the other quiet decision. Keeping browser APIs out of module scope is the difference between a kit that imports cleanly into a server component and one that throws at build time. It is the kind of constraint you only appreciate after it has cost you a weekend somewhere else.

Reference links

Overview and getting started:

https://www.cometchat.com/docs/ui-kit/react/v7/overview

Plugins

https://www.cometchat.com/docs/ui-kit/react/v7/plugins/overview

CometChat Campaigns

CometChat — Wed, 24 Jun 2026 06:49:08 +0000

Most teams building outbound messaging end up in the same place eventually: a notification stack spread across too many tools, a custom dashboard stitched together with glue code, and an engineering ticket required every time ops wants to send a campaign. The stack works until it doesn't, and when it breaks, nobody agrees on where to look first.

CometChat Campaigns is the omnichannel notification platform built into CometChat. It runs on the same infrastructure as CometChat Chat, shares the same user identity system, and lets product, marketing, and operations teams reach users across every channel without building or maintaining the plumbing themselves.

Why this matters to product managers and marketers

Every campaign your team wants to send should not require a conversation with engineering first. It usually does, because the tools that handle delivery are not the same tools that understand your users. Someone has to map IDs, configure the right endpoint, and make sure the right segment gets the right message at the right time. That work lands on a sprint. The campaign waits.

Campaigns changes that relationship. Marketing and ops teams can build, schedule, and send directly from the CometChat dashboard, without raising a ticket or waiting on a release cycle. Audience targeting, message templates, A/B testing, and delivery scheduling are all available without writing a line of code.

And because Campaigns runs on the same platform as CometChat Chat, the user data your product already has is the user data your campaigns run on. No exports, no imports, no sync jobs keeping two systems loosely in agreement. When a buyer goes quiet in a marketplace conversation, Campaigns can trigger a re-engagement nudge based on that signal directly. When a user is mid-conversation, push gets suppressed automatically. That kind of context-aware delivery is what most teams are trying to approximate by stitching tools together. Here it is the default behavior.

Key features and capabilities

Omnichannel delivery from a single endpoint.

In-app, push, SMS, and email are all reachable through one API call. Channel sequencing handles fallback logic automatically: in-app first (no opt-in required), then push, then SMS. Volume shifts to the cheapest effective channel without custom routing code.

No-code campaign builder.

Marketing and ops teams can design, schedule, and send campaigns from the CometChat dashboard without raising an engineering request. Message templates with variable substitution handle personalization at scale. Audience targeting lets teams segment by behavior, attributes, or custom events.

A/B testing built in

Test message variants across channels and let delivery data decide what ships. No separate testing tool, no manual result aggregation.

Cross-channel analytics in one view.

Open rates, click-through rates, A/B outcomes, and individual user notification history are all visible in the same dashboard. You can see which channel is doing the work and which is generating spend without benefit, without exporting to a separate tool.

Multi-tenant architecture, inherited from CometChat Chat.

Per-tenant notification configs, templates, and analytics with full data isolation. One instance serves multiple brands or communities without rebuilding anything for each one.

Compliance included from day one.

HIPAA, GDPR, SOC 2, and ISO 27001 support is part of the platform. Audit logs and moderation policy apply consistently across Chat and Campaigns from a single configuration.

Integration options

Four ways to connect, depending on where you are:

Unified API

One endpoint to trigger notifications across all channels. Connects to any backend workflow, billing system, or CRM without rebuilding your stack.

UI Kits

Pre-built in-app message center components for iOS, Android, Flutter, and JavaScript. Drop in and theme to match your product.

SDKs

. iOS, Android, Flutter, React Native, and JavaScript, for teams that want native control over the in-app notification experience.

Webhooks

Trigger campaigns from existing internal systems without re-platforming.

What is worth understanding about the architecture

The no-code builder is genuinely operator-first. When customization is needed, UI kits share the same theming system as CometChat Chat, so custom UX does not mean starting from scratch or abandoning the dashboard.

Channel sequencing defaults to in-app first for a specific reason: in-app requires no opt-in, which makes it the highest-reach channel by default. Push requires opt-in. SMS costs money per message. The sequencing logic exhausts the free, high-reach channel before touching paid ones, and it does this automatically. Notification fatigue has a way of becoming a product problem before it shows up in the metrics. Channel intelligence is the structural answer, not a campaign calendar review.

Pricing does not penalize growth. There is no MAU-based billing and no overage charges at peak concurrent connections. The cost structure stays predictable as volume scales.

To learn more

Notification Fatigue Is a Product Problem, Not a Marketing One

CometChat — Thu, 04 Jun 2026 07:51:39 +0000

There's a moment every growth team eventually hits: open rates drop, unsubscribes climb, and someone in the room suggests the copy needs work. So the copy gets rewritten. The subject line gets A/B tested. The send time shifts from 10am to 10:14am because someone read a study.

And nothing really changes.

That's because notification fatigue isn't a messaging problem. It's a sequencing problem, a channel problem, and at its root - a product architecture problem. By the time your metrics move, the damage is already done.

The Damage Happens Before You Can See It

Here's what notification fatigue actually looks like operationally: a user gets a push. They don't open it. Three hours later, they get an SMS for the same thing. Then a WhatsApp message. Then another push.

None of this registers as an error in your analytics. Delivery was successful. The campaign ‘ran.’ But somewhere between the second and third message, the user decided your notifications aren't worth reading anymore. They turned them off or just started ignoring them, which is functionally the same thing but harder to measure.

The open rate dip you'll notice next week is a lagging indicator of a decision your product forced them to make days ago. You can't fix that with better copy. You needed to never send those three messages in the first place.

Volume Is the Wrong Variable to Optimize

Most messaging systems are built around volume. More touchpoints, more conversions that's the assumption. And it works, briefly, right until users start treating your notifications the way most people treat car alarms: background noise that implies nothing urgent.

The teams that get this right aren't sending fewer messages because they're conservative. They're sending the right message on the right channel because they've built sequencing logic that accounts for what the user already did.

If a user opened your in-app message, they don't need the SMS. If the push converted, the WhatsApp follow-up is friction, not reinforcement. Sequencing isn't about timing delays between blasts, it's about making each next message contingent on whether the last one worked.

This is a technical decision, not a creative one. And it belongs in your messaging infrastructure, not in a campaign brief.

Channel Intelligence Matters More Than Channel Coverage

There's a version of ‘omnichannel’ that means: we send everything, everywhere, always. It's expensive, it's annoying, and it produces the kind of engagement numbers that look fine until your retention metrics tell a different story.

The more useful version of omnichannel is channel sequencing with fallback logic: start on your highest-signal, lowest-cost channel (in-app notifications, if the user is active), and only escalate to SMS or WhatsApp if the previous touchpoint went unanswered. You reserve the expensive, interruptive channels for the moments that actually need them not as a default.

This does two things. It keeps your cost-per-message reasonable at scale. And it keeps users from associating your brand with interruption.

The second effect is harder to model but more consequential. A user who trusts that your SMS means something important will open it. A user who's been trained by three months of redundant blasts will see your sender name and feel mild irritation. That's not a recoverable state.

Why This Is a Product Problem

Marketing teams are usually the ones blamed for notification fatigue. But marketing teams are operating within the constraints of whatever messaging infrastructure the product team built. If the infrastructure doesn't support behavior-triggered sequencing - if it can't check whether a message was viewed before firing the next one, then even a thoughtful messaging strategy gets flattened into: send everything, measure what we can, iterate.

The fix isn't a better campaign strategy. It's messaging infrastructure that treats user behavior as a first-class input: one that can sequence across channels, check delivery and view status before escalating, and apply rules that match the actual logic of your engagement goals.

When that infrastructure exists, ‘notification fatigue’ stops being a recurring agenda item. It stops being something you manage after the fact. Your system just doesn't do the thing that causes it.

What CometChat Campaigns Gets Right

CometChat Campaigns is built around this exact problem. You define your audience, your channels, and your sequence logic and the platform handles escalation based on what actually happened: was it delivered, was it viewed, was it clicked?

You start in-app. If the user doesn't engage, you fall back to push. If still nothing, you can escalate to SMS or WhatsApp. Each step is conditional, not automatic. The user who already converted never sees the follow-up. The user who missed it does.

It's a small architectural shift from broadcast to conditional delivery and it's the difference between a notification system that earns attention and one that trains users to ignore it.

Notification fatigue isn't inevitable. It's what happens when volume substitutes for intelligence. The teams who solve it aren't better marketers. They're building on infrastructure that treats the next message as a function of what the last one accomplished and that's a product decision worth making early.

Launching CometChat Campaigns on Product Hunt today!

CometChat — Wed, 03 Jun 2026 10:00:53 +0000

One dashboard to build, customize, and send omnichannel notifications to your users. Marketing offers, feature announcements, support alerts, operational broadcasts. Design your templates, pick your audience, and deliver across in-app, push, SMS, and email. A/B test variants, schedule sends, and track performance end to end. Marketers, ops, support, developers. Everyone on your team can run campaigns from day one.

https://www.producthunt.com/products/cometchat-campaigns?launch=cometchat-campaigns

It would be great if you could take a moment to go and upvote!!

Launching Chat Skills for AI Agents on Product Hunt today

CometChat — Wed, 27 May 2026 08:13:56 +0000

This helps you add fully functional chat to your React app using AI agent skills. Drop in a skill file and your agent handles the full integration: installation, environment setup, SSR-safe rendering, and the correct init and login flow. One file per framework. Works seamlessly with Cursor, Kiro, VS Code Copilot, Claude, and Codex. Go from zero to a working chat in minutes, built on CometChat's proven foundation and ready for real projects from day one.

https://www.producthunt.com/products/cometchat-skills?launch=calling-skills-for-ai-agents

It'll be great if you could check it out and upvote!

Launching Voice and Video Calling by CometChat on Product Hunt today!

CometChat — Wed, 20 May 2026 07:51:01 +0000

CometChat Calling gives you HD voice and video, built to ship fast and scale high. Recording, screen sharing, call logs, raise hand, and picture-in-picture out of the box. Integrate via SDKs, or drop a CometChat Skills file into your coding agent and let it handle the setup. Handles high-concurrency calls, with HIPAA, GDPR, SOC 2, and ISO 27001 compliance built in.

producthunt.com

Production Ready UI Kits by CometChat launching on Product Hunt today

CometChat — Wed, 13 May 2026 07:18:55 +0000

Build production-ready chat experiences faster with CometChat’s updated open-source UI Kits across Angular, Jetpack Compose, React, React Native, Vue, Flutter, Android, and iOS. Featuring redesigned Angular and Jetpack Compose UI Kits with modular components, native modern UI patterns, built-in messaging and calling, real-time updates, search, unread counts, and everything needed to launch polished chat experiences faster.

https://www.producthunt.com/products/production-ready-ui-kits-by-cometchat?launch=production-ready-ui-kits-by-cometchat

It'll be great if you could take a minute to go upvote us on Product Hunt:)

CometChat Unreal Engine SDK

CometChat — Fri, 08 May 2026 08:17:23 +0000

We're launching the CometChat Unreal Engine SDK, a native UE5 plugin that integrates real-time chat directly into multiplayer games and interactive experiences.

The SDK ships with full support for both Blueprint and C++, so you can wire up a working chat system whether you're prototyping visually or building a production title in code.

Supported platforms include:

Windows (Win64)
macOS
iOS
Android

Minimum requirements:

Unreal Engine 5.5.4 or 5.7.2
C++ development tools for your platform
A CometChat account with an App ID, Region, and Auth Key.

Why does this matter to me as a game developer?

Adding chat to a game is not as simple as dropping in a library.

Every game engine has different constraints around threading, UI rendering, and event systems. A real-time chat SDK needs to play nicely with all of them. For Unreal specifically, that means running all callbacks on the Game Thread so you can update UI safely, exposing async operations as Blueprint-friendly nodes with clear success and failure outputs, and fitting into the existing Subsystem architecture so the SDK lifecycle is automatically managed alongside your game instance.

Most solutions in this space hand you a REST API and leave the Unreal integration to you. The CometChat Unreal SDK is purpose-built for UE5, with a plugin architecture that handles all of that automatically.

Key features and capabilities

Blueprint and C++ support
The plugin exposes every SDK operation through both Blueprint async nodes and a native C++ API. You get the same capabilities either way.

In Blueprints, every operation has On Success and On Failure exec pins, making error handling explicit and visual. In C++, you access the same underlying subsystem directly.

UCometChatSubsystem
The SDK is built around a UGameInstanceSubsystem, which means it's created automatically when your game starts and lives for the full duration of the game instance. You don't manage its lifecycle manually. Access it from any Actor or Widget with a standard Get Subsystem call.

Latent async nodes
All network operations, including login, sending messages, fetching history, and group management, are exposed as latent async Blueprint actions. They don't block the game thread and surface results through clean success and failure output pins.

Real-time delegates
Incoming messages, presence updates, typing indicators, delivery receipts, and connection state changes all arrive via multicast delegates on the Subsystem. Every delegate fires on the Game Thread, so you can update your UI directly in the callback without any additional thread-switching.

What's included out of the box

Authentication Login with Auth Key, Login with Auth Token, Logout, session check.
Messaging Send and receive text messages (1:1 and group), message history with pagination.
Users Fetch user profiles, real-time presence.
Groups Create, join, leave groups, group messaging.
Real-time events Message received, presence changed, typing indicators, read receipts, connection state.

How does installation work?

The plugin ships with two installation paths.

Option 1: Precompiled binaries (no build required)

Copy the CometChatSdk/ plugin folder from the SDK repository into your project's Plugins/CometChat/ directory, download the precompiled binaries for your engine version, extract them into the same directory, enable the plugin in your .uproject file, and open your project in Unreal Editor. No compilation step needed.

Option 2: Build from source

Copy the plugin source into your project's Plugins/ directory, regenerate project files, and build.

Once installed, add CometChat as a module dependency in your game's .Build.cs file, then call Configure on the CometChatSubsystem with your App ID and Region before making any other SDK calls.

What's interesting about the tech behind this?

The plugin is structured into three distinct layers, and understanding them helps you use it effectively.

UCometChatSubsystem is the single owner of the SDK lifecycle. Because it's a UGameInstanceSubsystem, Unreal manages its creation and destruction automatically. You never instantiate it directly.

Latent async nodes are the Blueprint-facing surface of every SDK operation. They follow the standard Unreal async action pattern, which means they work correctly with Blueprint's execution graph and never block frame execution.

Real-time delegates are how the SDK pushes events to your game. Rather than polling or requiring you to set up listeners manually, you bind to the Subsystem's delegates before login and events arrive automatically. Because all delegates fire on the Game Thread, you can drive UI updates directly from them.

There's also a ready-to-use CometChatGroupChatBox widget included in the plugin if you want a working group chat UI without building one from scratch.

Reference links

SDK repository: https://github.com/cometchat/chat-sdk-unreal/tree/v1

Documentation overview: https://www.cometchat.com/docs/sdk/unreal/overview

Setup guide: https://www.cometchat.com/docs/sdk/unreal/setup

CometChat Skills

CometChat — Mon, 04 May 2026 08:09:11 +0000

CometChat Skills is a set of five agent skill files that guide any AI coding agent through a correct CometChat React UI Kit v6 integration, from install to a working chat UI, in under 15 minutes.

There is one skill per framework: React.js, Next.js, React Router, and Astro, plus a shared core. The skills work with Claude Code, Cursor, Kiro, VS Code Copilot, and Codex. Drop a .md file into your agent's context directory, and the agent knows exactly what to do.

This product focuses on eliminating the framework-specific debugging that slows down React integrations. Every React framework has different SSR constraints, env var conventions, and module loading patterns. CometChat Skills handles all of that automatically, so your AI coding agent generates the right integration code for your specific project.

What are we launching?

We're launching CometChat Skills, a set of production-ready agent skill files for integrating CometChat React UI Kit v6 into React applications.

The skills work with any AI coding agent that reads markdown context, including:

Claude Code
Cursor
Kiro
VS Code Copilot
Codex

Supported frameworks include:

React.js / Vite
Next.js (App Router + Pages Router)
React Router v6 and v7
Astro

Install the skills with one command, then open your project in your AI coding agent to run it. The agent detects your framework, shows three chat experience options, collects or infers your CometChat credentials, and scaffolds the integration with the correct SSR pattern, file layout, and TypeScript types.

Why does this matter to me as a developer?

Integrating CometChat into a React project is not the same across every framework.

Every React framework has different:

SSR constraints
Environment variable conventions
Module loading patterns

Most tools like Sendbird, Stream and PubNub all have static quickstart docs. None offer an agent-agnostic skill that detects existing project state, adapts to the detected framework, and generates idiomatic integration code inline in your existing project, across every major AI coding agent.

Key features and capabilities in CometChat Skills

Framework detection
The skill detects your project's router type, bundler, and framework version before generating any code.

This means the agent:

Chooses the right SSR prevention pattern for your framework.
Applies the correct environment variable convention.
Generates code that matches your existing project structure.
Generates code that matches your existing project structure.

Credential inference

Before prompting you for your CometChat credentials, the skill looks for them in your existing files or any existing CometChat UI Kit integration calls in your project.

Three chat experiences, ready to scaffold

Once the agent knows your framework and credentials, you choose the chat experience you want to build.

Pass an experience directly when you run the command:

Conversation list and message view. This lists all conversations and messages in a single view with the option to open specific chats when clicking on them. Best for apps where users switch between multiple conversations.
One-to-one chat.Private conversation windows connecting individual users. Best for customer support or matched-pair chat.
Tab-based chat. Tabs to indicate chats, calls, users and groups. Each tab shows the matching CometChat list; clicking a conversation opens messages on the right. Best for full-featured messenger-style apps.

Additionally, CometChat skills will ensure:

Minimal changes to your existing project, and
A verification checklist after integration

What's interesting about the tech behind this?

CometChat Skills is built around a modular skill file architecture.

There is one entry-point dispatcher skill and four framework-specific skills underneath it:

Because the skills ship as markdown files, they work with any AI coding agent that reads markdown context. Drop a .md file into your agent's context directory. That's it.

This makes the skills genuinely agent-agnostic. Claude Code, Cursor, Kiro, VS Code Copilot, and Codex all read the same files and follow the same instructions.

Reference links

GitHub repository: https://github.com/cometchat/cometchat-skills

Documentation for React: https://www.cometchat.com/docs/ui-kit/react/react-js-integration

Documentation for React.js: https://www.cometchat.com/docs/ui-kit/react/overview

Launching Compact Message Composer by CometChat on Product Hunt today!

CometChat — Wed, 29 Apr 2026 07:44:23 +0000

CometChat's Compact Message Composer, part of the CometChat UI Kits, brings rich text formatting to your chat app - bold, italic, strikethrough, underline, links, bullet points, blockquotes and more. Enabled with a single prop. Comes with a floating toolbar, keyboard shortcuts, and full control over how messages are sent. Drop it into any framework and ship a richer chat experience in minutes.

It'll be great if you could spare a minute to upvote on PH: https://www.producthunt.com/products/cometchat?launch=compact-message-composer-by-cometchat