# dappros/ethora: a submodule monorepo for chat, AI bots and messaging SDKs

> Ethora is a monorepo of git submodules that points to chat SDKs for React.js, React Native, Android, iOS and WordPress. The README documents a free cloud server and a CLI setup tool, but leaves self-hosting and rollback details thin.

**dappros/ethora** — SDK monorepo for Ethora chat / messaging platform. (1) Pick an SDK for your frontend stack. (2) Integrate manually or using ethora-setup. (3) Optionally configure app settings, deploy AI agents etc. Server: ethora.com cloud [free]. Dedicated server + SLA option for enterprise customers.

- Repository: https://github.com/dappros/ethora
- Website: https://ethora.com/
- Stars: 548 · Forks: 112
- Language: JavaScript
- License: Apache-2.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/dappros-ethora

## What Ethora solves and who it is aimed at

Ethora is a chat and messaging SDK platform. The README describes it as a way to add real-time messaging, AI bots and backend services to an app, and the repository itself is a monorepo whose job is discovery: each SDK, tool and sample app lives in its own repository and is linked here as a git submodule. That structure tells you who it is for. If you are a frontend or mobile developer who needs a working chat surface rather than a protocol stack, the pitch is a prebuilt UI plus a hosted backend you do not run yourself. The feature matrix lists prebuilt chat UI as present across React.js, React Native, Android, iOS and WordPress, and single-room embedded widget mode as present on all five. The other audience is the low-code one: the WordPress plugin is described as a no-code chat widget, and the app-reactjs submodule is described as an App Builder frontend. Teams that want AI bots in the same product are served by separate submodules: bots for the XMPP, LLM and automation framework, rag-demos for RAG pipeline examples, and mcp-cli for IDE and agent integration. What Ethora is not, based on the README, is a protocol tutorial or a self-contained server distribution. The messaging gateway is XMPP over WebSocket at wss://xmpp.chat.ethora.com:5443/ws, and the REST API lives at api.chat.ethora.com, so the default path assumes Ethora's cloud is reachable.

## How the submodule monorepo and the cloud fit together

The data flow is conventional for a hosted chat product, and the README is explicit about the pieces. Your app embeds one of the SDKs. That SDK talks to the REST API at api.chat.ethora.com for the request and response work, and to the XMPP WebSocket endpoint for real-time messaging. The SDK does not ship a server; the README lists ethora.com cloud as the free server option and a dedicated server with an SLA for enterprise customers, without describing how that dedicated server is provisioned. The monorepo layer is deliberately thin. There is no shared runtime here, only pointers. A GitHub workflow at .github/workflows/bump-submodules.yml runs every six hours on weekdays and on manual dispatch, updates each submodule to the latest commit on its remote default branch, and commits the pointer bumps directly into main. That means cloning the monorepo with --recurse-submodules gives you whatever commit each submodule was pinned to at the last bump, not a tested combination. The README's feature matrix is dated: it says last reviewed 2026-04-21 (v26.04), and it notes that a monthly AI-reviewed update is proposed via PR. Coverage figures are computed as present plus partial times 0.5 over 44 features: React.js 77%, Android 76%, React Native 68%, iOS 68%, WordPress 14%. Those numbers are the project's own accounting, and they are the clearest signal that the five SDKs are not interchangeable.

## Installing Ethora and getting a first chat working

The README gives two entry points. Clone the monorepo with submodules, or skip straight to the SDK you need. The clone command is documented verbatim:

```bash
git clone --recurse-submodules https://github.com/dappros/ethora.git
cd ethora
```

If you already cloned without that flag, the README gives the repair command:

```bash
git submodule update --init --recursive
```

After that, the recommended path is the setup CLI. The README says it creates an account, sets up an app and generates config files for your target SDK, and that you can also point it at a self-hosted server:

```bash
npx @ethora/setup
```

For a web app, the quickest documented path is to enter the React.js submodule and install its dependencies:

```bash
cd sdk-reactjs
npm install
```

The README then defers: see sdk-reactjs/README.md for embedding instructions. That deferral matters. The monorepo README does not show a component import, a provider wrapper, or the shape of the generated config, so the actual first render happens in the submodule's own documentation. The same pattern repeats for React Native (cd sdk-reactnative, npm install), Android (see sdk-android/README.md for Gradle setup) and iOS (see sdk-swift/README.md for Swift Package Manager setup). If you want to see the component running before you write any code, the README points at playground.chat.ethora.com, described as a live @ethora/chat-component playground with code export and HTTP testing. Signing up at app.chat.ethora.com is where the README says you create apps and get API credentials.

## Where Ethora is the wrong tool

The most concrete limitation is documentation depth at the monorepo level. Every quick path ends in a pointer to another repository, so the monorepo README cannot be your only reference. The feature matrix shows sharper edges. OAuth and social login is marked present only on React.js, partial on React Native, roadmap on Android, partial on iOS and partial on WordPress. Push notifications are partial on React Native. Reactions and delivery status indicators are absent on React Native. In-app notifications are absent there and partial on Android and iOS. Dark mode is present only on Android. If your product needs consistent behaviour across web and mobile, the matrix says you will be building around gaps rather than inheriting parity. WordPress is the weakest case at 14% coverage, with most capabilities marked absent and text messaging, 1:1 messaging and OAuth marked partial; the plugin is positioned as a no-code widget, so treat it as an embed rather than a platform. Two more things the README does not answer. It does not document rollback, so if a submodule bump breaks your build, you are reverting git pointers yourself. And it does not explain how the dedicated server and SLA option is delivered, so an enterprise buyer cannot size that work from this repository alone. Self-hosted server support is listed as present across all five SDKs, and the setup CLI mentions connecting to a self-hosted server, but the monorepo README contains no deployment guide.

## Alternatives and the difference in approach

The honest comparison starts with the protocol. Ethora's real-time layer is XMPP over WebSocket, and the repository's own topics include ejabberd and xmpp. That is a different bet from SDKs built on a proprietary socket protocol or on a hosted-only backend, because XMPP is a long-standing open standard with an existing server ecosystem. If your team already runs an XMPP or ejabberd deployment, Ethora's self-hosted server support and the XMPP WebSocket endpoint are the parts worth evaluating first, since the SDK is speaking a protocol you can host. The second alternative is the build-it-yourself route: take an open XMPP client library, write your own message list, reactions and room handling, and run your own server. That gives you full control and no vendor dependency, at the cost of the prebuilt UI, the theming layer, the unread counter and the MAM pagination that Ethora ships. The third alternative is a commercial chat API with a managed backend. Those typically offer tighter documentation and a single SDK surface, while Ethora's distinguishing features here are the Apache-2.0 licence on the SDK code, the five-platform spread including a WordPress plugin, and the bundled AI pieces (bots, rag-demos, mcp-cli) that most chat SDKs leave to you. The trade is that Ethora's breadth is spread across submodules with uneven maturity, and the README's own coverage percentages are the evidence.

## Maintenance, releases and licence cost

The repository is not archived, and the last push was on 2026-09-09, which is recent. Releases are monthly and versioned by year and month: v26.09 on 2026-09-01, v26.08 on 2026-08-01, v26.07 on 2026-07-01. The submodule bump workflow runs every six hours on weekdays and commits pointer bumps directly into main, so the monorepo's own history moves without a release tag for each bump. Upgrade cost therefore has two layers. The SDK layer follows those monthly releases. The monorepo layer follows whatever commit each submodule's default branch was on at the last bump, which is why pinning and testing a known combination is on you. The licence is Apache-2.0, which permits commercial use and modification and includes an explicit patent grant; it also requires that you keep the licence and notice files and state significant changes. That is a description of the licence terms, not legal advice, and the repository ships a LICENSE file plus CODE_OF_CONDUCT.md, CONTRIBUTING.md, SECURITY.md and QA_SCENARIOS.md at the top level. The commercial question sits outside the licence: the README lists the ethora.com cloud as free and a dedicated server with an SLA as an enterprise option, so the cost of the hosted path is a commercial arrangement, not a code licence.

## Conclusion

Adopt Ethora if you want a prebuilt chat UI and can live with the hosted ethora.com cloud, since the README's quickest paths are npm install inside sdk-reactjs or sdk-reactnative plus npx @ethora/setup. Do not adopt it if you need documented rollback, a published self-hosting guide, or parity across platforms: the feature matrix marks OAuth and push notifications as partial on React Native, and WordPress scores 14% coverage. Verify first that your target SDK's submodule README actually documents the embedding steps you need, and check the licence file for Apache-2.0 terms.

## FAQ

### What is dappros/ethora?

It is an SDK monorepo for the Ethora chat and messaging platform, described in the README as a single place to discover, clone and navigate all Ethora SDKs, tools and sample apps. Each component lives in its own repository and is linked as a git submodule.

### How do I install the Ethora chat SDK?

The README's recommended path is npx @ethora/setup, which it says creates an account, sets up an app and generates config files for your target SDK. For a web app you can instead clone with --recurse-submodules, then run npm install inside sdk-reactjs and follow that submodule's README for embedding instructions.

### Can I self-host the Ethora server?

The feature matrix lists self-hosted server support as present for React.js, React Native, Android, iOS and WordPress, and the setup CLI says you can connect to a self-hosted server. The monorepo README does not include a deployment guide, so the server-side steps are not documented here.

### Which Ethora SDK is the most complete?

By the project's own coverage figures, React.js is highest at 77% and Android is close at 76%, while React Native and iOS are both 68% and WordPress is 14%. The matrix is dated 2026-04-21 (v26.04), so treat the numbers as a snapshot.

## Sources

- [dappros/ethora on GitHub](https://github.com/dappros/ethora)
- [License: Apache-2.0](https://github.com/dappros/ethora/blob/main/LICENSE)
- [Project website](https://ethora.com/)
- [README](https://github.com/dappros/ethora/blob/main/README.md)
- [Releases](https://github.com/dappros/ethora/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/dappros-ethora