The Complete Guide to CATIA Customization: From CAA to Automation

Introduction

Dassault Systèmes’ CATIA is one of the most widely used high-end CAD/CAE/CAM platforms in aerospace, automotive, marine, and high-end manufacturing. The Airbus A380, Boeing 787, multiple Tesla and BMW models — all were designed with CATIA at their core.

But the barrier to CATIA customization is a notch higher than NX, Creo, or SolidWorks. Not only is the technical stack more layered, but Dassault’s licensing of the CAA RADE SDK is restrictive — many teams cannot obtain the full SDK even with budget in hand.

This article systematically walks through the four mainstream technical tracks for CATIA customization, helping you make the right choice in real engineering projects.

The Four Tracks of CATIA Customization

CATIA exposes its extensibility in roughly four layers, ranked here from highest capability ceiling and licensing barrier to lowest:

Track	Language	Licensing	Capability Ceiling	Typical Scenarios
CAA RADE	C++	Requires RADE license + CAA Partner agreement	Virtually unlimited — extend UI, add Workbenches, define custom features	Industry templates, enterprise Workbenches, commercial plugins
Automation Object	VBA / VB.NET / VBScript / Python (win32com)	Base CATIA license is enough	Limited to what the Automation API exposes	Batch processing, data migration, drawing automation
Knowledgeware / EKL	EKL script	Requires KW Advisor / Expert module license	Parameter-driven, rule-checked, batch generation	Family parts, parametric skeletons, compliance checks
CATScript / CATVBA Macros	CATVBA / CATScript	Base CATIA license	Equivalent to Automation, weaker dev experience	Record + tweak, throwaway scripts

Let’s go through each.

1. CAA RADE: The Capability Ceiling

CAA (Component Application Architecture) is the underlying component framework of CATIA itself — virtually every CATIA module is written in CAA. RADE (Rapid Application Development Environment) is the companion tooling: the mkmk build system, CodeRADE Visual Studio integration, and an extensive library of SDK headers.

CAA’s core idea is the CATIA component model, layered on top of COM:

• Components are made of Implementations
• Each Implementation realizes one or more Interfaces (IIDs)
• Components convert between IIDs via QueryInterface

A typical CAA snippet, getting the root Product of a document and listing its children:

#include "CATIAProduct.h"
#include "CATIDocRoots.h"
#include "CATListPtrCATBaseUnknown.h"

HRESULT EnumerateChildren(CATDocument* pDoc) {
    CATIDocRoots* piDocRoots = NULL;
    HRESULT rc = pDoc->QueryInterface(IID_CATIDocRoots, (void**)&piDocRoots);
    if (FAILED(rc) || !piDocRoots) return E_FAIL;

    CATListPtrCATBaseUnknown* pRootList = piDocRoots->GiveDocRoots();
    if (!pRootList || pRootList->Size() == 0) {
        piDocRoots->Release();
        return E_FAIL;
    }

    CATBaseUnknown* pRoot = (*pRootList)[1];  // CAA list indices start at 1
    CATIAProduct* piRootProduct = NULL;
    rc = pRoot->QueryInterface(IID_CATIAProduct, (void**)&piRootProduct);
    if (SUCCEEDED(rc) && piRootProduct) {
        CATIAProducts* piChildren = NULL;
        piRootProduct->get_Products(piChildren);
        long count = 0;
        piChildren->get_Count(count);
        // ... iterate piChildren ...
        piChildren->Release();
        piRootProduct->Release();
    }

    delete pRootList;
    piDocRoots->Release();
    return rc;
}

CAA’s ceiling is high: you can add a complete Workbench, define new modeling features, customize drawing annotation rules, and even replace some of CATIA’s own UI behavior. The price:

• Licensing barrier: CAA RADE is not openly sold. You must apply to the Dassault CAA Partner program and sign an NDA before you receive the SDK.
• Learning curve: CAA exposes tens of thousands of interfaces; mastery requires close reading of the CAA Encyclopedia and Live Documentation.
• Build complexity: mkmk is not CMake. It has its own dependency model and platform abstraction; porting to modern CI takes effort.
• Version coupling: CAA interfaces have breaking changes across major CATIA releases; every upgrade means a recompile.

When to choose CAA: industry templates, commercial plugins, deep UI customization, or when the customer has already invested in the CAA Partner relationship. Otherwise, it shouldn’t be your default.

2. Automation Object: The Most Practical Extension

CATIA exposes a COM-based automation object model in-process, starting from Application and reaching almost everything “the user can do in the UI.” This is where most customization projects live, since it requires only a base CATIA license.

Minimal runnable example (Python via pywin32):

import win32com.client

# Connect to a running CATIA instance
catia = win32com.client.Dispatch("CATIA.Application")
catia.Visible = True

# Create a new Part
part_doc = catia.Documents.Add("Part")
part = part_doc.Part

# Add a sketch on origin
sketches = part.Bodies.Item(1).Sketches
ref_plane = part.OriginElements.PlaneXY
sketch = sketches.Add(ref_plane)

# Edit the sketch
factory_2d = sketch.OpenEdition()
factory_2d.CreateLine(0, 0, 100, 0)
factory_2d.CreateLine(100, 0, 100, 50)
factory_2d.CreateLine(100, 50, 0, 50)
factory_2d.CreateLine(0, 50, 0, 0)
sketch.CloseEdition()

# Pad the sketch
shape_factory = part.ShapeFactory
pad = shape_factory.AddNewPad(sketch, 20)
part.Update()

# Save
part_doc.SaveAs(r"D:\catia\demo.CATPart")

VBA macro code is nearly identical — the difference is that VBA runs inside CATIA’s process (Tools → Macro), while Python uses win32com across processes.

Suitable for:

• Batch processing — read parameters from Excel, generate hundreds of part variants in a loop
• Data migration — extract BOMs, properties, assembly trees into ERP/PDM
• Drawing automation — batch view generation, batch PDF export
• Side-by-side comparison with Creo automation

Limits:

• Cannot extend the UI (no new Toolbar or Workbench)
• Cannot define new feature types
• Some advanced modules (surfaces, electrical, piping) have less complete Automation coverage
• Automation calls are not cheap; large assemblies (10k+ parts) require careful loop design

3. Knowledgeware / EKL: The Heaviest Hammer for Parametrics

Knowledgeware (KW) is CATIA’s built-in knowledge engineering layer: parameters, formulas, rules, checks, and Knowledge Patterns. EKL (Enterprise Knowledge Language) is the script language used by KW — a mix of BASIC and SQL syntax.

KW’s biggest strength is native integration with modeling itself — a Rule lives directly on the Part, recomputes on reopen, and needs no external host program.

A trivial EKL Rule that auto-sets bolt count on a flange:

let nBolts(Integer)
nBolts = round(`Parameters\OuterDiameter` / 50)
`Parameters\BoltCount` = nBolts

Knowledgeware deserves its own deep-dive — see CATIA Knowledgeware and EKL Parametric Design.

4. CATScript / CATVBA Macros: Record-as-Code

CATIA’s built-in macro recorder (Tools → Macro → Start Recording) translates mouse actions into CATScript or CATVBA. Easiest entry point, but not recommended as the main development path:

• Recordings include redundant calls (UI cancels, view switches all get recorded)
• CATScript is a BASIC dialect with no classes/inheritance — weak engineering ergonomics
• Debugging is poor: no breakpoints, no step execution

Recommended use: treat the recorder as a “tool to discover API call sequences,” then translate the recorded code into proper VBA modules or Python scripts under version control.

Setting Up the Development Environment

Common Baseline

Regardless of track:

• CATIA V5 R2018 or newer (earlier releases have weaker API coverage)
• Or 3DEXPERIENCE Platform R2020x or newer (note: 3DEXPERIENCE and V5 APIs have diverged significantly — see below)
• Visual Studio 2017+ (required for CAA development)
• Use a dedicated dev box or VM so RADE installs don’t disturb production CATIA

Automation Stack

Lowest-cost setup:

CATIA V5 R2021
+ Python 3.10
+ pywin32
+ Visual Studio Code

For .NET teams:

CATIA V5 R2021
+ Visual Studio 2022 + VB.NET project
+ Add COM reference: CATIA V5 InfInterfaces

CAA RADE Stack

Once your RADE license is approved, the install typically includes:

• CAA C++ SDK (matched to your CATIA major version)
• mkmk build tools
• CodeRADE Visual Studio extension

CAA project layout is fixed (FrameworkName / IdentityCard / Module / src / LocalInterfaces). You can’t organize files freely as in a generic C++ project — a frequent source of frustration.

Source Control

Don’t put CATIA binaries (CATPart, CATProduct, CATDrawing) directly into Git — they bloat the repo fast. Recommended:

• Binaries go in Git LFS or an external PDM
• Repo only stores source code (VBA / Python / EKL / CAA C++) and text-format metadata
• Use ENOVIA / 3DEXPERIENCE for CAD data; use Git for scripts

Typical Scenarios and Track Selection

Scenario	Recommended Track	Reason
Batch parametric modeling (family-table style)	Knowledgeware + Automation	KW for rules, Automation as the batch driver
Drawing automation	Automation	API coverage is strong; Drawing module Automation is mature
Custom Workbench / Toolbar	CAA RADE	Automation cannot do this
Standard part library	Knowledge Pattern + Power Copy	Native modeling integration; shareable via ENOVIA
Migrating data into ERP	Automation	Cross-process integration is straightforward
Compliance checks (wall thickness, fillet limits)	Knowledgeware Check	Triggers on save/update automatically
Model comparison / diffing	CAA RADE or Automation	Simple diffs via Automation; deep diffs need CAA
Bidirectional PLM sync	CAA RADE + ENOVIA SOA	Requires ENOVIA SOA endpoints

ENOVIA / 3DEXPERIENCE Integration

ENOVIA is Dassault’s PLM platform. In V5 the integration with CATIA goes through VPM Navigator or CATIA-ENOVIA Workplace; on 3DEXPERIENCE it is unified, with CATIA running directly as an App on the platform.

Available integration extension points:

• ENOVIA SOA: SOA-style Web Services for Java / .NET, suitable for two-way external sync
• 3DEXPERIENCE Web Services: REST APIs authenticated via 3DPassport
• MQL/TCL: ENOVIA’s kernel scripting language, for server-side customization
• Knowledge Pattern with PLM References: KW reads ENOVIA references directly

The ENOVIA + CATIA relationship parallels Teamcenter + NX — same-vendor PLM with same-vendor CAD, native cooperation but completely incompatible APIs.

Common Pitfalls and How to Avoid Them

1. CATIA “Hangs” / Automation Stalls

CATIA’s Automation calls are single-threaded synchronous. Tight loops freeze the UI. Optimization:

• Cache the Application reference outside the loop; don’t Dispatch repeatedly
• For bulk Part edits, defer every Update() until after the loop and call it once at the end. CATIA’s update cost grows roughly with features × dependent_features, so per-feature updates are the worst case.
• Toggle visual refresh off during pure geometry/parameter passes: catia.RefreshDisplay = False before the loop, restore True after — typically saves 30%–50% on long batches
• Avoid frequent Workbench switching

2. Bitness Mismatch with Office

CATIA V5 has shipped a 64-bit build since R19, and from V5-6R2014 onward Dassault maintains only the 64-bit release. If a customer site is still on a legacy 32-bit V5, you must use a 32-bit Python and a 32-bit Office to bridge Automation. In practice: confirm the CATIA bitness in the splash screen or About dialog, then match it to the Python interpreter (python -c "import struct; print(struct.calcsize('P')*8)") and Excel install. A bitness mismatch fails immediately at Dispatch("CATIA.Application") with class not registered.

3. Non-ASCII Paths and Spaces

SaveAs / Open are unstable with non-ASCII paths. Standardize on plain ASCII paths, or use Win32 short-path conversion.

4. License Check Timing

Some APIs (e.g. KnowledgewareToolbox) require the corresponding KW license. If only some team members have KW, scripts should try ... catch and surface a friendly error rather than crash.

5. 3DEXPERIENCE vs V5 API Differences

Don’t assume V5 code “just runs” on 3DEXPERIENCE. Differences:

• Storage: V5 is files; 3DX is database references (PLM Reference)
• Publish objects: 3DX introduces Configuration / Effectivity, with more complex semantics
• Some Automation interfaces are deprecated; others have changed signatures

PoC the boundaries first, then choose between adapting Automation or porting to CAA.

6. Legal Boundaries of the CAA Partner Agreement

The CAA SDK is NDA-protected. Modules built on top default to belonging to the customer or are bound by the agreement terms. In outsourced projects clarify ownership, public release rights, and Dassault certification requirements (CAA V5 Approved badge).

Summary

CATIA customization is a more vertical world than NX/Creo/SolidWorks — the ceiling is high (CAA RADE can do almost anything), but so is the entry barrier. For most enterprise users, Automation Object + Knowledgeware covers 80% of needs. CAA RADE is the high ground reserved for teams with commercial-plugin ambitions or industry-template strategies.

Further reading:

• CATIA Knowledgeware and EKL Parametric Design — the deep-dive companion
• The Complete Guide to NX Customization — same-tier comparison
• Creo Parametric Design Automation — mid-range CAD parametrics
• SolidWorks Customization Guide — Dassault sibling

If your team is evaluating CATIA customization tracks, talk to Qingdao Chenshi — we have years of practice in aerospace and high-end equipment.