CIM (Cross-platform Instant Messaging) is a production-grade, modular instant messaging framework built with Java 17, Spring Boot 3.3, and Netty. It provides a complete IM solution including a Netty-based server (cim-server) for handling client connections and message forwarding, a routing server (cim-forward-route) for message routing, user login/offline management, and a client SDK (cim-client-sdk) for building custom clients. The system uses Zookeeper for service discovery, Redis for caching and session management, and optionally MySQL for offline message persistence. It supports group chat, private chat, offline messages, delayed messages, emoji, AI mode, and a built-in command system. The architecture is microservice-oriented with clear separation of concerns, and the codebase demonstrates strong engineering practices including consistent hashing for server selection, a custom ring buffer wheel for delayed tasks, a dynamic HTTP proxy for RPC calls, and a trie-based prefix search. The project includes comprehensive unit and integration tests, Docker support, and CI/CD pipelines.
OpenCowork is a desktop AI agent application built with Electron, React, and TypeScript. It enables users to automate tasks through natural language interactions, supporting browser automation (via Playwright), local command execution, image processing, and integration with messaging platforms like Feishu. The application features a modular architecture with separate main and renderer processes, communicating via IPC. Core functionality includes task orchestration, skill-based workflow reuse, scheduling, memory management, and MCP (Model Context Protocol) integration for extensibility. The system emphasizes local-first operation, user control, and reliable execution with fallback mechanisms for unstable automation scenarios.
Wildfire Chat IM Server is a production-grade instant messaging backend built on a heavily customized Moquette MQTT broker. It provides MQTT-based client connectivity, HTTP REST APIs for admin/robot/channel management, and supports features like private/group/chatroom/channel messaging, file/media storage (local or Qiniu), push notifications, sensitive word filtering, conference/voice-video events, social moments, and multi-domain mesh federation. The architecture is a multi-module Maven project (broker, common, sdk, distribution) using Netty for networking, Hazelcast for distributed caching, and MySQL/H2 with Flyway migrations for persistence. The codebase demonstrates solid engineering with annotation-driven routing, protobuf message serialization, and a clean SDK for server-side integration. However, it suffers from a god-class in MemoryMessagesStore, duplicated configurations, vendored Netty MQTT codec, and some security concerns (hardcoded keys, weak XOR encryption). It is actively maintained with frequent schema migrations and feature additions, but the licensing is ambiguous (multiple license files) and documentation is primarily in Chinese.
Turms is a production-grade, open-source instant messaging engine designed for 100K to 10M concurrent users. The system follows a microservices architecture with two core Java/Spring Boot servers: turms-gateway (handles client connections, authentication, session management, and push) and turms-service (implements business logic for messaging, groups, users, conversations, storage, and admin API). Both servers are built on a reactive stack (Project Reactor, Netty) for non-blocking I/O and high throughput. The platform includes a Vue.js admin UI (turms-admin), multiple client SDKs (JavaScript, Kotlin, Swift, Dart, C++), a Flutter chat demo, and a plugin system for extensibility (anti-spam, push notifications, MinIO storage, Rasa chatbot, LiveKit conferencing). Data is stored in MongoDB (sharded), Redis (session, blocklist, sequence IDs), and optionally Elasticsearch for full-text search. The codebase demonstrates strong engineering practices: custom RPC codecs for cluster communication, a property metadata framework for configuration validation, thread-safe rate limiting, and a well-defined plugin extension point system. While primarily an application, it includes an AI serving module (PaddleOCR) for content moderation, but this is a minor component. The repository is actively maintained with frequent commits, comprehensive CI/CD pipelines, and Terraform deployment scripts.
This is the OpenIM SDK Core, a cross-platform instant messaging client SDK written in Go. It provides the core messaging functionality—send/receive messages, manage conversations, groups, friends, user profiles, and file uploads—for the OpenIM ecosystem. The SDK communicates with an OpenIM server via HTTP REST and WebSocket long connections, and persists data locally using SQLite (native) or IndexedDB (WebAssembly). It features robust incremental synchronization, a callback-driven architecture for event handling, and extensive support for multiple platforms (iOS, Android, Windows, macOS, Linux, Web). The codebase demonstrates solid engineering practices with generic sync engines, caching utilities, and a comprehensive integration test suite. However, it also contains notable code duplication (dual native/WASM storage implementations), incomplete WASM stubs, some panic-based error handling, and alpha-stage dependencies, which prevent it from being exceptional. Overall, it is a functional, actively maintained SDK with reusable patterns for incremental sync and WebSocket connection management.
GoBelieveIO/im_service is an instant messaging (IM) server infrastructure implemented in Go. It provides real-time peer-to-peer messaging, group chat (including super groups for large audiences), and chat rooms. The system is designed for clustered deployment and consists of three separate processes: `im` (access server handling client TCP/WebSocket connections), `ims` (storage server using append-only file logs with in-memory indexes), and `imr` (router server coordinating message delivery between access servers). Authentication is token-based (Redis or JWT). Message storage is per-user file-based with efficient offline message synchronization via sync keys. The codebase includes a custom binary protocol over TCP/WebSocket, a Redis-backed pub/sub mechanism for group events and relationship changes, and MySQL for group and friend data. This is a production-grade system (as indicated by its star count) with comprehensive benchmark tools and Python integration tests. However, the repository appears to be in a maintenance-stale state with no recent commits and some deprecated message types.
aTox is an Android client for the Tox peer-to-peer instant messaging protocol. It provides encrypted text messaging, audio/video calls, file transfers, and group chats using the decentralized Tox network. The application follows a clean multi-module architecture: the `domain` module contains pure Kotlin business logic (Tox wrappers, feature managers, validators), the `core` module handles local persistence via Room database (contacts, messages, file transfers, friend requests), and the `atox` module implements the Android UI using Dagger dependency injection, ViewModels, LiveData, and Navigation component. Key entry points include `MainActivity` for handling intents and navigation, `ToxService` for running the Tox loop in a foreground service, and `EventListenerCallbacks` for bridging Tox events to database updates and notifications. External dependencies include the `tox4j` JNI bindings to `c-toxcore`, libsodium for encryption, and opus/libvpx for audio/video codecs. The repository is explicitly unmaintained and carries significant technical debt from its complex Bazel native build system, outdated library versions, and potential security risks inherent in the Tox protocol itself.