1 Introduction to Apollo
- 1.1 Legacy Limitations
2 Apollo: A New Paradigm
- 2.1 Fast FDTD Solver
- 2.2 Live Viewer
- 2.3 FP64 Accuracy
- 2.4 GDS & STL Import
- 2.5 H5 Output
3 Setting up Apollo
4 Supported Flows
- 4.1 Direct through Config File
  - 4.1.1 File Structure
  - 4.1.2 Simulation Parameters
  - 4.1.3 PML Parameters
  - 4.1.4 Geometry Parameters
    - 4.1.4.1 Primitive Shapes
    - 4.1.4.2 Common Fields (All Primitive Shapes)
      - 4.1.4.2.1 Circle Only
      - 4.1.4.2.2 Rectangle Only
    - 4.1.4.3 GDSII Layouts
    - 4.1.4.4 STL Layouts
  - 4.1.5 Full Example
- 4.2 Python Scripting
- 4.3 Web Interface

Introduction to Apollo

Designing a wide variety of RF chips, metalenses, metamaterials, and electronics requires significant electromagnetic wave simulation (EM sim) capabilities. Historically, EM sim performance has been limited by the architecture of legacy compute architectures.

For example, when designing photonics circuits, certain design rules are provided by the foundry. A photonics circuit design is created using those rules. The design must be verified and simulated before entering production at the foundry (whether through shuttle or full mask). If the simulations take a long time, are inaccurate, or don’t output the full useful data, then the photonics circuit could have issues operating as designed.

FDTD is a method used by many EM sim tools to produce EM simulations.

Legacy Limitations

On CPUs, high FP64 performance, access to low-latency large memory pool, direct network and storage interfaces enabled decent performance with minimal tradeoffs. Meep, for example, takes almost 1 hour to perform a 600x600x600 simulation over 100 timesteps on a server with 192 Amd Epyc CPU cores.

On GPUs, potentially higher FP32/FP64 performance trades off with extremely limited memory capacity, complex host-device programming model, far away network and storage interfaces. FDTD3D, for example, supports Cuda GPUs.

FDTD solvers like Ansys Lumerical that support both CPU and GPU backends typically limit the functionality of the GPU backend. Basic functionality like per-timestep outputs and movie monitors are not present. This drives users back to CPU solvers.

The table below compares hardware support for various popular FDTD solvers:

FDTD Solver	CPU	GPU

FDTD Solver	CPU	GPU
Meep	Yes	No
Lumerical	Yes	Yes (with limitations)*
Tidy3D	No	Yes (only as a SaaS)
Feko	Yes	Yes (single GPU only)
FDTDX	Yes	Yes
FDTD3D	Yes	Yes (with limitations)**

* In addition to many limitations when using GPUs, Lumerical’s insane pricing for a H100/H200/B100/B200 GPU is more than the cost of the GPU.

** Disassembling Cuda code from FDTD3D shows FP64 computations are not always used, leading to accuracy limitations.

Apollo: A New Paradigm

Apollo is an extremely fast FDTD solver. Based on various benchmarks, we believe Apollo to be the fastest FDTD solver across CPUs and legacy GPUs. Apollo reduces the time spent in simulation, accelerating the development of RF chips, metalenses, metamaterials, and electronics.

The table below compares features across various popular FDTD solvers:

FDTD Solver	Cost	Backends	GDS & STL Import	Live Viewer	Precision

FDTD Solver	Cost	Backends	GDS & STL Import	Live Viewer	Precision
	$^*	Bolt Zeus GPU	Yes	Yes	FP32 mode FP64 mode
Meep	free & OSS	CPU & mpi	Yes	No	Mixed (partial FP64)^**
Lumerical	$$$	CPU & Cuda	Yes	No	Mixed (partial FP64)^**
Tidy3D	$$	SaaS (Cuda)	Yes	No	Mixed (partial FP64)^**
FDTD3D	free & OSS	CPU & Cuda	No	No	Mixed (partial FP64)^**

^* For pricing on Zeus and Apollo, please contact us.
^** There is no guarantee that the computations are performed at FP64 or FP32.

Fast FDTD Solver

Apollo achieves leading performance with extreme co-design of hardware and software. Unlike all other FDTD solvers, Apollo is not limited by the underlying architecture of the CPU or GPU. Bolt controls the hardware architecture and implementation of the software.

Many of the features described below are only made possible by co-designing the hardware and software together, something which no other FDTD solver developer has achieved.

More detailed performance benchmarks coming soon!

Live Viewer

Apollo integrates an industry-first live viewer, enabling users to immediately view the output of the simulation as it progresses. This can save costs on compute resources and valuable time. There are many cases where being able to quickly visualize the performance of the design can improve usability:

As an educational tool to introduce electromagnetism
Shifting left the visually intuitive feedback to during the simulation vs. after
Enabling the end user to easily stop a simulation that is not producing the intended or desired results

Apollo live viewer; in this demo showing the electric field every 10 computed timesteps

Other FDTD solvers like Meep, Lumerical, and Tidy3D require the user to post-process outputs and generate videos for visualization. As the other solvers require the simulation to complete prior to generating the visualization, the value of the visualization decreases.

The video below shows a demo of Apollo, highlighting the live viewer:

https://youtu.be/M2uGJa6u030?si=BbkFKFGadR2VwSqB

Apollo’s live viewer does not decrease the performance of the simulation, so there’s no downside to immediately visualizing the output as the simulation runs. We have already been able to achieve interactive visualizations at over 10 fps (visualizing every 10 timesteps) when the simulation space is approximately 400x400 cells, and 1 fps at 1200x1200 cells, while still outputting Ez for every timestep.

FP64 Accuracy

Apollo is composed of proprietary FP64 math modules that fully comply with the IEEE 754 standard. These modules are locked to FP64 precision at the hardware-level ensuring deterministic and consistent accuracy across all simulations. This means the user never has to worry about hidden precision losses or inconsistent result due to mixed-mode computation.

In contrast, many legacy GPU-based FDTD solutions dynamically switch between different floating-point precisions throughout the computational pipeline leaving users questioning how much numerical error was introduced. In addition, the compiler may decide to optimize parts of the computational pipeline, further reducing accuracy and limiting repeatability across different CPU and legacy GPU backends.

GDS & STL Import

Apollo supports direct importing of industry standard GDS and STL file formats. This allows users to reuse their existing design assets.

To ensure compatibility with the current 2D version of Apollo there are a few limitations to consider:

For GDS files, all geometry must reside within a single z-plane.
- 3D stacked structures are not supported in this early access release.
STL files, typically used for 3D structures, can also be ingested.
- Users simply specify a z-plane of interest, and Apollo will extract a 2D cross-sectional slice at that plane to run simulations.

H5 Output

Coming soon!

Setting up Apollo

Coming soon!

Supported Flows

Direct through Config File

Apollo is configured using a config.json file, allowing users to control simulation settings, source characteristic, boundary conditions, and geometry.

File Structure

{
  "SimulationParameters": { ... },
  "PMLParameters": { ... },
  "GeomParameters": { ... },
}

Simulation Parameters

Defines the core settings for the simulation grid, source configuration, and runtime behavior.

Parameter	Type	Description	Default Value

Parameter	Type	Description	Default Value
`x_cells_total`	`uint32_t`	Number of grid cells in X direction	32
`y_cells_total`	`uint32_t`	Number of grid cells in Y direction	32
`timesteps_total`	`uint32_t`	Total number of simulation time steps	0
`ddx`	`float`	Spatial cells size	1.0
`source`	`string`	Source type (`"gaussian point"`, `”sinusoid point”`)	`”gaussian point”`
`plane_wave`	`bool`	Enables plane wave source	`false`
`x_src_loc`	`uint32_t`	X coordinate of the source	1
`y_src_loc`	`uint32_t`	Y coordinate of the source	1
`freq_in`	`float`	Sinusoid source frequency (Hz)	1.0
`FFT_on`	`bool`	Enable FFT analysis	`false`
`freqs_of_interest`	`float[]`	List of target frequencies (Hz)	[1.0]
`num_of_freqs`	`uint32_t`	Number of frequencies to analyze	auto-calculated
`arg`	`float[]`	Angular frequencies (rad/s)	[1.0]
`spread`	`int`	Spread of gaussian source	1
`t0`	`int`	Time offset for gaussian source	1
`slot`	`int`	PCIe slot number that the FPGA card is mounted	0
`animation_speed`	`float`	The interval between generated frames	1
`vmin`, `vmax`	`float`	Visualization scale limits	[-1, 1]

PML Parameters

Controls the configuration of the Perfectly Matched Layer (PML) boundary, used to absorb outgoing waves.

Parameter	Type	Description	Default Value

Parameter	Type	Description	Default Value
`growth_factor`	`double`	Polynomial growth rate for PML	3.0
`cond_factor`	`float`	PML conductivity scaling factor	0.33
`width`	`uint32_t`	PML width in cells	12

Geometry Parameters

An array of geometric objects that define what is physically in the simulation space. Three types of geometry are currently supported:

Primitive Shapes: ”circle” or ”rectangle”
Imported GDSII layouts: ”GDSII”

Primitive Shapes

Common Fields (All Primitive Shapes)

Parameter	Type	Description	Default Value

Parameter	Type	Description	Default Value
`shape`	`string`	`”circle”` or `”rectangle”`	`”circle”`
`x_loc`, `y_loc`, `z_loc`	`int`	Center location of shape	[1, 1, 1]
`permittivity`	`float`	Relative permittivity	1.0
`conductivity`	`float`	Relative conductivity	0.0

Circle Only

Parameter	Type	Description	Default Value

Parameter	Type	Description	Default Value
`radius`	`float`	Radius of the circle	1.0

Rectangle Only

Parameter	Type	Description	Default Value

Parameter	Type	Description	Default Value
`x_len`, `y_len`	`int`	Length in X and Y directions of the rectangle	1
`angle`	`float`	Rotation angle in degrees	1.0

GDSII Layouts

Parameter	Type	Description	Default Value

Parameter	Type	Description	Default Value
`shape`	`string`	Must be `”GDSII”`	`”circle”`
`file_path`	`string`	Path to the `.gds` file	`"../../bolt_apollo_loaders/examples/assets/coupler.gds"`
`permittivity`	`float`	Relative permittivity	1.0
`conductivity`	`float`	Relative conductivity	0.0

STL Layouts

Coming soon!

Full Example

{
  "SimulationParameters": {
    "x_cells_total": 400,
    "y_cells_total": 400,
    "timesteps_total": 2000,
    "ddx": 0.01,
    "source": "sinusoid point",
    "x_src_loc": 19,
    "y_src_loc": 74,
    "freq_in": 375000000.0,
    "FFT_on": false,
    "animation_speed": 10,
    "vmin": -0.08,
    "vmax": 0.08
  },
  "PMLParameters": {
    "growth_factor": 3,
    "cond_factor": 0.33,
    "width": 10
  },
  "GeomParameters": [
    {
      "shape": "circle",
      "x_loc": 20,
      "y_loc": 20,
      "radius": 3,
      "permittivity": 30,
      "conductivity": 0.3
    },
    {
      "shape": "rectangle",
      "x_loc": 30,
      "y_loc": 80,
      "x_len": 10,
      "y_len": 10,
      "angle": 45,
      "permittivity": 30,
      "conductivity": 0.3
    },
    {
      "shape": "GDSII",
      "file_path": "../../bolt_apollo_loaders/examples/assets/coupler.gds",
      "permittivity": 11.7,
      "conductivity": 0
    }
  ]
}

Python Scripting

Coming soon!

Web Interface

Coming soon!