Skip to main content
FFXIVClientStructs provides low-level access to Final Fantasy XIV’s game client through C# interop structures. The API is organized into several major namespaces that mirror the game’s internal architecture.

​
Major Namespaces

The API is divided into five primary namespaces, each serving a distinct purpose:

​
FFXIV

The main namespace containing all game-specific client structures. This is the most commonly used namespace and includes:
  • Client - Core game client systems (UI, Game logic, Graphics, Network, etc.)
  • Component - Reusable components (GUI, Excel data, Text processing)
  • Common - Shared utilities and data structures
  • Application - Application-level networking
  • Shader - Shader parameters and rendering data
Most plugin development will focus on structures within the FFXIV namespace.

​
STD

C++ Standard Library implementations for interop with native C++ containers:
  • StdVector, StdList, StdDeque - Sequential containers
  • StdMap, StdSet - Associative containers
  • StdString, StdWString - String types
  • StdPair - Pair container
  • Helper - Container operation helpers
These types enable safe interaction with STL containers used throughout the game client.

​
Havok

Havok Physics and Animation engine structures:
  • Animation - Animation playback, rigging, skeletal animation
  • Common.Base - Core types (vectors, matrices, quaternions, AABB)
  • Common.Serialize - Serialization utilities
Used primarily for character animation and physics simulation.

​
SQEX

Square Enix proprietary engine components:
  • CDev.Engine.Sd - Sound and audio systems
Currently limited to sound-related functionality.

​
Interop

Interoperability utilities for working with native memory:
  • Pointer - Safe pointer wrapper
  • SpanExtensions - Extensions for memory spans
These provide safe abstractions over raw pointers and memory operations.

​
Finding Specific Classes

​
By Game System

If you’re looking for structures related to a specific game feature:
  • UI/Addons → FFXIV.Client.UI and FFXIV.Component.GUI
  • Character/Player Data → FFXIV.Client.Game.Character and FFXIV.Client.Game.Object
  • Inventory/Items → FFXIV.Client.Game
  • Network Packets → FFXIV.Application.Network
  • Graphics/Rendering → FFXIV.Client.Graphics
  • Excel Data → FFXIV.Component.Excel

​
By Name Pattern

Classes follow consistent naming conventions:
  • Addon[Name] - UI windows and overlays (e.g., AddonActionBar, AddonInventory)
  • Atk[Type] - UI toolkit components (e.g., AtkUnitBase, AtkComponentButton)
  • [System]Manager - System managers (e.g., ActionManager, InventoryManager)
  • [Type]Array - Data arrays and collections

​
Using the Generated Documentation

The API reference is generated from source code with:
  • Complete inheritance hierarchies
  • Field offsets and memory layouts
  • Method signatures and parameters
  • XML documentation comments
  • Struct sizes and alignment
Each class page shows its namespace path, base classes, and all public members. The API reference is organized hierarchically: 
FFXIVClientStructs/
├── FFXIV/
│   ├── Client/
│   │   ├── UI/          (UI addons and windows)
│   │   ├── Game/        (Game logic and state)
│   │   ├── Graphics/    (Rendering and scene)
│   │   ├── System/      (Core client systems)
│   │   └── Network/     (Client networking)
│   ├── Component/
│   │   ├── GUI/         (UI toolkit)
│   │   ├── Excel/       (Game data)
│   │   └── Text/        (Text processing)
│   ├── Common/          (Shared utilities)
│   ├── Application/     (App-level systems)
│   └── Shader/          (Shader data)
├── STD/                 (C++ containers)
├── Havok/               (Havok engine)
├── SQEX/                (Square Enix engine)
└── Interop/             (Memory utilities)

​
Common Patterns

​
Accessing Singletons

Many game systems are singletons accessible via static methods: 
var actionManager = ActionManager.Instance();
var uiModule = UIModule.Instance();

​
Working with Addons

UI addons inherit from AtkUnitBase: 
var addon = (AddonInventory*)gameGui->GetAddonByName("Inventory");
if (addon != null && addon->AtkUnitBase.IsVisible) {
    // Work with addon
}

​
Using STD Containers

STD containers provide safe enumeration: 
foreach (var item in myStdVector.AsSpan()) {
    // Process item
}

​
Next Steps

​
Additional Resources

Build docs developers (and LLMs) love

Get started for freeTalk to us