CometChat React Native UI Kit, pre-built chat screens you can drop into an app

A UI kit for chat, not a chat backend you host

The CometChat React Native UI Kit is described as a pre-built user interface kit that developers use to integrate a chat experience into an existing or a new mobile app. The scope is stated in the repository description: voice and video calling and text chat for React Native. What you get is the front end, the conversation screens, the message list, the calling UI, and the components needed to assemble them. What you do not get is a backend you run yourself.

That division is the single most important fact for an engineer evaluating it. The kit is designed to sit on top of CometChat's hosted service, and the setup flow starts in the CometChat dashboard where you create an app and are handed an Auth Key and an App ID. The audience is therefore React Native teams that want messaging to look finished this quarter rather than teams that want to own message storage, delivery guarantees and moderation themselves. The project description calls the result reliable and fully-featured, but the words that carry the most weight are pre-built and kit: this is a decision about who does the work, not about how much work is left afterwards.

packages/ and examples/ show how the kit is meant to be consumed

The repository is laid out as .gitignore, README.md, examples/, packages/, screenshots/. The packages/ directory is where the kit itself lives, and the examples/ directory holds four separate applications: SampleApp, SampleAppAI, SampleAppExpo and SampleAppWithPushNotifications. Each of those has its own README linked from the main file.

Those four examples are the clearest evidence of how the kit is meant to be used, and they cover the four decisions a mobile team actually has to make. A plain React Native app, an app with an AI feature, an app built with Expo, and an app that handles push notifications. Reading them side by side shows the same UI Kit components being wired into four different native setups, which is useful because the integration steps for each of those paths differ substantially in tooling even when the chat code looks similar.

The structure also tells you what this repository is not. There is no server directory, no database layer and no deployment configuration, so there is nothing here to run as a backend. If you were hoping for a self-hosted chat stack, the samples would be a misleading place to start. They are samples of a client.

Node 18, React Native 0.77 and native toolchains set the floor

The prerequisites are specific enough to check in a minute. Node.js 18 or higher. React Native version 0.77 or later, and the documentation says up to the latest version. On iOS you need XCode, Pod (CocoaPods) for iOS, and an iOS device or emulator running iOS 12.0 or above. On Android you need Android Studio and a device or emulator on Android version 5.0 or above.

Two things are worth pointing out. First, the React Native floor of 0.77 is recent, so an app on an older React Native release cannot simply add the kit and expect it to work, and the native toolchain requirements mean this is not a JavaScript-only dependency: CocoaPods and Android Studio have to be in place before any integration begins. Second, the iOS and Android minimum versions are device requirements, not library requirements, and they are low enough that most fleets qualify.

The practical consequence for an evaluation is that the kit's compatibility question is a question about your app, not about the kit. Check your React Native version first, because that is the constraint most likely to rule the kit out, and it is cheaper to discover that before you create a dashboard app than after.

Setup starts in the dashboard and ends with an Auth Key and App ID

The documented integration sequence is short and it is entirely service-side at the start. You register on the CometChat dashboard and sign up for an account. After registering you log in and create a new app, and CometChat generates an Auth Key and an App ID for you. The instructions are explicit that these credentials must be kept secure because you will need them later. You are then pointed at the Key Concepts documentation for the basic components of CometChat, and finally at the Integration Steps section of the documentation for integrating the UI Kit into your iOS app.

Note what is not in that flow. There is no npm install of the kit, no copy-paste of a component tree, and no configuration file in this repository that you would edit. The README does not document the native installation steps for the kit itself, so the Integration Steps page in the CometChat documentation is where the actual installation commands live, and the repository assumes you will follow them there. The credentials generated in the dashboard are the real configuration surface of this integration, and the documentation asks you to keep them secure because you will need them later.

For teams that prefer to have the integration written for them, the project also offers Agent Skills, which are installed with a single command in your project root and require Node.js 18 or higher:

npx @cometchat/skills add

The skills are installed for Claude Code by default, and you pass an ide flag to target a different agent, for example --ide cursor. You then open the project in your agent and prompt it with "add chat to my app", or run the /cometchat command. The documentation says the agent detects your project setup, walks through a short plan for approval and then writes the integration code into your existing app, following the official guides, and that the skills work with Claude Code, Cursor, GitHub Copilot, Codex, Windsurf and other agents.

Where the repository documentation stops

The README is a starting point rather than a manual, and it is worth being precise about what it does not contain. There is no component reference, no prop table, no theming guide, no list of which CometChat features the kit exposes, and no migration notes for moving from an earlier major version. The documentation is delegated to the website, with a link to the React Native UI Kit overview, a support ticket system, and live support through the dashboard.

The default branch name tells its own story. It is v5, and the integration link in the setup section points at a path for version 5.0. The published releases are v5.5.2 on 2026-10-16, v5.5.1 on 2026-09-25 and v5.5.0 on 2026-09-08, and the last push was on 2026-10-16. That cadence is close enough to the present to matter when you plan an integration, since a major-version jump will not be a drop-in change.

The licence is the other gap. The repository does not declare a licence, so there is no permission statement you can point at for shipping a commercial application built on these components. If your app is closed source and goes to an app store, that question needs an answer from the vendor before release, not after.

Building chat screens yourself versus adopting the kit

The honest alternative to this kit is writing the conversation, message list, typing indicator, attachment handling and calling screens yourself in React Native. The difference in approach is not about line count, it is about where the responsibilities sit.

Hand-building the UI means you own the protocol layer, the local cache, the send and retry logic, the call signalling, the push handling and the media upload path, and you can point all of it at whatever backend your organisation already runs. The cost is that none of that is free, and the calling screens in particular are the part most teams underestimate.

Using the kit moves that work behind a service boundary. You get pre-built components that match the CometChat product, and the setup is a dashboard app plus credentials rather than a protocol implementation. The price is that your chat data, history and calling run through a hosted service, the kit is tied to CometChat's own data model, and the components only cover what that service exposes. A third path exists, and it is the one the samples show: keep your own backend and use the kit only if it can talk to it, which the README does not document. For teams that already have a messaging backend, that unanswered question is the one to resolve first, since it decides whether this is a UI dependency or a platform decision.

Editorial conclusion

Adopt the CometChat React Native UI Kit if you are shipping a React Native app that needs messaging, voice and video calling in the near term and are willing to run your chat backend through CometChat's service, and skip it if chat is a secondary feature or if your data must live on infrastructure you control. Before you start, confirm your Node.js and React Native versions clear the stated floors of Node 18 and React Native 0.77, and check the licence situation for your distribution model, because the repository does not declare one.

Frequently asked questions

Official sources

1. cometchat/cometchat-uikit-react-native on GitHub
2. Issues
3. Project website
4. README
5. Releases