D++ Library Documentation

D++ (DPP) is a lightweight, high-performance C++ library designed for interacting with the Discord API (v10). It is optimized for a minimal memory footprint and high scalability, making it suitable for bots managing large numbers of guilds and users.

Key features include:

• Efficient Caching: Optimized systems for guilds, channels, members, roles, and users.
• High Throughput: Uses highly optimized Erlang Term Format (ETF) support for fast WebSocket communication.
• Scalability: Built-in support for sharding and clustering.
• Feature Completeness: Supports Slash Commands/Interactions and full Voice support (sending and receiving audio).
• Cross-Platform: Stable support for Linux, Windows, macOS, FreeBSD, and OpenBSD, with prebuilt packages for Raspberry Pi.

D++ is a lightweight, efficient C++ library for interacting with the Discord API (v10). It is designed for high scalability and a small memory footprint, even when caching large amounts of data.

Key Features:

• Discord API v10 Support: Full coverage of the API specification.
• Efficient Caching: Optimized caching for guilds, channels, guild members, roles, and users.
• Sharding & Clustering: Supports multiple shards within a single process (manual or automatic).
• High Throughput: Optimized ETF (Erlang Term Format) support for fast websocket communication.
• Slash Commands: Full support for interactions and slash commands.
• Voice Support: Ability to send and receive audio with DAVE End-To-End Encryption.
• Cross-Platform: Stable support for Linux, Windows, macOS, FreeBSD, OpenBSD, and Raspberry Pi.

On OpenBSD, once the library is installed to /usr/local, you should use CMake to manage your project and link to the library.

Important Limitation: Direct linking via clang++ or g++ is currently broken on OpenBSD. You must use CMake for your build system to ensure correct integration.

When checking if one role is higher than another in the hierarchy, do not compare position numbers directly, as multiple roles can share the same position. Instead, use the comparison operators (<, >) directly on dpp::role objects. This is the recommended way to ensure correct hierarchy logic.

// Example: Ensuring target_role is not higher than issuer_role
if (target_role > issuer_role) {
    event.reply("You can't ban someone whose role is higher than yours!");
    return;
}

Discord imposes connection limits: you can only connect to one shard every five seconds unless your bot is in at least 150,000 guilds.

Once a bot reaches the 150,000 guild threshold, Discord allows higher concurrency. D++ automatically handles this by attempting to connect 16 shards in parallel, waiting for them to connect, and then proceeding to the next batch of 16. You do not need to manually configure large bot sharding or connection concurrency; the library handles this automatically.

When contributing to the D++ library, use snake_case for all class, variable/member, function, and method names to match the C++ standard library style.

For enums, use snake_case for both the enum name and its values. Since enum class is not used, you must prefix enum values with a unique prefix to avoid collisions and ensure they are grouped correctly in IDEs (e.g., ll_debug, ll_trace).

When using external dependencies (like opus or libssl):

• Do not include their headers or reference their types directly in D++ header files. This prevents them from becoming public dependencies.
• Instead, use opaque classes or forward-declare the structs.

Avoid platform-specific code (e.g., Windows-only functions or direct libc calls). If platform-specific logic is required, wrap it in #ifdef _WIN32 (or appropriate macros) and provide a cross-platform alternative.

The thread pool is responsible for executing all callbacks and completed coroutines. You can control the size of this pool via the dpp::cluster constructor.

• Default Size: Half of the system's concurrency value.
• Minimum Size: 4 threads.
• Mechanism: Uses a priority queue to manage tasks.