What is XMPP? Complete Guide to XMPP Messaging Protocol (2025)

What is XMPP? Understanding the Extensible Messaging and Presence Protocol

XMPP (Extensible Messaging and Presence Protocol) is an open-source protocol for real-time communication that enables instant messaging, presence information, and data exchange between network entities. Originally developed as the Jabber protocol in 1999, XMPP uses XML-based streams to facilitate secure, decentralized messaging across federated servers.

How XMPP works: XMPP operates on a client-server architecture where messages flow through XML streams over persistent TCP connections. Unlike proprietary messaging systems, XMPP's federated design allows different servers to communicate with each other, similar to how email works. Major platforms including WhatsApp have leveraged XMPP's robust architecture for their messaging infrastructure.

Key benefits of XMPP messaging:

• Open Standard: Governed by IETF standards (RFC 6120, RFC 6121) ensuring interoperability
• Decentralized Federation: Run your own XMPP server while communicating with other domains
• Strong Security: Built-in TLS encryption with modern OMEMO end-to-end encryption support
• Extensible Design: Add features through standardized XEP (XMPP Extension Protocol) modules
• Real-Time Communication: Sub-100ms message delivery with persistent connections

XMPP continues to power diverse applications beyond instant messaging, including Internet of Things (IoT) devices, real-time collaboration tools, gaming platforms, and enterprise communication systems.

1. Introduction

1.1 Historical Context

The Extensible Messaging and Presence Protocol (XMPP) emerged from the Jabber open-source community in January 1999 when Jeremie Miller announced Jabber and released the first version of the jabberd server. This open-source messaging protocol provided a decentralized alternative to closed instant messaging systems, building its foundation on open standards and XML-based communication.

The protocol achieved significant milestones with the formation of the Jabber Software Foundation (JSF, later renamed XMPP Standards Foundation) in August 2001, which provided governance and standardization oversight. In October 2004, the Internet Engineering Task Force (IETF) formally standardized XMPP's core protocols through RFC 3920 (XMPP Core) and RFC 3921 (Instant Messaging and Presence). The IETF revised these specifications in March 2011 as RFC 6120 and RFC 6121, establishing XMPP as a robust framework for real-time communication with improved security and internationalization.

XMPP has evolved far beyond its initial scope of instant messaging and presence. Through its extensible nature, it now powers diverse applications including Internet of Things (IoT) devices, real-time collaboration tools, social networking features, gaming platforms, and cloud computing services.

Sources: XMPP Standards Foundation History; IETF RFC 3920 (October 2004); IETF RFC 6120/6121 (March 2011).

What This XMPP Guide Covers

This comprehensive guide serves as a technical reference for developers, system architects, and IT professionals working with XMPP-based systems. It covers the protocol's fundamental architecture, security considerations, and implementation details. You'll explore XMPP's core specifications while understanding its extensibility through XEPs (XMPP Extension Protocols).

You'll gain understanding of both theoretical concepts and practical applications, from basic client-server interactions to advanced features like federation and real-time data exchange.

1.3 Core Concepts

XMPP's foundation rests on several key principles that enable real-time communication and extensibility. At its core, XMPP provides presence information and instant messaging capabilities through XML streams. These streams facilitate near-real-time exchange of structured data between network entities.

An XML stream opens with a <stream:stream> tag that establishes the connection context:

<stream:stream
  from='client@example.com'
  to='example.com'
  version='1.0'
  xmlns='jabber:client'
  xmlns:stream='http://etherx.jabber.org/streams'>

The protocol's extensibility comes from XEPs (XMPP Extension Protocols), which allow for standardized protocol additions without modifying the core specification. This modular approach enables XMPP to adapt to new use cases while maintaining backward compatibility.

XMPP employs a distributed client-server architecture with federation capabilities, allowing separate XMPP servers to communicate with each other. This design promotes interoperability and scalability while adhering to open standards, ensuring that different implementations work together seamlessly.

2. How Does XMPP Work? Architecture Overview

XMPP Client-Server Architecture

XMPP's client-server model establishes a foundation for reliable message routing and presence management. Clients connect to their designated XMPP server using long-lived TCP connections, over which XML streams are established. The server acts as both a message router and presence manager, maintaining session state and handling message delivery.

Servers play a crucial role in federation, enabling communication between users on different domains. When a client sends a message to a user on another server, their home server establishes a server-to-server connection with the recipient's server, creating a robust and scalable network topology.

2.2 Entities and Addresses (JIDs)

XMPP uses Jabber IDs (JIDs) as unique addresses for all entities in the network. A full JID consists of three parts: localpart@domainpart/resourcepart. The localpart identifies a specific user account, the domainpart specifies the server hosting the account, and the optional resourcepart distinguishes between multiple client connections for the same user.

For example, in user@example.com/mobile, "user" is the localpart, "example.com" is the domainpart, and "mobile" is the resourcepart. This addressing scheme enables precise routing and resource management.

2.3 Stanzas

XMPP defines three fundamental types of XML stanzas for communication:

• <message/> stanzas for pushing information between entities
• <presence/> stanzas for broadcasting availability status
• <iq/> (Info/Query) stanzas for request-response interactions

Here are examples of each stanza type:

Message Stanza:

<message from='user@example.com/mobile'
         to='friend@example.net'
         type='chat'
         id='msg123'>
  <body>Hello, how are you?</body>
</message>

Presence Stanza:

<presence from='user@example.com/mobile'>
  <show>away</show>
  <status>In a meeting</status>
</presence>

IQ Stanza:

<iq from='user@example.com/mobile'
    to='example.com'
    type='get'
    id='roster1'>
  <query xmlns='jabber:iq:roster'/>
</iq>

Each stanza type has specific attributes and child elements that define its purpose and behavior. These stanzas form the basic building blocks of XMPP communication, enabling everything from simple chat messages to complex application-specific data exchange.

2.4 Data Flow

Communication in XMPP follows a structured flow:

1. TCP Connection – Establish connection to server (default port 5222)
2. Stream Opening – Send initial <stream:stream> element
3. TLS Negotiation – Upgrade to encrypted connection using STARTTLS
4. SASL Authentication – Authenticate using credentials
5. Resource Binding – Bind a resource identifier to the connection
6. Session Establishment – Begin sending stanzas

The stream negotiation process ensures secure and authenticated communication channels before any actual data exchange occurs. Once established, these streams enable efficient bi-directional communication between entities.

2.5 Protocol Layers

XMPP implements a layered protocol architecture:

1. TCP provides reliable transport
2. TLS ensures channel security (port 5222 for client-to-server, port 5269 for server-to-server)
3. XMPP streams establish the XML communication context
4. Stanzas carry application-level data
5. XEP extensions add specialized functionality

┌─────────────────────────┐
│   XEP Extensions        │
├─────────────────────────┤
│   XMPP Stanzas          │
├─────────────────────────┤
│   XML Streams           │
├─────────────────────────┤
│   TLS (5222, 5269)      │
├─────────────────────────┤
│   TCP                   │
└─────────────────────────┘

This layered approach separates concerns and enables modular implementation while maintaining security and reliability. Each layer builds upon the previous one, creating a robust foundation for real-time communication applications.

3. Core Specifications and Standards

3.1 RFC Overviews

The core XMPP specifications are defined in three primary RFCs that work together to provide a complete protocol definition:

RFC 6120 (XMPP Core), published March 2011, establishes the fundamental XML streaming protocol, including stream negotiation, channel encryption, authentication, and error handling. This foundational document defines how XMPP entities communicate at the most basic level.

RFC 6121 (Instant Messaging & Presence), published March 2011, builds upon the core by defining specific protocols for instant messaging and presence functionality, including roster management, presence subscriptions, and message handling.

RFC 7622 (XMPP Address Format), published September 2015, specifies the format and handling of XMPP addresses (JIDs). This specification obsoleted RFC 6122 (March 2011) to improve internationalization support by replacing stringprep with the PRECIS framework for preparation and comparison of internationalized strings.

Sources: IETF RFC 6120 (March 2011); IETF RFC 6121 (March 2011); IETF RFC 7622 (September 2015).

3.2 Protocol Requirements

XMPP implementations must support several core features to ensure interoperability. XML streams and TLS encryption are mandatory components, providing the foundation for secure communication. While SASL authentication mechanisms are required, implementations have flexibility in choosing which specific mechanisms to support.

Resource binding, though technically optional, is practically required for client connections to function properly. The protocol maintains backward compatibility through careful versioning, allowing newer implementations to communicate with older ones while supporting enhanced features when available.

3.3 Technical Details

XMPP enforces strict XML well-formedness requirements while prohibiting certain XML features like DTDs and external entities for security reasons. Stream features are negotiated in a specific order, with security features like TLS typically negotiated before authentication.

The protocol defines comprehensive error handling at both stream and stanza levels, enabling robust error reporting and recovery. Domain validation ensures that servers only process traffic for domains they are authorized to handle.

4. Security and Privacy

XMPP Transport Security: TLS Requirements

XMPP mandates the use of Transport Layer Security (TLS) for secure communication. RFC 6120 originally required TLS 1.0 or higher, but RFC 7590 (published June 2015) updated these requirements to reflect modern security practices. Current implementations MUST support TLS 1.2 or higher, with TLS 1.3 RECOMMENDED for new deployments.

The TLS handshake process verifies server certificates and optionally client certificates, establishing a secure encrypted channel before any XMPP-level communication begins. Prioritize modern cipher suites with forward secrecy (such as those using ECDHE key exchange) over legacy cipher suites.

Configure your TLS implementations to:

• Disable outdated protocols (SSL 2.0, SSL 3.0, TLS 1.0, TLS 1.1)
• Use strong cipher suites with forward secrecy
• Maintain up-to-date certificate revocation lists
• Implement HTTP Strict Transport Security (HSTS) where applicable

Regular security audits and certificate rotation are recommended best practices.

Sources: IETF RFC 6120 (March 2011); IETF RFC 7590 (June 2015).

4.2 Authentication and Authorization

XMPP supports multiple SASL (Simple Authentication and Security Layer) authentication mechanisms. Historically, SCRAM-SHA-1 and SCRAM-SHA-1-PLUS were specified as mandatory-to-implement mechanisms. However, due to advances in cryptographic standards, modern implementations SHOULD support SCRAM-SHA-256 and SCRAM-SHA-256-PLUS, which provide stronger security guarantees. The EXTERNAL mechanism is commonly used with TLS client certificates for server-to-server communications.

Implement access control through a combination of authentication credentials and authorization rules. Servers maintain access control lists and can implement additional authorization policies through XEP extensions like privacy lists (XEP-0016) and blocking commands (XEP-0191) for roster management.

Sources: IETF RFC 6120; IETF RFC 5802 (SCRAM-SHA-1); IETF RFC 7677 (SCRAM-SHA-256).

XMPP End-to-End Encryption with OMEMO

OMEMO (OMEMO Multi-End Message and Object Encryption), defined in XEP-0384, has emerged as the preferred method for end-to-end encryption in XMPP. The current version (0.9.0, published April 2025) provides forward secrecy and multi-device support using the X3DH key agreement protocol combined with the Double Ratchet Algorithm.

OMEMO uses:

• Curve25519/Ed25519 for key agreement
• AES-256-CBC for message encryption
• HMAC-SHA-256 for authentication

The protocol ensures that messages remain secure even if keys are later compromised, and supports asynchronous communication where recipients can decrypt messages even when offline during transmission.

While OpenPGP (XEP-0373) and OTR (Off-the-Record) messaging are also supported, they have limitations in multi-device scenarios. OpenPGP lacks forward secrecy, and older OTR versions (pre-OTRv4) require both parties to be online simultaneously. OMEMO offers the best balance of security and usability for modern XMPP deployments, though it increases implementation complexity and requires careful key management.

Sources: XEP-0384: OMEMO Encryption v0.9.0 (April 2025); Double Ratchet specification by Trevor Perrin and Moxie Marlinspike; X3DH specification.

4.4 Privacy and Data Protection

XMPP implements privacy controls through multiple mechanisms. Privacy lists allow users to control who can see their presence information and send them messages. Servers can implement additional privacy features through XEPs, such as blocking commands and invisible mode.

The protocol's design considers metadata minimization, though some information like JIDs must be visible for routing purposes. Modern XMPP implementations include features to help comply with privacy regulations like GDPR, such as data export capabilities and the right to be forgotten.

5. Extension Mechanism: XEPs (XMPP Extension Protocols)

5.1 Role of the XMPP Standards Foundation (XSF)

The XMPP Standards Foundation manages the XEP process, providing governance and oversight for protocol extensions. XEPs progress through defined stages: Experimental, Proposed, Draft, and Final, with each stage requiring increasing levels of review and implementation experience.

The XSF Council, elected by XSF members, votes on protocol approvals and status changes. This structured process ensures that extensions are well-designed, thoroughly tested, and maintain compatibility with core XMPP specifications.

5.2 Key XEP Examples

Several XEPs have become fundamental to modern XMPP implementations:

• XEP-0030 (Service Discovery): Enables entities to discover features and capabilities supported by other entities on the network. Status: Final (since 2008).
• XEP-0045 (Multi-User Chat): Provides comprehensive group chat functionality, including room management, participant roles, and moderation features. Status: Draft. Last significant revision in February 2012.
• XEP-0163 (Personal Eventing Protocol): Allows entities to broadcast state changes and updates to authorized subscribers using a simplified publish-subscribe model. Status: Draft.
• XEP-0060 (Publish-Subscribe): Implements a generic publish-subscribe framework for information distribution, forming the foundation for many other XEPs. Status: Draft.
• XEP-0280 (Message Carbons): Synchronizes messages across multiple devices for the same user account. Status: Draft.
• XEP-0313 (Message Archive Management): Provides server-side message history storage and retrieval. Status: Draft.
• XEP-0368 (SRV records for XMPP over TLS): Enables direct TLS connections on dedicated ports (5223 for client-to-server, 5270 for server-to-server) without traditional STARTTLS negotiation. Status: Proposed (2021).
• XEP-0384 (OMEMO Encryption): Implements modern end-to-end encryption with forward secrecy and multi-device support. Status: Experimental. Current version 0.9.0 (April 2025).

These extensions demonstrate XMPP's versatility in addressing various communication needs while maintaining protocol consistency.

Sources: XMPP Standards Foundation XEP repository; individual XEP specifications.

5.3 How Extensions Work in Practice

Extensions integrate with XMPP through defined XML namespaces and structured stanza patterns. Each XEP specifies its namespace, required stanza formats, and processing rules. Implementations must handle backward compatibility and graceful fallback when interacting with entities that don't support specific extensions.

Test for interoperability between different implementations, with many XEPs including comprehensive test suites. The XSF maintains compliance suites to verify correct implementation of both core protocols and extensions.

6. XMPP Server and Client Implementation

Popular XMPP Server Implementations

Several mature XMPP server implementations serve different deployment needs:

6.2 Client Libraries

XMPP client libraries exist for all major programming platforms:

• Strophe.js: Mature JavaScript library for web applications
• Smack: Feature-rich Java library with Android support
• Slixmpp: Modern Python library with async/await support
• Gloox: Comprehensive C++ library

Example code snippet using Strophe.js:

const conn = new Strophe.Connection(BOSH_SERVICE);

conn.connect(user_jid, password, (status) => {
  if (status === Strophe.Status.CONNECTED) {
    console.log('Connected to XMPP server');

    // Send a message
    const message = $msg({
      to: 'recipient@example.com',
      type: 'chat'
    }).c('body').t('Hello from Strophe!');
    conn.send(message);

    // Handle incoming messages
    conn.addHandler(onMessage, null, 'message', 'chat');
  } else if (status === Strophe.Status.DISCONNECTED) {
    console.log('Disconnected from XMPP server');
  }
});

function onMessage(message) {
  const body = message.querySelector('body')?.textContent;
  const from = message.getAttribute('from');
  console.log(`Message from ${from}: ${body}`);
  return true; // Keep handler active
}

Select libraries based on factors like API design, documentation quality, and community support.

6.3 Developer Tools

Development tools facilitate XMPP implementation and debugging:

• XML console debuggers like the ones in Gajim and Psi provide real-time protocol inspection
• Network monitoring tools such as Wireshark offer XMPP-specific protocol analysis
• Command-line tools like xmpp-client enable automated testing and scripting
• Continuous Integration frameworks can incorporate XMPP compliance testing

These tools support the entire development lifecycle, from initial implementation to deployment and maintenance.

7. Advanced Topics and Use Cases

7.1 Federation and Scalability

XMPP's federated architecture enables independent servers to communicate while maintaining autonomy over their domains. This design provides natural scalability but introduces challenges in maintaining consistent service quality across federated networks.

High-throughput deployments typically employ clustering solutions, with load balancers distributing traffic across multiple server nodes. Modern XMPP servers support various clustering approaches, from simple active/passive setups to complex multi-master configurations.

┌─────────────┐     ┌─────────────┐
│   Client    │────▶│    Load     │
│ Connections │     │  Balancer   │
└─────────────┘     └──────┬──────┘
                           │
        ┌──────────────────┼──────────────────┐
        │                  │                  │
   ┌────▼────┐        ┌────▼────┐       ┌────▼────┐
   │ XMPP    │        │ XMPP    │       │ XMPP    │
   │ Node 1  │◀──────▶│ Node 2  │◀─────▶│ Node 3  │
   └────┬────┘        └────┬────┘       └────┬────┘
        │                  │                  │
        └──────────────────┼──────────────────┘
                           │
                      ┌────▼────┐
                      │ Shared  │
                      │ Storage │
                      └─────────┘

XMPP for IoT Applications

XMPP's extensible nature makes it well-suited for IoT applications, offering advantages over protocols like MQTT and CoAP in certain scenarios. The protocol's presence mechanism naturally maps to device status monitoring, while its publish-subscribe capabilities facilitate sensor data distribution.

Key IoT-focused XEPs provide:

• XEP-0323: Efficient sensor data transmission
• XEP-0325: Device control and management
• XEP-0347: Presence-based device discovery
• Secure authentication and authorization

XMPP's advantage in IoT lies in its built-in security features and ability to traverse NATs and firewalls, though it may have higher overhead compared to lightweight protocols like MQTT.

7.3 Real-Time Collaboration

XMPP supports real-time collaboration through various extensions:

These capabilities enable enterprise-grade collaboration solutions, particularly in environments requiring high security or compliance with specific regulations. Mission-critical deployments benefit from XMPP's robust error handling and delivery guarantees.

7.4 Bridging and Interoperability

XMPP gateways enable communication with other protocols and networks through protocol translation and message routing. Common implementations include:

• Spectrum2: Multi-protocol gateway supporting IRC, Slack, WhatsApp, and more
• Biboumi: IRC gateway for XMPP
• Integration with social media platforms
• Connectors for enterprise messaging systems

In microservices architectures, XMPP can serve as a message broker, handling event distribution and service communication. Its structured stanza format and extensible nature make it suitable for event-driven architectures requiring rich metadata and routing capabilities.

8. Deployment Considerations

Planning Your XMPP Infrastructure

Successful XMPP deployment requires careful infrastructure planning:

DNS Configuration:

• SRV records for service discovery
• Multiple A/AAAA records for high availability
• DNSSEC for enhanced security

Example SRV records:

_xmpp-client._tcp.example.com. 86400 IN SRV 5 0 5222 xmpp1.example.com.
_xmpp-server._tcp.example.com. 86400 IN SRV 5 0 5269 xmpp1.example.com.

Hardware Requirements:

• CPU: Multiple cores for concurrent connection handling
• Memory: Sufficient for in-memory session storage (approximately 1–2 MB per active connection)
• Storage: Fast I/O for message archives
• Network: Low-latency, high-bandwidth connectivity

Containerization using Docker or Kubernetes can provide deployment flexibility and simplified scaling.

Hardening XMPP Server Security

Implement robust security measures:

TLS Configuration:

• Use modern cipher suites only
• Enable Perfect Forward Secrecy
• Rotate certificates regularly
• Implement HSTS

Protection Mechanisms:

• Rate limiting at connection and stanza levels
• DDoS mitigation through traffic analysis
• Input validation for all client data
• Regular security audits

Firewall Rules:

# Allow XMPP client connections
iptables -A INPUT -p tcp --dport 5222 -j ACCEPT

# Allow XMPP server-to-server
iptables -A INPUT -p tcp --dport 5269 -j ACCEPT

# Allow HTTPS for BOSH/WebSocket
iptables -A INPUT -p tcp --dport 443 -j ACCEPT

Configure comprehensive monitoring and alerting systems to track security-related events and anomalies.

8.3 Performance Optimization

Optimize performance across several key areas:

Caching Strategy:

• Redis or Memcached for session data
• In-memory roster caching
• Message queue optimization

Architecture:

• Horizontal scaling across multiple nodes
• Geographic distribution for lower latency
• Connection pooling for database access

Balance message archive management between accessibility and performance impact. Target metrics: sub-100ms message delivery latency, support for 1,000+ messages per second per server node.

8.4 Maintenance and Upgrades

Implement effective maintenance procedures to ensure reliable service:

• Schedule regular update cycles for security patches
• Use staged rollouts of major version upgrades
• Test compatibility before deployment
• Maintain automated rollback procedures

Test new XEP implementations thoroughly in staging environments before production deployment. Maintain documentation to track configuration changes and custom modifications.

9. XMPP vs Alternative Messaging Protocols

XMPP Challenges and Limitations

The extensive flexibility of XMPP's extension mechanism presents significant implementation challenges. While XEPs enable powerful customization, they can lead to fragmentation when different implementations support varying subsets of extensions. This creates compatibility issues between clients and servers.

Balance the benefits of implementing newer extensions against the need to maintain broad compatibility. Managing extension dependencies and version compatibility often results in increased development complexity and potential interoperability issues.

XMPP vs MQTT vs Matrix: Protocol Comparison

XMPP faces strong competition from newer protocols and proprietary solutions:

When to choose XMPP:

• Enterprise environments requiring federation across domains
• Applications needing strong security and compliance features
• Systems requiring both messaging and presence information
• Projects benefiting from standardized, well-documented protocols

XMPP maintains advantages in federation, security, and standardization. Market trends suggest continued relevance in enterprise and IoT applications, though consumer messaging increasingly favors closed platforms.

9.3 Standardization and Governance

The volunteer-driven nature of XMPP standardization can lead to challenges:

• XEP development may lag behind rapidly evolving technology needs
• Limited resources for documentation and specification maintenance
• Difficulty in achieving consensus for controversial features

The XMPP Standards Foundation must balance careful deliberation with the need for timely updates to maintain the protocol's relevance in fast-moving technology landscapes.

10. Future Directions

10.1 Emerging Standards and XEP Proposals

Several developments are shaping XMPP's evolution:

• Enhanced WebRTC integration for seamless multimedia communication
• Improved support for augmented reality (AR) and virtual reality (VR) applications
• New extensions for real-time data synchronization and stream processing
• Advanced encryption methods for group communications

Emerging proposals focus on:

• Reduced protocol overhead for resource-constrained devices
• Better support for mobile and progressive web applications
• Integration with modern authentication frameworks (OAuth 2.0, OpenID Connect)
• Improved handling of large-scale pub/sub systems

10.2 Ecosystem Growth

XMPP's future growth appears promising in several sectors:

Enterprise and Government:

• Increased adoption for secure internal communications
• Integration with zero-trust security architectures
• Custom deployments for specific regulatory requirements

IoT and Infrastructure:

• Expanded use in industrial IoT applications
• Integration with edge computing platforms
• Enhanced support for mesh networks

Privacy and Security:

• Advanced end-to-end encryption methods
• Improved metadata protection
• Enhanced audit and compliance capabilities

The protocol continues to evolve with emphasis on:

• Simplified deployment models
• Better support for cloud-native architectures
• Enhanced scalability for massive deployments
• Improved tools for monitoring and management

11. Conclusion

11.1 Key Takeaways

XMPP has proven itself as a versatile and robust protocol for real-time communication, offering unique advantages through its federated architecture and extensive extensibility. Its key strengths include:

• Open standardization ensuring protocol stability and interoperability
• Rich ecosystem of extensions addressing diverse use cases
• Strong security features including end-to-end encryption
• Proven scalability in large-scale deployments

Be aware of these challenges:

• Complexity in managing multiple extensions
• Potential fragmentation across implementations
• Higher initial development overhead compared to simpler protocols
• Need for careful performance optimization in large deployments

11.2 Looking Ahead

XMPP continues to evolve and maintain relevance in modern communication systems. Its strong foundation in open standards and active community development suggest a sustainable future, particularly in enterprise and IoT applications.

Join the XMPP community:

• Join the XMPP Standards Foundation
• Participate in protocol development
• Contribute to open-source implementations
• Engage with the community through official channels

Visit xmpp.org to begin your journey with XMPP.

12. References and Further Reading

Core Documentation

• XMPP Standards Foundation
• XMPP Software
• XMPP Security

IETF RFCs

• RFC 6120: XMPP Core
• RFC 6121: XMPP Instant Messaging and Presence
• RFC 6122: XMPP Address Format
• RFC 7622: XMPP Address Format Update

Essential XEPs

• XEP-0045: Multi-User Chat
• XEP-0060: Publish-Subscribe
• XEP-0280: Message Carbons
• XEP-0384: OMEMO Encryption
• XEP-0363: HTTP File Upload

Academic Resources

• "XMPP: The Definitive Guide" (O'Reilly Media)
• "Building XMPP Applications with JavaScript" (Packt Publishing)
• "Security Analysis of XMPP Federation" (IEEE)

Community Resources

• XMPP Mailing Lists
• XMPP Chat Rooms
• XMPP Blog
• XMPP Newsletter

Development Tools

• XMPP Compliance Suites
• XMPP Protocol Validator
• XMPP Interoperability Testing

Working Groups

• XMPP Council
• Internet of Things Special Interest Group
• Security Special Interest Group