OpenChat

Open-source, self-hosted team collaboration platform - Your data, your control

A modern, fast, and secure team chat application built with Rust and Next.js. Self-host your team communications without compromising on features or performance.

Screenshots

Screenshots coming soon

Why OpenChat?

Privacy-First • Lightning Fast • Enterprise-Ready • 100% Open Source

OpenChat is a powerful alternative to Slack and Microsoft Teams that you can self-host on your own infrastructure. Keep complete control of your team's communications, data, and privacy while enjoying a modern chat experience.

Key Highlights

🔒 Enterprise Security - PostgreSQL Row Level Security (RLS) ensures bulletproof data isolation
⚡ Real-time Performance - WebSocket connections with Redis Pub/Sub for instant messaging
🚀 Built with Rust - Memory-safe, blazingly fast backend that scales effortlessly
🎨 Modern UI - Beautiful, responsive interface built with Next.js and Tailwind CSS
🔐 SSO Integration - Seamless single sign-on with TitaniumVault authentication
💾 Self-Hosted - Your data stays on your infrastructure - no vendor lock-in
📦 Docker Ready - Deploy anywhere with containerized architecture
🌐 Cloud Native - Built for AWS ECS with CloudFront CDN support

Recent Updates

Version 0.38.0 (API) / 0.16.0 (UI) - Enterprise Audit Logging & Enhanced Custom Emojis

New Features:

Comprehensive Audit Logging: Track all important security and administrative events
- Automatic logging of message deletions (with content preservation)
- Channel creation, deletion, and membership changes
- Permission and role assignment tracking
- Settings modifications
- User authentication events (login, logout, failed attempts)
- IP address and user agent tracking for security analysis
- Monthly table partitioning for scalable long-term storage
Audit Log Management:
- Admin-only audit log viewer with advanced filtering
- Filter by user, action type, resource type, resource ID, and date range
- Expandable row details with full metadata display
- CSV export functionality for compliance and analysis
- Pagination support for large datasets
- Retention period: 7 years (configurable for compliance)
Enhanced Custom Emojis:
- Automatic image resizing to 128x128 pixels for consistency
- Support for PNG, JPEG, GIF, and WebP formats
- High-quality Lanczos3 filtering for crisp emoji rendering
- Fallback to original if resize fails

API Endpoints:

GET /api/audit-logs - List audit logs with filters (requires org.view_audit_logs permission)
GET /api/audit-logs/export - Export audit logs to CSV
GET /api/audit-logs/actions - Get list of all unique action types
GET /api/audit-logs/resource-types - Get list of all resource types

Database:

New audit_logs table with partitioning by timestamp (monthly partitions)
Indexes on (user_id, timestamp), (resource_type, resource_id), action, and timestamp
Composite primary key (id, timestamp) for partition compatibility

Technical:

AuditLogger service with helper methods for common audit events
Automatic IP address extraction from X-Forwarded-For header (ALB/CloudFront compatible)
User agent tracking for security analysis
JSONB metadata storage for flexible event details
Permission-based access control (org.view_audit_logs)
Image processing with image crate (resize_emoji_image function)

Security & Compliance:

Full audit trail for security investigations
Compliance support (SOC 2, GDPR, HIPAA audit requirements)
Tamper-evident logging with timestamp partitioning
IP address tracking for threat detection
User agent analysis for anomaly detection

Version 0.33.0 (API) / 0.11.0 (UI) - Advanced Search & Real-time Notifications

New Features:

Advanced Message Search: Powerful full-text search with advanced filters
- Filter by user: from:@username
- Filter by channel: in:#channel-name
- Filter by date: before:2025-01-15 or after:2025-01-01
- Combine multiple filters for precise results
- Search across all channels/DMs or within specific conversations
- Cached results for improved performance (1 minute TTL)
Real-time Notifications: Get instant updates for important events
- WebSocket-based notification delivery
- Notifications for @mentions, DMs, and thread replies
- Redis caching for notification counts (5 minute TTL)
- Cross-instance notification support via Redis Pub/Sub
Notification Management:
- Unread notification count tracking
- Mark individual notifications as read
- Mark all notifications as read at once
- Automatic cache invalidation on read status changes

API Endpoints:

GET /api/search/messages?q={query} - Search messages with filters
GET /api/notifications - List user notifications
GET /api/notifications/unread-count - Get unread notification count
POST /api/notifications/{id}/read - Mark notification as read
POST /api/notifications/read-all - Mark all notifications as read

Technical:

PostgreSQL full-text search with GIN indexes
Advanced query parser for filter extraction (regex-based)
Dynamic SQL query building for filtered searches
Redis caching for search results and notification counts
WebSocket server message types: NewNotification, NotificationCountUpdated
BroadcastToUser handler for user-specific WebSocket messages

Version 0.32.0 (API) / 0.10.0 (UI) - Complete File Attachments & Storage System

New Features:

File Attachments: Upload and share files directly in messages
- Drag & drop file upload with visual feedback
- Click-to-upload button with file browser
- Multiple file attachments per message
- Real-time upload progress indicators
Rich Media Display:
- Inline image previews (automatic for images)
- Native video player with controls
- Document thumbnails with file type icons
- File size and type information
- Download buttons on all attachments
Configurable Storage: Choose between local filesystem or Amazon S3
- Admin settings page for storage configuration
- Local storage (default): Saves files to /var/openchat/uploads
- S3 storage: AWS S3 bucket support with encrypted credentials
- Support for S3-compatible services (MinIO, DigitalOcean Spaces)
Storage Security:
- File type validation (images, videos, documents, PDFs)
- File size limits (configurable, default 25MB)
- Encrypted credential storage (base64, ready for AES-256)
- Access control: Users can only download attachments they have access to

API Endpoints:

POST /api/attachments/upload - Upload file attachments
GET /api/attachments/{id}/download - Download attachment
DELETE /api/attachments/{id} - Delete attachment
GET /api/messages/{id}/attachments - List message attachments
GET /api/settings/storage - Get storage configuration (admin)
POST /api/settings/storage - Update storage configuration (admin)

UI Components:

AttachmentDisplay component with image/video/document rendering
File upload button with drag-and-drop zone
Upload progress indicators
Admin storage settings page at /admin/storage

Technical:

FileStorage trait with Local and S3 implementations
Storage factory pattern for org-based storage selection
Multipart form upload handling in Rust
AWS SDK S3 integration
Environment variables: MAX_FILE_SIZE, ALLOWED_FILE_TYPES, LOCAL_STORAGE_PATH

Version 0.25.0 (API) / 0.6.0 (UI) - Rich Text Formatting with Markdown

New Features:

Markdown Support: Full markdown formatting in messages
- Bold (**text**), italic (*text*), inline code (`code`)
- Code blocks with syntax highlighting (` ```language ````)
- Lists (ordered and unordered)
- Links, blockquotes, headings
Markdown Toolbar: Quick formatting buttons for common markdown syntax
Live Preview: Toggle between edit and preview mode to see rendered markdown
Syntax Highlighting: Beautiful code syntax highlighting for 100+ languages
XSS Protection: Sanitized HTML output prevents security vulnerabilities

UI Components:

Markdown toolbar with formatting buttons (bold, italic, code, links, lists, quotes)
Live preview toggle to see how your message will look
Syntax-highlighted code blocks using Prism themes
Support for GitHub Flavored Markdown (tables, strikethrough, task lists)

Technical:

react-markdown for rendering with remark-gfm for GitHub features
rehype-sanitize for secure HTML output (XSS protection)
react-syntax-highlighter with VS Code Dark+ theme
Messages stored as markdown-compatible text (no schema changes required)

Version 0.24.0 (API) - Message Pinning & Bookmarks

New Features:

Message Pinning: Pin important messages to channels for all members to see
Personal Bookmarks: Save messages privately for later reference
Real-time WebSocket notifications for pin/unpin actions
Access control ensures users can only pin/bookmark messages they can see

API Endpoints:

POST /api/messages/{id}/pin - Pin a message
DELETE /api/messages/{id}/pin - Unpin a message
GET /api/channels/{id}/pins - List pinned messages
POST /api/bookmarks - Bookmark a message
DELETE /api/bookmarks/{message_id} - Remove bookmark
GET /api/bookmarks - List your bookmarks

Technical:

Added pinned_messages and bookmarks database tables with RLS policies
Optimized queries with indexes for performance at scale
WebSocket integration for real-time pin/unpin notifications

Features

Core Messaging

Public & Private Channels - Organize conversations by topic or team
Direct Messages - 1-on-1 and group conversations
Real-time Sync - Messages appear instantly across all connected devices
Message Threading - Keep conversations organized (roadmap)
Rich Reactions - Express yourself with emoji reactions
Message Editing & Deletion - Full control over your messages

Collaboration

Typing Indicators - See when teammates are composing messages
User Presence - Online, offline, and away status tracking
File Attachments - Share images, documents, and more
Full-Text Search - Find messages instantly with PostgreSQL full-text search and Redis caching
@Mentions & Notifications - @user and @channel notifications with real-time alerts
Message Pinning - Pin important messages to channels for easy reference
Personal Bookmarks - Save messages for later with private bookmarks
Rich Text Formatting - Full markdown support with live preview and syntax highlighting

Enterprise Features

Multi-Organization Support - Host multiple teams on one instance
Organization Isolation - Database-level security with PostgreSQL RLS
SSO Authentication - Integrate with existing identity providers
Audit Logging - Track activity for compliance (roadmap)
Horizontal Scaling - Add more servers as your team grows

Tech Stack

Backend

Rust 2024 Edition - Modern, safe systems programming
Actix Web - High-performance async web framework
PostgreSQL - Reliable, feature-rich relational database
Redis - Caching and real-time pub/sub messaging
SQLx - Compile-time verified SQL queries
WebSockets - Real-time bidirectional communication

Frontend

Next.js 16 - React framework with server components
React 19 - Latest React with concurrent features
TypeScript - Type-safe development
Tailwind CSS - Modern utility-first styling
TanStack Query - Powerful data fetching and caching
Zustand - Lightweight state management

Infrastructure

Docker - Containerized deployment
AWS ECS - Scalable container orchestration
CloudFront - Global CDN for static assets
Network Load Balancer (NLB) - High-availability traffic routing for long-lived WebSocket connections
- Important: ALB is not suitable for OpenChat due to WebSocket connection timeouts
- NLB supports persistent connections required for real-time messaging

Quick Start

Desktop Application

Want the desktop experience? OpenChat now has native desktop applications for Windows, macOS, and Linux!

Download: See Desktop Application section below for installation instructions.

Web Application

Prerequisites

Docker and Docker Compose
PostgreSQL 14+
Redis 7+
Node.js 20+
Rust 1.83+ (2024 edition)

Local Development

Clone the repository

# HTTPS
git clone https://github.com/ZerosAndOnesLLC/OpenChat.git
cd OpenChat

# SSH
git clone git@github.com:ZerosAndOnesLLC/OpenChat.git
cd OpenChat

Start PostgreSQL and Redis
```
docker-compose up -d postgres redis
```

Set up the API

cd api
cp .env.example .env
# Edit .env with your database credentials

# Run migrations
cargo install sqlx-cli
sqlx database create
sqlx migrate run

# Start the API server
cargo run

Start the UI
```
cd ../ui
npm install
npm run dev
```
Open your browser
```
http://localhost:3000
```

Production Deployment

OpenChat is designed to run on AWS with ECS containers:

# Build and push Docker images
docker build -t openchat-api ./api
docker build -t openchat-ui ./ui

# Deploy with Terraform (see terraform/ directory)
cd terraform/prod/us-east-1/openchat
terraform apply

See DEPLOYMENT.md for detailed production setup instructions.

Architecture

┌─────────────┐         ┌──────────────┐         ┌──────────────┐
│   Browser   │◄───────►│   Next.js    │◄───────►│              │
│  (WebSocket)│         │      UI      │         │              │
└─────────────┘         └──────────────┘         │              │
                                                  │   Actix Web  │
┌─────────────┐         ┌──────────────┐         │   Rust API   │
│   Browser   │◄───────►│  CloudFront  │◄───────►│              │
│   (HTTP)    │         │      CDN     │         │              │
└─────────────┘         └──────────────┘         └──────┬───────┘
                                                         │
                        ┌────────────────────────────────┼────────┐
                        │                                │        │
                        ▼                                ▼        ▼
                 ┌──────────────┐              ┌──────────────┐  │
                 │  PostgreSQL  │              │    Redis     │  │
                 │   Database   │              │ Cache+PubSub │  │
                 └──────────────┘              └──────────────┘  │
                                                                 │
                                               ┌─────────────────▼──┐
                                               │  TitaniumVault SSO │
                                               └────────────────────┘

Security Architecture

OpenChat implements defense-in-depth security:

Application Layer - JWT token validation, role-based access control with fine-grained permissions
Database Layer - PostgreSQL Row Level Security (RLS) enforces organization isolation
Network Layer - TLS encryption, private VPC networking
Authentication - SSO integration with enterprise identity providers

Even if application code has bugs, the database prevents cross-organization data access.

Role-Based Permissions (v0.36.0)

OpenChat implements a comprehensive role-based permission system integrated with SSO:

SSO Roles:

openchat-admin - Full administrative access to all features
openchat - Standard user access with basic permissions

Permission System:

Granular Permissions: Fine-grained control over channel, organization, and DM operations
SSO Integration: Roles are provided by your SSO provider (TitaniumVault)
Redis Caching: Permission checks are cached for 5 minutes for optimal performance
Automatic Mapping: SSO roles automatically map to permission sets

Available Permissions:

Channel Permissions:

channel.read - Read messages and view channel details
channel.write - Send messages in channels
channel.delete - Delete channels
channel.invite_users - Invite users to channels
channel.manage_members - Add/remove channel members
channel.delete_messages - Delete any message in channel
channel.pin_messages - Pin messages in channels
channel.edit_details - Edit channel name, description, etc.

Organization Permissions:

org.create_channels - Create new channels
org.manage_users - Manage organization users
org.manage_roles - Manage roles and permissions
org.view_audit_logs - View organization audit logs
org.manage_settings - Manage organization settings
org.manage_integrations - Manage webhooks and integrations

DM Permissions:

dm.read - Read direct messages
dm.write - Send direct messages
dm.delete_own_messages - Delete own messages in DM

API Endpoints:

GET /api/roles - List all roles for organization
GET /api/roles/{id} - Get role with permissions
GET /api/permissions - List all available permissions

Default Permission Sets:

openchat-admin: All permissions
openchat: Basic channel read/write, DM access, create channels

OpenChat vs. Alternatives

Feature	OpenChat	Slack	Mattermost	Rocket.Chat
Open Source	✅ SSPL	❌ Proprietary	✅ MIT	✅ MIT
Self-Hosted	✅ Full control	❌ Cloud only	✅ Available	✅ Available
Built with Rust	✅ Memory safe	❌	❌	❌
Modern Tech Stack	✅ 2024	⚠️ Legacy	⚠️ Mixed	⚠️ Mixed
Row Level Security	✅ Database RLS	❌	❌	❌
WebSocket Real-time	✅ Native	✅	✅	✅
SSO Integration	✅ Built-in	✅ Paid	✅ Available	✅ Available
Horizontal Scaling	✅ Redis Pub/Sub	✅	✅	✅
Free for Commercial	✅ SSPL	❌ Paid	⚠️ Limits	⚠️ Limits
Docker Deployment	✅	N/A	✅	✅

Why Choose OpenChat?

Cost: No per-user fees, no feature paywalls, no surprise costs
Performance: Rust backend delivers exceptional speed and low memory usage
Security: Database-level isolation prevents data leaks
Modern: Built with 2024 technologies, not legacy codebases
Privacy: Your data never leaves your infrastructure
Control: Customize and extend as needed

Roadmap

✅ Phase 1 - MVP (Current)

🚧 Phase 2 - Enhanced Features (In Progress)

🔮 Phase 3 - Enterprise (Future)

📱 Phase 4 - Native Applications (In Progress)

Android Application
iOS Application
Windows Application (Tauri-based desktop app)
macOS Application (Tauri-based desktop app)
Linux Application (Tauri-based desktop app)

Note: OpenChat is under heavy development and the roadmap is subject to change. Features, timelines, and priorities may be adjusted based on community feedback and project needs.

API Features

Message Search

OpenChat provides powerful full-text search capabilities powered by PostgreSQL and Redis:

Endpoint: GET /api/search/messages

Query Parameters:

q - Search query text (required)
scope - Search scope: all, channel, or dm (default: all)
channel_id - Filter by specific channel (required if scope is channel)
dm_id - Filter by specific DM (required if scope is dm)
limit - Number of results (default: 50, max: 100)

Features:

Full-text search using PostgreSQL GIN indexes
Prefix matching for partial word searches
Results cached in Redis for 1 minute
Returns messages with total count
Supports search across all messages, specific channels, or DMs

Example:

GET /api/search/messages?q=hello+world&scope=channel&channel_id=abc-123&limit=20

Message Pinning

Pin important messages to the top of channels for easy reference by all members:

Endpoints:

POST /api/messages/{id}/pin - Pin a message (channel members only)
DELETE /api/messages/{id}/pin - Unpin a message
GET /api/channels/{id}/pins - List all pinned messages in a channel

Features:

Only channel messages can be pinned (not DMs)
All channel members can view pinned messages
Real-time WebSocket notifications when messages are pinned/unpinned
Pins are sorted by pinned date (most recent first)

Example:

# Pin a message
POST /api/messages/msg-123/pin

# List pinned messages
GET /api/channels/channel-456/pins

Personal Bookmarks

Save messages for later reference with personal bookmarks:

Endpoints:

POST /api/bookmarks - Bookmark a message
DELETE /api/bookmarks/{message_id} - Remove a bookmark
GET /api/bookmarks - List all your bookmarks

Features:

Bookmarks are private to each user
Works with both channel messages and DMs
Access verification ensures users can only bookmark messages they can see
Sorted by bookmark date (most recent first)

Example:

# Bookmark a message
POST /api/bookmarks
{
  "message_id": "msg-789"
}

# List your bookmarks
GET /api/bookmarks

Performance

OpenChat is built for scale:

Message Throughput: 10,000+ messages/second per instance
Concurrent Users: Thousands per server with Redis Pub/Sub
Database Queries: Optimized with indexes and query planning
Caching: Aggressive Redis caching reduces database load by 80%+
WebSocket: Efficient connection pooling and message routing
Latency: Sub-100ms message delivery in same region
Search Performance: Full-text search with GIN indexes and 1-minute Redis caching

Scalability

Horizontal Scaling: Add more ECS tasks behind Network Load Balancer (NLB)
- NLB required for WebSocket connection persistence
- Supports thousands of concurrent long-lived connections per instance
Database: PostgreSQL supports millions of messages
Redis: Distributed pub/sub for cross-instance messaging
CDN: CloudFront delivers static assets globally
Stateless API: Each request can be handled by any instance

Accessing OpenChat

Authentication Flow

OpenChat uses TitaniumVault for authentication and should be accessed through the TitaniumVault applications portal:

Log in to TitaniumVault at https://titanium-vault.com
Navigate to Applications page
Click on OpenChat - this initiates the OAuth flow
OpenChat opens with you automatically authenticated

Important: Do not access OpenChat directly. Always go through TitaniumVault's applications portal to ensure proper authentication.

OAuth Configuration

OpenChat uses OAuth 2.0 with PKCE for secure authentication:

Client ID: openchat-api (registered in TitaniumVault)
Redirect URI: https://openchat.zerosandones.us/sso/callback/
Scopes: openid profile email
Grant Types: authorization_code, client_credentials, refresh_token

Security

Authentication

JWT token-based authentication
Single sign-on (SSO) integration via OAuth 2.0 with PKCE
TitaniumVault identity provider support
Secure token refresh mechanism

Authorization

Organization-level isolation
Role-based access control (admin, member)
Channel-level permissions (public, private)
PostgreSQL Row Level Security (RLS)

Data Protection

TLS encryption in transit
Database encryption at rest
Secure session management
CSRF protection
SQL injection prevention (compile-time verified queries)

Compliance

GDPR-ready with data export capabilities
Audit logging for compliance tracking
Data retention policies
Self-hosted for data sovereignty

Desktop Application

OpenChat Desktop is a native desktop application built with Tauri and Rust, providing a lightweight, fast, and secure desktop experience for Windows, macOS, and Linux.

Features

Native Performance: Built with Rust for maximum performance and minimal resource usage
Lightweight: 3-10MB bundle size (vs 50-100MB for Electron-based apps)
Cross-Platform: Single codebase for Windows, macOS, and Linux
Shared UI: Uses the same Next.js interface as the web application
System Integration: Native notifications, tray icon, and OS-level features
Secure: Tauri's capabilities-based security model ensures safe operation

Download & Installation

Windows

Download the latest .msi installer from Releases
Run the installer and follow the setup wizard
Launch OpenChat from the Start Menu or Desktop shortcut

System Requirements:

Windows 10 or later
WebView2 Runtime (usually pre-installed)

macOS

Download the latest .dmg file from Releases
Open the .dmg and drag OpenChat to Applications
Launch from Applications folder (builds are not yet notarized: right-click → Open the first time)

System Requirements:

macOS 10.13 (High Sierra) or later

Linux

Download your preferred package format:

Debian/Ubuntu: .deb package
AppImage: Universal .AppImage (no installation required)
RPM: For Fedora, RHEL, openSUSE

# Debian/Ubuntu
sudo dpkg -i openchat_0.1.0_amd64.deb

# AppImage (no installation needed)
chmod +x OpenChat-0.1.0.AppImage
./OpenChat-0.1.0.AppImage

# Fedora/RHEL
sudo rpm -i openchat-0.1.0.x86_64.rpm

System Requirements:

Modern Linux distribution with GTK 3.24+
WebKit2GTK 4.1

Development

Want to build from source or contribute to the desktop app? See the Desktop Development Guide.

Technical Details

Framework: Tauri 2.x
Backend: Rust 2024 edition
Frontend: Next.js (shared with web app)
Size: ~5MB installed
Plugins: Shell, Dialog, FileSystem, Notifications

CI & Releases

CI (.github/workflows/ci.yml) runs on every pull request and push to main. All CI and release workflows use GitHub-hosted runners (free for this public repo); no self-hosted runners are required.

API / Desktop: cargo check with warnings as errors, cargo test, and cargo clippy (report only)
Web UI: tsc --noEmit, next build, and ESLint (report only)

Releases are cut by pushing a tag; the tag must match the version in the component's manifest.

Component	Version source	Tag	Workflow	Runners
API	`api/Cargo.toml`	`api-vX.Y.Z`	`api-release.yml`	GitHub-hosted (Ubuntu 22.04 x64 + arm64, glibc 2.35+)
Desktop	`tauri/Cargo.toml`	`desktop-vX.Y.Z`	`tauri-release.yml`	GitHub-hosted (Linux x64/arm64, Windows, macOS)
Web UI	`webui/package.json`	—	deployed via `webui/build-and-pub-to-s3.sh`	—

Use scripts/release.sh to cut a release:

# 1. On a branch: bump the version (manifest + lockfile), verify it builds, and commit
scripts/release.sh bump api patch        # or: desktop / webui, minor / major
# 2. Open a PR and merge it
# 3. On an up-to-date main: tag the merged version and push the tag (starts the release workflow)
scripts/release.sh tag api               # or: desktop

Both release workflows can also be run manually from the Actions tab (workflow_dispatch) as a dry run that builds artifacts without publishing a release. The latest 10 releases per component are kept; older releases are pruned but their tags are preserved.

Lockfiles (api/Cargo.lock, tauri/Cargo.lock, webui/package-lock.json) are committed so CI and releases build against the exact reviewed dependency versions.

Contributing

We welcome contributions from the community! Whether you're fixing bugs, adding features, or improving documentation, your help is appreciated.

How to Contribute

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Make your changes
- Follow Rust and TypeScript best practices
- Add tests for new functionality
- Update documentation as needed
Run tests and linters
```
cargo test
cargo clippy
npm run lint
```
Commit your changes (git commit -m 'Add amazing feature')
Push to your branch (git push origin feature/amazing-feature)
Open a Pull Request

Development Guidelines

Rust: Follow Rust 2024 edition idioms, use cargo fmt and cargo clippy
TypeScript: Use strict TypeScript, follow Next.js conventions
Testing: Write unit tests for business logic, integration tests for APIs
Documentation: Update README and inline documentation
Security: Never commit secrets, follow secure coding practices

Code of Conduct

We are committed to providing a welcoming and inclusive environment. Please read our Code of Conduct before contributing.

Support

Documentation: docs.openchat.dev (coming soon)
Issues: GitHub Issues
Discussions: GitHub Discussions
Security: Report vulnerabilities to security@openchat.dev

License

OpenChat is licensed under the Server Side Public License (SSPL) v1.

The SSPL is a source-available license that allows free use, modification, and distribution. If you offer OpenChat as a service to third parties, you must open source your service infrastructure.

Key Points:

✅ Free to use internally
✅ Free to modify and customize
✅ Full source code available
⚠️ Service providers must open source their infrastructure stack

See LICENSE.md for the complete license text and terms.

Acknowledgments

Built with amazing open-source technologies:

Rust - Memory-safe systems programming
Actix Web - Powerful, pragmatic web framework
Next.js - The React framework for production
PostgreSQL - The world's most advanced open source database
Redis - In-memory data structure store
Tailwind CSS - Utility-first CSS framework

Special thanks to all our contributors who help make OpenChat better!

Getting Started • Documentation • Contributing • License

Made with ❤️ by the OpenChat community

⭐ Star us on GitHub if you find OpenChat useful!

Name		Name	Last commit message	Last commit date
.github		.github
api		api
deprecated/win64		deprecated/win64
docs/screenshots		docs/screenshots
scripts		scripts
tauri		tauri
webui		webui
.gitignore		.gitignore
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE.md		LICENSE.md
LOAD_TESTING.md		LOAD_TESTING.md
README.md		README.md
SECURITY.md		SECURITY.md
load_test_token_cache.sh		load_test_token_cache.sh
plan.md		plan.md
quick-config.md		quick-config.md
todo.md		todo.md
v2.md		v2.md

Latest commit

History

Folders and files

Repository files navigation

OpenChat

Screenshots

Why OpenChat?

Key Highlights

Recent Updates

Version 0.38.0 (API) / 0.16.0 (UI) - Enterprise Audit Logging & Enhanced Custom Emojis

Version 0.33.0 (API) / 0.11.0 (UI) - Advanced Search & Real-time Notifications

Version 0.32.0 (API) / 0.10.0 (UI) - Complete File Attachments & Storage System

Version 0.25.0 (API) / 0.6.0 (UI) - Rich Text Formatting with Markdown

Version 0.24.0 (API) - Message Pinning & Bookmarks

Features

Core Messaging

Collaboration

Enterprise Features

Tech Stack

Backend

Frontend

Infrastructure

Quick Start

Desktop Application

Web Application

Prerequisites

Local Development

Production Deployment

Architecture

Security Architecture

Role-Based Permissions (v0.36.0)

OpenChat vs. Alternatives

Why Choose OpenChat?

Roadmap

✅ Phase 1 - MVP (Current)

🚧 Phase 2 - Enhanced Features (In Progress)

🔮 Phase 3 - Enterprise (Future)

📱 Phase 4 - Native Applications (In Progress)

API Features

Message Search

Message Pinning

Personal Bookmarks

Performance

Scalability

Accessing OpenChat

Authentication Flow

OAuth Configuration

Security

Authentication

Authorization

Data Protection

Compliance

Desktop Application

Features

Download & Installation

Windows

macOS

Linux

Development

Technical Details

CI & Releases

Contributing

How to Contribute

Development Guidelines

Code of Conduct

Support

License

Acknowledgments

About

Resources

Code of conduct

Contributing

Security policy

Stars

Watchers

Forks

Releases

Packages

Used by

Contributors