When investing in photonics simulation software like Ansys Lumerical FDTD, understanding the licensing models is as important as understanding the physics. The right license setup can mean the difference between a quick overnight simulation or a week-long bottleneck. In this article, we’ll break down Lumerical FDTD’s licensing options in plain terms – from GUI design seats and solver engines (Standard vs. Enterprise) to how high-performance computing (HPC), GPUs, and cloud “burst” licenses work. Whether you’re a simulation engineer pushing the limits of GPU acceleration or an IT manager planning for on-prem vs. cloud deployment, this guide will help you choose the optimal licensing strategy for your needs.
GUI vs. Solver Licenses – Design Seats and Engine Seats
Ansys Lumerical FDTD uses a two-part licensing system: one license for the graphical user interface (GUI) – often called a design seat – and another for the solver engine that runs the simulations[optics.ansys.com]. The GUI license allows an engineer to open and use the Lumerical FDTD design environment (building structures, setting up simulations, visualizing results). The solver license (sometimes called a “solve” license or engine seat) is required when you actually run an FDTD simulation on a compute resource. In practice, when you purchase Lumerical FDTD you receive both components, but they are counted separately in the license manager:
- GUI (Design) License: A user-host-display (UHD) counted license tied to a user & machine. One GUI license lets one user open any number of FDTD instances on one machine (one “display”) concurrently. If you have multiple engineers who need to use Lumerical’s interface simultaneously, you’ll need multiple GUI licenses (or an Enterprise prep/post license for extra seats). The GUI license has no limit on cores because it’s just for the design environment – it doesn’t perform heavy computation.
- Solver (Engine) License: A job-counted license that governs simulation runs. Each concurrent simulation job will consume a solver license (unless special sharing applies, discussed later). Solver licenses have limits on how much compute they can use per job – defined in terms of CPU cores or GPU streaming multiprocessors (SMs). These limits differ for Standard vs. Enterprise licenses, which we’ll detail next.
In summary, the GUI license is your “seat” to drive the software, while the solver license is the horsepower under the hood. A licensing server (FlexLM-based) typically floats these licenses on your network so multiple users or jobs can draw from a shared pool as needed[optics.ansys.com]. With the basics covered, let’s look at the two flavors of solver licensing available and how they scale with computing power.
Standard vs. Enterprise Solver Licenses
Ansys Lumerical FDTD is offered in two main license models: Standard (sometimes called Business) and Enterprise. Both include the same physics and modeling capabilities; the difference lies in how they handle computational scaling and HPC. Here’s a side-by-side comparison of their key characteristics:
|
License Model |
Base Compute Capacity |
HPC Expansion |
GPU Acceleration |
Typical Use Case |
|
Standard FDTD (Business) |
Up to 32 CPU cores per simulation; beyond 32 cores requires additional Standard license(s). |
Not compatible with Ansys HPC Pack licenses. Scaling beyond 32 cores achieved by stacking multiple Standard solver licenses (each adds 32-core capacity). |
Up to 16 GPU SMs (streaming multiprocessors) per simulation. More SMs also require extra solver licenses in blocks of 16 SM. For example, a job needing 20 SM required 2 Standard licenses (16 SM + 4 SM). |
Small to mid-size simulations on a single workstation or server. Ideal for companies without dedicated HPC resources – one Standard license can utilize a decent number of cores out-of-the-box. Concurrency is limited unless additional licenses are purchased. |
|
Enterprise FDTD |
Up to 4 CPU cores per simulation on the base license. Designed to work in tandem with Ansys HPC licenses for scaling to high core counts. |
Scales via Ansys HPC Packs or HPC Workgroup licenses for more cores/threads. HPC licenses act as “add-ons” that unlock additional cores beyond the 4-core base. (We’ll explain HPC packs shortly.) This model can potentially scale to hundreds or thousands of cores with enough HPC licenses. |
Up to 4 GPU SMs per simulation on the base license. Additional GPU capacity unlocked via HPC licenses, analogous to CPU core scaling. One Enterprise FDTD license together with HPC add-ons can thus run on multiple GPUs or very large GPUs. |
Large-scale and high-performance simulations, HPC clusters, and enterprise environments. Best if you need to run on many cores, multi-GPU servers, or distributed clusters. You invest in one (or a few) Enterprise solver licenses, then augment with flexible HPC tokens to scale per job or to run many jobs in parallel. |
SM (Streaming Multiprocessor): In NVIDIA GPU architecture, SMs are analogous to CPU cores for licensing purposes. Each GPU has a fixed number of SMs (e.g., NVIDIA A100 has 108 SMs). License limits refer to total SMs used.
In essence, Standard licenses give you a larger “chunk” of compute in a single license (32 cores or 16 GPU SMs) but cannot be extended with HPC add-ons, whereas Enterprise licenses start with a small chunk (4 cores/4 SM) but are expandable to virtually any size via HPC licensing. Enterprise is the route to go for serious HPC or cloud scaling, while Standard is simpler and might be more cost-effective for modest parallel needs.
Example: If you ran the same simulation on a 64-core machine, a Standard license alone wouldn’t suffice (32-core limit per license) – you’d need two Standard licenses to use all 64 cores. With an Enterprise license, you’d use your one solver license + HPC licenses to extend from 4 to 64 cores. We’ll illustrate how HPC licensing works next.
HPC Licensing and GPU Scaling Explained
Once you exceed the base core count or SM count included with your solver license, Ansys HPC licenses come into play (for Enterprise licenses). HPC licenses are separate add-ons (either “HPC Pack” or “HPC Workgroup” increments) that allow you to utilize more CPU cores or GPU SMs for a simulation without requiring additional full solver licenses. This flexible scheme is a major benefit of the Enterprise model. Let’s break it down:
Fig1: HPC Pack licensing enables exponential core scaling for Enterprise licenses. Each HPC Pack roughly quadruples the usable core count (e.g., 1 Pack ≈ 12 cores total, 2 Packs ≈ 36 cores, 3 Packs ≈ 132 cores, etc.), on top of the base 4-core per solver seat. The chart above shows how adding HPC packs increases parallel capacity per simulation.
- Enterprise + HPC (CPU example): One Enterprise FDTD license covers 4 CPU cores. If you want to run on, say, 32 cores, you can purchase HPC licenses to cover the additional 28 cores beyond the base 4. In practice this could be either 28 HPC Workgroup licenses (each workgroup “increment” typically unlocks 1 extra core) or 2 HPC Pack licenses (each pack is a bundle that unlocks a larger chunk of cores). Ansys provides an HPC License [Calculator tool] to determine exactly how many packs or increments are needed for a given core count. For a 128-core run across 4 nodes (32 cores each), you’d still use 1 Enterprise license and augment it with HPC: e.g. 124 HPC increments or 3 HPC Pack licenses in that case.
- Enterprise + HPC (GPU example): Similarly, one Enterprise license covers 4 SMs on GPUs. Modern datacenter GPUs have 80–140 SMs, so HPC licenses are essential to utilize a full high-end GPU. For example, an NVIDIA A100 (80 GB) has 108 SMs; with Enterprise, the first 4 SMs are “free”, and the remaining 104 SMs would be enabled by HPC tokens. The model is analogous to CPU: each additional SM beyond the base counts against your HPC licenses (likely 1 HPC increment per SM). The license manager will automatically check out the needed number of HPC tokens when you launch the job. Crucially, the license system looks at whichever resource count – CPU cores or GPU SMs – demands more licenses, and uses that as the requirement. (So if you use both CPU and GPU, you’re essentially charged for the larger of the two demands, not both at once.)
- Standard license scaling: By contrast, Standard licenses do not use HPC tokens. If you exceed the Standard license’s built-in limits (32 cores or 16 SMs per job), you must consume additional Standard solver licenses. For instance, running a job on 64 cores would consume 2 Standard licenses (each covering 32 cores). Running on a GPU with 64 SMs would require 4 Standard licenses (16 SM each) to cover all SMs, since one Standard license covers the first 16 SMs, and 48 SMs remain – that’s 3 more licenses needed (in general, SMs are counted in blocks of 16 for Standard). This can become limiting or expensive if you frequently use large resources, since you’d need a separate solver license for every block of 16 SM or 32 cores.
In practice, Enterprise + HPC is more efficient for heavy scaling. You buy one Enterprise FDTD license, then add HPC capacity as needed rather than buying multiple full licenses. Standard is more static – great up to its limit, but scaling further means buying whole additional licenses (which also each come with another GUI seat that you might not need).
Concrete examples:
- Single GPU job: Suppose you want to run FDTD on one NVIDIA RTX 6000 Ada GPU (which has ~142 SMs). A Standard license covers 16 SMs, so you’d need 9 Standard licenses to use all 142 SMs (!). An Enterprise license would cover 4 SMs, then you’d apply HPC tokens for the remaining 138 SMs – for example, 1 HPC Pack allows ~112 SM and then a few more HPC increments for the rest. Clearly Enterprise + HPC is the practical choice for such a large GPU – with Standard, it’s not even feasible for one job to consume 9 licenses in most cases.
- Multi-core CPU job: Running a simulation on 48 CPU cores: Standard allows 32 cores per license, so it would use 2 Standard licenses (32 + 16 out of the second license). Enterprise would use 1 license + HPC for the extra 44 cores beyond the base 4. That could be achieved with 44 HPC workgroup tokens, or more economically, 2 HPC Packs (which cover up to 36 cores) plus some increments for the remainderoptics.ansys.com.
The key takeaway is that Standard licenses have higher standalone capacity, while Enterprise licenses combined with HPC tokens offer virtually unlimited capacity. If you plan on leveraging multi-GPU computing or large clusters, Enterprise is the way to go. Next, we’ll discuss how these licenses work when running many simulations at once (sweeps) and how they’re handled in cluster or cloud scenarios.