Overview

The Stream Chat Android SDK enables you to easily build any type of chat or messaging experience for Android, either in Kotlin or Java.

Start here

If you're building with Android Views instead of Compose, start with the Android Views In-App Messaging Tutorial.

Build with Stream CLI and Agent Skills

The Stream CLI and Agent Skills provide AI coding agents, such as Claude Code, Cursor, and Codex, with the tools and knowledge necessary to build apps with Stream.

Install the CLI and add the skills to your project:

curl -fsSL https://getstream.io/cli.sh | bash
getstream skills stream-android

Once installed, invoke it from your agent:

/stream Add Stream Chat to my Android app.

The /stream skill acts as a router, reading your request and dispatching it to the specialist skill. You can also invoke the /stream-android skill directly.

Stream Agent Skills can also be installed from skills.sh.

What's new in V7

Version 7 is a major update to the Stream Chat Android SDK, with a focus on a modern look, improved developer experience, and better cross-platform consistency.

Modern redesign

The Compose SDK ships with a completely refreshed default UI. The channel list, message list, composer, and reactions have all been redesigned with a cleaner, more polished look that aligns with modern Android design patterns.

New design system

V7 introduces a unified design system shared across all Stream SDK platforms (iOS, Android, React, React Native, and Flutter). The theming system has been rebuilt around StreamDesign, with StreamDesign.Colors and StreamDesign.Typography replacing the previous StreamColors, StreamTypography, StreamDimens, and StreamShapes classes. Design tokens for colors, typography, spacing and icons are now defined consistently, making it easier to achieve a coherent look when shipping on multiple platforms.

Name alignments across platforms

Many APIs and component names have been aligned with their iOS, React, React Native, and Flutter counterparts. This reduces friction when working across platforms and makes the documentation easier to follow regardless of which SDK you started with.

ChatComponentFactory

UI customization has been consolidated into ChatComponentFactory, a single interface that replaces the multiple bespoke customization mechanisms that were previously scattered across different components. Most of the Compose UI can now be customized by overriding methods on ChatComponentFactory. Override only what you need; default implementations are provided for everything else.

Consolidated modules

Four modules have been merged or removed to simplify the dependency graph:

• stream-chat-android-offline and stream-chat-android-state are now part of stream-chat-android-client.
• stream-chat-android-ui-utils is merged into stream-chat-android-ui-common.
• stream-chat-android-ai-assistant is removed in favor of the standalone stream-chat-android-ai repository.

Simplified client setup

The plugin system has been replaced with direct configuration on ChatClient.Builder. A single ChatClientConfig class replaces StreamOfflinePluginFactory and StreamStatePluginFactory, with sensible defaults out of the box.

Architecture

The SDK consists of three major components:

• Views/XML UI components. Provides a set of reusable and customizable UI components based on Android Views.
• Compose UI components. Provides a set of reusable and customizable Jetpack Compose UI components.
• Client. Provides the main chat functionality including built-in state management and offline support. You can use it directly if you intend to build your own UI layer for the chat.

flowchart LR
  app[Your app] --> views[Views UI components]
  app --> compose[Compose UI components]
  app -. custom UI .-> client
  views --> client[Client]
  compose --> client
  client <--> api[Stream API]

For most apps we recommend the Views/XML UI components or the Compose UI components. If your UI doesn't significantly differ from the industry standard, you should be able to customize the built-in components to match your requirements.

UI SDKs

Built on top of the Stream Chat low-level client, the Stream Chat Android UI components enable you to easily build any type of chat or messaging experience for Android.

We have UI component libraries available for both Android Views and Jetpack Compose. Each of these libraries provides an extensive collection of efficient and customizable UI components which enable you to quickly get started with little to no setup required. The libraries support:

• Rich-media messages
• Channel and message lists
• Message Reactions
• Message threads and quoted replies
• Text input commands (ex: Giphy and @mentions)
• Image and file uploads
• Video playback
• Indicators for read state and typing
• Push notifications
• Offline storage
• Voice messages
• and more.

If needed, you can create your own UI components by listening to the state we expose and using our components as building blocks. You can learn more about how state is exposed here and in the low-level client docs.

Choosing the right UI SDK

Views UI components

The UI Components library includes pre-built Android Views to easily load and display data from the Stream Chat API. These include a Channel List and a Message List, a Message Composer View, and more. See the Getting Started page for more details.

This library is built on top of the client library, and offers the quickest integration of Stream Chat into an Android application. It also offers a variety of theming options to make it fit your app's needs.

You can see the UI Components in action by checking out the UI Components Sample App, available in the GitHub repository.

Compose UI components

The Compose UI Components library is a chat UI implementation built from scratch with Jetpack Compose. It contains modular Composable functions for building channel lists, messaging screens, and more. See the Getting Started page for more details.

This is also built on top of the client library, and offers easy integration of Stream Chat into a Compose-based Android application. It's also highly modular and customizable.

Check out the Compose implementation in action by trying the open-source Compose UI Components Sample App.

The right SDK for you

If your use case requires a very high level of customization, runtime theming changes, replacing whole parts of the default UI or stateless components that don't rely on our ViewModels, the Compose SDK is the way to go. It offers deep customization through several layers: the theme, modifiers for components, bound and stateless component overloads, smaller reusable components and slot APIs.

If, instead, you're looking for a simpler, less customizable SDK which currently offers slightly better performance in some scenarios or your project is limited by technology, then the UI Components SDK is a great option. It still offers a fair amount of customization through the theme and its attributes and some programmatic ways to customize the UI.

Whichever SDK you choose, we guarantee you'll be happy and we'll provide amazing support with your integration, through detailed documentation, guides and direct support.

Upgrade and versioning strategy

The StreamChat Android SDK adheres to the semantic versioning rules.

• Bug fixes and behavior improvements cause patch version bump.
• New features are shipped with an increased minor version.
• Incompatible changes in the API will cause a major version increase.

Occasionally, the SDK can include visual changes (whitespace, color changes, sizing, etc) in minor versions, as we are continuously improving the default look of our UI components. Bumping the major version for such changes would not be practical.

You can see all the SDK changes in the releases page.

How should I specify my dependency version?

You should use a fixed version in order to avoid any conflicts or unpredictable behavior.

For example:

implementation "io.getstream:stream-chat-android-compose:$stream_version"

Check the Releases page for the latest version number.

What's next