LaserCAD—A Novel Parametric, Python-Based Optical Design Software

Abstract

In this article, we present LaserCAD, an open-source, script-based software toolkit for the design and visualization of optical setups based on parametric ray tracing. Unlike conventional commercial tools, which focus on complex lens optimization and offer dense GUIs with extensive parameters, LaserCAD is tailored for fast, intuitive modeling of laser beam paths and opto-mechanical assemblies with minimal setup overhead. Written in Python, it allows users to describe optical systems in a language close to geometrical optics, using simple commands with sensible defaults for most parameters. Optical elements can be automatically positioned including the required mounts. As a graphical backend, FreeCAD renders 3D models of all components for interactive visualization and post-processing. LaserCAD supports integration with other simulation tools and can automate the creation of alignment aids for 3D printing. This makes it especially suitable for rapid prototyping and lab-ready designs.

1. Introduction

For the planning and the realization of sophisticated optical setups in laboratories, a large number of software tools are available to support the user during the design and the actual setup phase. For the design, the optical elements (e.g., mirrors, lenses, diffraction gratings, laser crystals, etc.) can first be placed in a virtual laboratory space (e.g., on a virtual optical breadboard) and the propagation of the light (e.g., a laser beam) is described by tracing a bundle of light rays with an appropriate wavelength spectrum mimicking the real (and laterally extended) beam along the intended path. Such a virtual setup, which should resemble the real setup as closely as possible, can help to optimize the design and to ensure that different optical elements do not interfere with the beam path where it is not intended. Problems with the setup, which can be caused by overlap or blocking of the elements and/or the beam, can be identified (and mitigated) before realizing the assembly of the optical elements in the lab. A detailed and realistic planning becomes all the more essential, the more optical elements are included in the actual setup. Such an approach helps to save time and effort during the setup phase [1,2,3,4].

Most well-established ray-tracing software tools like Zemax, Fred, Comsol or Optica [5,6,7,8] describe the propagation of realistic beams through optical setups by tracing thousands of rays through the setup, including the correct and detailed description of reflection, diffraction and wavelength-dependent refraction on complex lens surfaces or other optical elements in the setup. Such immensely powerful software tools have—among others reasons—been developed for the optimization of setups with respect to achieving minimal (and realistic) focal spot sizes of ray distributions at different positions in the setup by means of geometrical optics. Furthermore, they come with extensive graphical user interfaces (GUIs) and give the user the possibility to choose from an impressive amount of parameters and options to describe lenses and mirrors in a very precise way. While these software solutions clearly provide the user with extremely powerful tools for a large variety of classical optics design tasks, like the mitigation of aberration in multi-element camera lenses, these programs can sometimes be less suited for the visualization of laser setups before their actual construction in the lab. The very precise—but sometimes too complicated—description of optical elements and ray distributions can prove to be time-consuming and sometimes unnecessary for setups using low divergence, quasi-monochromatic beams. The programs offer a huge amount of options and parameters to set for rather simple assemblies, often without offering reasonable default values, which complicates the design where it might not be absolutely necessary. Especially opto-mechanical elements, which may play a crucial role when it comes to the actual implementation in the lab, are often not at all or only approximately included in the description with the established software tools and require precise and detailed manual positioning and selection if available. On top of that, some of these tools may come with non-negligible license costs and sometimes with no or rather intricate application programmer interfaces (APIs), which might render the quick scripting, modularization and integration into other existing simulation tools extremely time-consuming or even impossible.

For those reasons we decided to develop and implement a new software tool called LaserCAD [9], which follows a Python-script based approach [10,11,12]. The idea behind LaserCAD is that the setup is defined in a language close to geometric optics—e.g., using terms like $\mathbf{propagation}$ and $\mathbf{add}\_\mathbf{on}\_\mathbf{axis}$ —together with a list of available optical elements requiring only a minimal number of parameters to be defined, while all values come with default settings. All elements will by default be placed on the optical axis if not specified differently and come with an automatically selected and adapted mount and post assembly that can be changed easily whenever necessary. When executed in a standard Python terminal, LaserCAD produces a comprehensive text output including name, type, position and normal direction of each element and beam in the terminal for debugging. As the graphical backend, we use FreeCAD [13], an open-source 3D computer-aided design (CAD) software. When the script is executed in FreeCAD, each beam, element and mount will be rendered and shown in an interactive window for visualization and post processing.

A key feature of LaserCAD is its purely script-based design philosophy, which resembles the modular and extensible nature of Latex documents. This approach ensures that optical setups are fully defined through concise Python scripts, making the system lightweight, scalable, and easily integrable as a Python library. Despite this simplicity, the framework remains highly flexible and can be expanded with user-defined elements, analysis tools, or algorithms whenever required. A strong emphasis is placed on the inclusion of opto-mechanical components, which are incorporated by default in every setup. These can be freely customized or extended, allowing users to represent realistic laboratory conditions with minimal additional effort. The unique combination of a professional CAD backend—enabling precise mechanical design, positioning, and scalability up to finite element analysis—with a Python-based ray-tracing framework for optical simulation provides an exceptionally powerful yet accessible tool. This integration allows users to perform detailed optical and mechanical design within a single environment while maintaining full extendability toward more complex algorithms, optimization procedures, or analysis modules implemented as plug-ins.

The remainder of this paper is structured as follows: Section 2 describes all relevant classes for the program and their hierarchy. In Section 3, the used ray-tracing algorithms for geometrical optics are presented, and in Section 4 we show some use cases of LaserCAD.

2. Object Structure and Properties

LaserCAD follows an object-oriented approach with hierarchical structures. In this context, objects are instances of abstract base classes—data structures that contain specific member functions and variables, known as attributes. The terms "object" and "class" are used synonymously in the following and are written in bold with capitalization, e.g., $\mathbf{Lens}$, while their member functions and attributes are written in lowercase, e.g., $\mathbf{draw}$. Figure 1 shows a collection of the most basic objects in LaserCAD.

2.1. Geometric Object

The $\mathbf{GeomObj}$ class (see Figure 1a) contains and manages the three-dimensional properties of all objects, like the position $\mathit{p}\in {\mathbb{R}}^3$ and the right-handed, orthonormal inner coordinate system $\mathit{M}\in {\mathit{M}}_{3\times 3}$. The x-axis of this coordinate system is defined as the front surface normal $\mathit{n}$ of each element. The combination of position and axes orientation is called $\mathbf{geom}$ and can be accessed and changed via getter and setter functions, respectively, for placement and orientation. In addition, $\mathbf{GeomObj}$—which is the base object from which all other objects inherit—features the $\mathbf{draw}\_\mathbf{text}$ and $\mathbf{draw}\_\mathbf{freecad}$ functions, producing an output either in the terminal or in the 3D CAD software. Finally, the attribute $\mathbf{draw}\_\mathbf{dict}$ is a dictionary containing all relevant keyword arguments that need to be passed to the draw functions, like the orientation or the color, which hence can be changed manually.

2.2. Rays and Beams

To include the path and visualize light rays or beams into the setup, two function classes exist. The $\mathbf{Ray}$ class describes 1D-light rays (having no transverse extent) propagating in 3D space. The vector $\mathit{r}$ describing the position of any point along such a ray can be written as

$$\mathit{r}=\mathit{p}+L\mathit{a}$$

(1)

with the length L and $\mathit{p}$ and $\mathit{a}$ representing the starting point and the direction, respectively, which are inherited from $\mathbf{GeomObj}$. Any intersection of such a ray with an optical element ($\mathbf{OptElement}$, see Section 2.4) will delimit L, ensuring that the ray stops at this element (and, e.g., creates a new ray propagating in a different direction). For the description of the interaction with a dispersive element, e.g., the diffraction of a ray at a grating surface, each ray receives the wavelength attribute $\lambda$ from its initialization in the object constructor.

The $\mathbf{Beam}$ class (see Figure 1b) acts as the container class for a combination of rays and comprises at least two rays: the inner ray, which describes the beam’s orientation in 3D space and one (or more) outer ray, which determines the local beam waist and its divergence. The default distribution of rays in a beam is the cone-shaped beam, consisting of one inner ray defining the cone’s axis of symmetry and one outer ray propagating on the cone’s surface. Other configurations, like square or hexagonal ray arrangements, as well as 1D rainbows with varying $\lambda$ or Gaussian beams, can easily be defined.

2.3. Unit Mounts and Composed Mounts

Posts, mounts and all other sorts of optic holders are contained in the $\mathbf{UnitMount}$ class (see Figure 1e). The core functionality is implemented by defining for each unit mount a $\mathbf{DockingObject}$, a basic $\mathbf{GeomObject}$ that describes the position and direction of the next mechanical interface of the mount. Taking a mirror holder, the docking object would be placed at the position of the junction between mount and post. In the same manner, posts are also treated as mounts, connecting two points in space; in this specific case, the junction of mount and post, alias the top side of the post, with its bottom side, alias the junction between post and optical table. With this approach, both objects, mounts as well as posts, can be described and handled with the $\mathbf{UnitMount}$ class. The $\mathbf{ComposedMount}$ class acts as a container class (similar to the $\mathbf{Composition}$ class in Section 2.5) and concatenates the unit mounts (e.g., Thorlabs™ KS2 and 0.5″ post holder [14,15]) to one part. An example of such a concatenation is shown in Figure 1f.

Visualization of the objects is realized by loading the corresponding 3D file in a common format like stl or step into the FreeCAD scenery and shifting it to the position given by the mount’s $\mathbf{geom}$ variable. Since most manufacturers offer 3D files in stl or step format for their optomechanics, adding new holders is easy and can be achieved with the help of a comprehensive tutorial, which can be found in the documentation of the project [9]. LaserCAD incorporates by default suitable mount and post combinations for each standard element and provides additional alternatives in a database, including a vast variety of Thorlabs™ and Newport™ components. In addition, some adaptive holders were implemented that change their size and angles automatically to hold the optics in place, like 1″ spacers, ${56}^{°}$ adapters for thin film polarizers or 1.5″-to-1″ adapter rings.

2.4. Components and Optical Elements

The $\mathbf{Component}$ class is the perform of complete optical elements. It adds the $\mathbf{Mount}$ as a member object to the actual optical element (e.g., a lens) in the constructor. With the aperture attribute, the $\mathbf{set}\_\mathbf{mount}\_\mathbf{to}\_\mathbf{default}$ function will select a suitable mount from an extensive catalog included in the program. The $\mathbf{rearrange}\_\mathbf{subobjects}$ functions, which are called with every change in $\mathit{p}$ and $\mathit{n}$, automatically keep the mount in the correct position and orientation around the optical element. An example use case of a $\mathbf{Component}$ could be a photodiode detector mounted on a post.

All specific optical elements like $\mathbf{Mirror}$ or $\mathbf{Lens}$ (see Figure 1c) inherit their properties and functions from the $\mathbf{OptElement}$ class. These properties describe in detail how the light interacts with this element via its $\mathbf{next}\_\mathbf{ray}$$\left(R_{\mathrm{in}}\right)$ function. This will take an object $R_{\mathrm{in}}$ of the $\mathbf{Ray}$ class as the incident ray and return a new ray $R_{\mathrm{out}}$, with starting point and direction changed according to the appropriate ray tracing algorithms for this optical element as described in Section 3. The input rays and beams can be defined manually to the function for testing, but they are mostly automatically handled by the $\mathbf{Composition}$ class as described in the following section.

Each optical element contains its ABCD matrix for ray tracing, but also for analysis and characterization of the setup. In the same manner, Kostenbauder matrices [16], either of single elements or of complete compositions, are provided to the user to give the possibility to evaluate spatio-temporal couplings of the beams introduced by the optical elements of the setup up to 1st-order approximation. So far we have included plane, spherical, cylindrical and rooftop mirrors; spherical lenses and gratings; refractive material blocks; and off-axis parabolas.

2.5. Composition

The container class $\mathbf{Composition}$ is used to address the whole setup or any sub-modules of it. It keeps track of the optical axis, which is modeled by a consecutive list of center rays that are varied by each newly added optical element. This way, the composition helps to place the optical elements centered around the beamline with as few parameters as possible. The core functionalities of $\mathbf{Composition}$ are as follows:

• $\mathbf{propagate}\left(\mathbf{s}\right)$: advances the endpoint on the optical axis by a distance of s mm.
• $\mathbf{add}\_\mathbf{on}\_\mathbf{axis}$: adds optical elements to the end of the composition.
• $\mathbf{add}\_\mathbf{fixed}\_\mathbf{element}$: adds an optical element without changing its position for off-axis optics and multi-pass systems.
• $\mathbf{compute}\_\mathbf{beams}$: starts with an initial ray configuration defined by the $\mathbf{light}\_\mathbf{source}$ and then performs consecutive ray tracing steps as defined by the elements in their order given by the attribute $\mathbf{sequence}$ (therefore LaserCAD is mostly built for sequential ray tracing).
• $\mathbf{draw}$: produces a sketch of the entire system including optical elements, their mounts and beams.

Routines like $\mathbf{rearrange}\_\mathbf{sub}\_\mathbf{objects}$ that are automatically called whenever the $\mathbf{geom}$ is changed, keep the relative distances and orientations of the elements within the composition constant like in the other container classes. An example of a simple $\mathbf{Composition}$ containing two lenses to form a telescope is shown in Figure 1d.

3. Ray Tracing Algorithms

The ray tracing algorithms follow the well-established standard equations that are widely used in modern optics simulation tools [7,17,18,19]. Nevertheless, we will define these equations in this context, as they define the scientific base for the comparison of LaserCAD’s simulation results to those from other software tools. Choosing, e.g., a plane mirror as an example for an optical element (which is by default taken to be thin and planar), its front surface can be described as a plane, which fulfills for all $\mathit{r}\in {\mathbb{R}}^3$ in this plane

$$(\mathit{r}-\mathit{Q})\mathit{n}=0$$

(2)

with the mirror’s position $\mathit{Q}$ (by default located at the center of the front surface) and its normal $\mathit{n}$. Using the definition from Equation (1), a ray with starting point $\mathit{p}$ and direction $\mathit{a}$ will propagate the length

$$L={\displaystyle \frac{(\mathit{Q}-\mathit{p})·\mathit{n}}{\mathit{a}·\mathit{n}}},$$

(3)

until it reaches the center of this mirror. Inserting this value of L in Equation (1) defines the intersection point of the ray with the mirror’s front surface. For a spherical surface (i.e., a surface being part of a sphere with radius R and center position $\mathit{C}$), the length L of the light ray is given by

$$L=\mathit{a}\mathit{D}\pm \sqrt{{\left(\mathit{a}\mathit{D}\right)}^2+R^2-D^2}$$

(4)

with $\mathit{D}=\mathit{C}-\mathit{p}$ being the vector pointing from the ray’s starting position to the sphere’s center. The intersection point is again calculated by Equation (1) and marks the starting point for the next ray. It is worth noting that we intentionally decided to let the rays be reflected even when the intersection lies outside of the aperture of the element. By allowing this, no rays are deleted during the calculation, and the 3D output enables the user to quickly check for potential clipping of beams.

The direction $\mathit{b}$ of the new ray depends on the incident ray’s direction $\mathit{a}$ and on the type of the optical element. In the context of a mirror, the law of reflection defines the new ray’s direction

$$\mathit{b}=\mathit{a}-2\mathit{n}(\mathit{a}·\mathit{n}),$$

(5)

where $\mathit{n}$ is the surface normal in the intersection point $\mathit{S}$ between the mirror surface and the ray. For a plane mirror, $\mathit{n}$ is identical to the element’s normal; for a spherical mirror, the normal can be calculated by the normalized distance of $\mathit{S}-\mathit{C}$.

Diffraction of a light ray at the surface of a reflection grating is calculated by adding the reciprocal grating vector $\mathit{G}$ to the parallel component ${\mathit{k}}_{\mathbf{1}\mathit{p}}$ of the incident ray’s wave vector ${\mathit{k}}_{\mathbf{1}}$. The reciprocal grating vector and wave vector are defined by

$$\mathit{G}={\displaystyle \frac{2\pi }{g}}{\mathit{e}}_{\mathrm{L}},{\mathit{k}}_1=k\mathit{a}={\displaystyle \frac{2\pi }{\lambda }}\mathit{a}={\mathit{k}}_{\mathbf{1}\mathit{p}}+{\mathit{k}}_{\mathit{1}\mathit{n}},$$

(6)

where g is the line spacing, ${\mathit{e}}_{\mathrm{L}}$ the unit vector pointing perpendicular to the grating lines and the grating’s normal, and $\lambda$ the wavelength of the incoming ray. The parallel (p) and normal (n) components of the incoming ray’s wave vector are given by

$${\mathit{k}}_{\mathbf{1}\mathit{n}}=({\mathit{k}}_{\mathbf{1}}·\mathit{n})\mathit{n},{\mathit{k}}_{\mathbf{1}\mathit{p}}=\mathit{n}\times ({\mathit{k}}_{\mathbf{1}}\times \mathit{n}).$$

(7)

Adding the reciprocal wave vector $\mathit{G}$m-times to the incoming ray’s parallel component ${\mathit{k}}_{\mathbf{1}\mathit{p}}$ gives the diffracted ray’s parallel wave vector component

$${\mathit{k}}_{\mathbf{2}\mathit{p}}={\mathit{k}}_{\mathbf{1}\mathit{p}}+m\mathit{G}$$

(8)

with m being the diffraction order. Note that the absolute value of the wave vector remains constant, since the wavelength does not change during the diffraction process. The output wave vector ${\mathit{k}}_{\mathbf{2}}$ as well as the diffracted ray direction $\mathit{b}$ reads

$${\mathit{k}}_{\mathbf{2}}={\mathit{k}}_{\mathbf{2}\mathit{p}}-\sqrt{k^2-k_{2p}^2}\mathit{n}\mathit{b}={\displaystyle \frac{\lambda }{2\pi }}{\mathit{k}}_{\mathbf{2}}.$$

(9)

To describe refraction effects, LaserCAD uses ABCD matrices rather than applying Snell’s law at curved surfaces. Since LaserCAD was intended for modeling optical setups including laser radiation, all scenarios should fulfill the paraxial condition and therefore be suitable for applying optical matrices. In this approximation, elements like lenses can be described completely by their focal length, so that detailed knowledge about surface curvature, material and refractive index is not needed. The elements of optical matrices, in addition, allow for a quick characterization of the entire $\mathbf{Composition}$. To apply the ABCD matrix formalism in 3D, the vector $\mathit{a}$ of the incident ray has to be split into its normal (n), radial (d) and sagittal (s) components, which are sketched in Figure 2:

$$\mathit{a}=a_n\mathit{n}+a_d\mathit{d}+a_s\mathit{s}$$

(10)

The radial vector $\mathit{d}$ is defined by the difference between the intersection point $\mathit{S}$ and the lens center $\mathit{Q}$, while the sagittal direction $\mathit{s}$ is perpendicular to the meridional $\mathit{n}$-$\mathit{d}$-plane and the normal vector $\mathit{n}$ is identical to the components normal. The meridional component $a_m$ as well as the sagittal component $a_s$ of $\mathit{a}$ is approximated to be constant during refraction.

$$\mathit{d}={\displaystyle \frac{\mathit{S}-\mathit{Q}}{|\mathit{S}-\mathit{Q}|}}\mathit{s}=\mathit{n}\times \mathit{d}{a}_m=\sqrt{a_n^2+a_d^2}$$

(11)

From these components the characteristic parameters $h_1$ and ${\alpha }_1$, describing the distance and divergence of a ray from the optical axis, are derived as

$$h_1=|\mathit{S}-\mathit{C}|{\alpha }_1=arctan\left({\displaystyle \frac{a_d}{a_n}}\right)$$

(12)

and can be inserted in the well known vector matrix formalism to compute the outgoing parameters $h_2$ and ${\alpha }_2$ [18,20].

$$\left(\begin{array}{c}{h}_2\\ {\alpha }_2\end{array}\right)=\left(\begin{array}{cc}A& B\\ C& D\end{array}\right)\left(\begin{array}{c}{h}_1\\ {\alpha }_1\end{array}\right)$$

(13)

The refracted ray’s direction $\mathit{b}$ is then given by

$$\mathit{b}=a_{m}cos{\alpha }_2\mathit{n}+a_{m}sin{\alpha }_2\mathit{d}+a_s\mathit{s}.$$

(14)

In addition to geometrical optics, LaserCAD also includes diffraction effects—as they occur, e.g., when using finite focal spot sizes—by means of Gaussian optics. Gaussian beams can be described by the combination of their central axis implemented as a 1D ray and their complex q-parameter

$$q=x+i{x}_{\mathrm{R}}$$

(15)

with x being the distance from the beam waist’s position on the axis and $x_{\mathrm{R}}$ its Rayleigh length [18,20]. Any effect of optical elements will be described by changing the axis analog to the algorithms described above and then calculating $q_{\mathrm{out}}\left(q_{\mathrm{in}}\right)$ according to the matrix formalism for Gaussian beams [20,21]

$$q_{\mathrm{out}}\left(q_{\mathrm{in}}\right)={\displaystyle \frac{A{q}_{\mathrm{in}}+B}{C{q}_{\mathrm{in}}+D}}.$$

(16)

4. Code Examples

To show the general handling of LaserCAD, we will present a few use cases as examples. The following code first constructs a magnifying 2-lens Kepler-type telescope and then sends a square beam through it, consisting of 5 × 5 individual rays, each initially separated by 2 mm in the lateral direction. All length values in LaserCAD are given in mm, beam divergence values are given in radians, and turning angles, e.g., of mirrors, are given in degrees.

Beams (or individual rays) and lenses are subsequently added to the $\mathbf{Composition}$ container object, which handles the positioning of the elements by advancing the optical axis according to the $\mathbf{propagate}$ function. The diameter of the second lens is changed by the aperture command, which also causes an automatic change in the second lens’s mount to a fitting 2″ model. The 3D rendered model will be produced by the $\mathbf{draw}$ function; the result is shown in Figure 3. Rays, lenses, default mounts and posts are all placed and fit to the default beam height of 80 mm, a value that can be changed easily by altering the position $\mathit{pos}$. The necessary line of code will lead to the output of Figure 4, where a new 1/2″ post holder and post were automatically inserted to fit to the new beam height.

To demonstrate the use and capabilities of mirror assemblies, we show the code, which will construct an anastigmatic mirror telescope.

After the initialization of the $\mathbf{Composition}$, a light source is defined and added. In this case it is a cylindrical beam with a radius of 2 mm. With the $\mathbf{propagation}$ function, the optical axis is advanced by 350 mm, which creates an equally long beam before adding the first mirror. The orientation of mirrors is usually defined indirectly in their constructor with the help of their deflection angles $\varphi$ and $\theta$ (e.g., in the third line by phi = 0, theta = 180 − 8). These angles describe how the reflected beam is rotated with respect to the incoming beam. While the first angle gives the desired beam deflection in the $xy$ plane, the second gives the deflection out of this plane. A perfect back reflection of the beam would be achieved by choosing $\varphi ={180}^{°}$, a plane mirror for ${90}^{°}$ deflection by $\varphi =\pm {90}^{°}$. To avoid blocking the path of the outgoing beam by previous optical elements, both mirrors need to be rotated from $0^{°}$ incidence. In this case, an angle of $8^{°}$ was chosen in both directions, $\varphi$ and $\theta$, equally, to reduce astigmatism as proposed in [22]. Curved mirrors are furthermore defined via their radius of curvature, which was chosen to be 250 mm and leads to a necessary distance of 250 mm between the mirrors, which was performed again by the $\mathbf{propagate}$ function. The last propagation call sets the length of the outgoing beam to 350 mm. Figure 5 shows the complete setup.

To change in the second mirror mount from the Polaris™ K1 [23] to the KS1 mount [24] from Thorlabs™, the following line: is executed, that also changes the post from 1" to the adjustable 0.5″ post.

To test the calculation of the spectral phase for ultrashort laser pulse analysis with LaserCAD, a pulse stretcher using reflective gratings for a chirped pulse amplification setup [25] was modeled in LaserCAD and Mathematica™ [8] and the lengths and positions of the different rays were compared. The rendered output of both scenarios is shown in Figure 6. The output shows the expected shape of an Offner-type stretcher setup, with LaserCAD having incorporated the opto-mechanical periphery as well. To validate the physical properties, the group delay dispersion was calculated by summing the ray lengths and calculating the derivative of this length with respect to wavelength. The result of LaserCAD was computed to $4.299\times {10}^6{\mathrm{fs}}^2$ showing less than $1\%$ deviation from the Mathematica™ computation of $4.320\times {10}^6{\mathrm{fs}}^2$ as well as from the theoretical formula of Treacy $4.290\times {10}^6{\mathrm{fs}}^2$ [26]. The whole stretcher was scripted in about 100 lines of Python code, including comments, and took only a few seconds to render on a standard desktop PC using an Intel™ Xeon™ W-2123 processor with 3.60 GHz and four cores. Regarding the performance, it should be mentioned that the computation time for the actual ray tracing and positioning of the optics is, in all tested scenarios, negligible against the rendering time from FreeCAD for the 3D output, which in the current version 1.0.0 uses only the processor and a single core. Still, even a whole chirped pulse amplification laser system was computed and rendered in less than one minute on the aforementioned PC. A template of it can be found in the modules folder of the LaserCAD project [9].

Scenarios like the previous ones with all optical elements were benchmarked against professional ray tracing software tools, including COMSOL and Optica [7,8], and showed good agreement. Taking the focal spot size of a concave mirror, for example, the Comsol calculation showed a maximal spread of $25.257\mathsf{\mu }\mathrm{m}$, whereas LaserCAD calculated it to be $25.284\mathsf{\mu }\mathrm{m}$, resulting in a deviation of about 1‰. The report of these comparisons is published in the project’s manual folder on GitHub [27].

5. Documentation

From the start, the project was programmed with priority on verbose code and well-structured modules. All functions are explained with comments, and every essential member function and class possesses a docstring. A test folder contains various test scenarios for the different classes and their interactions. A detailed documentation based on the academic approach of the DIVIO documentation system has been written [28]. Following this scheme, the documentation is divided into tutorials, how-to guides and a discussion/reference part. The tutorials contain step-by-step instructions for some stand-alone objects like lenses, mirrors or single beams and smaller setups. The code is divided into tiny executable units, and many example pictures between the instructions show the results to familiarize the user with the LaserCAD syntax and structure. The how-to guides contain more complex scenarios with parametric dependencies, like telescopes or a complete stretcher design. In addition, a guide for importing and adjusting new mounts for customized setups is provided. In the discussion section the objects with their source code and some explanation of how and why they were implemented in this way can be found. In addition, some reports of more complex projects conducted in our group can be found here, e.g., a detailed report and analysis of a regenerative stretcher-amplifier system ray-traced by LaserCAD [27]. The documentation files can be found in the folder manual and are all written in the markdown language so that they will be displayed on the GitHub page [9].

6. Discussion

We designed an open-source parametric software toolkit for scripting and rendering complex optical setups with few lines of code and high flexibility of used models and objects. The vast variety of predefined professional optomechanics, together with easy-to-adjust optics and customizable ray-tracing algorithms with well-set default values, make it possible to visualize setups with a minimal amount of required parameters. Since the output is produced by a state-of-the-art CAD program, the user has an unprecedented ability to post-process and complete the output with further details and preconstructed objects like vacuum chambers and more. To the best of our knowledge, this synergy, which forms a unified workflow allowing both optical and mechanical aspects to be treated simultaneously, renders the LaserCAD software framework unique among all comparable solutions.

Another application that shows the potential of LaserCAD is the automated generation of alignment aids, such as spacers or simple mounts, which can subsequently be 3D printed to facilitate the practical realization of the setup in the laboratory. This approach has already been realized in our group to accelerate and streamline the construction of a compressor by undergraduates. The use of the popular Python programming language not only makes the software beginner-friendly but also enables possible collaborations with other ray-tracing, machine learning and optimization software packages, either as directly imported Python modules or via APIs to professional optic design software like Quadoa [29]. In this manner, LaserCAD could be used for preliminary prototyping of projects before the optics positions can be transferred to specialized simulation software tools.

In contrast to commercial software packages such as Zemax or Fred, the focus of LaserCAD does not lie in the high-performance tracing of millions of rays or in the microscopic optimization of focal spot sizes. Instead, the main goal is the realistic visualization and mechanical consistency of complete laboratory setups, using only the minimal number of rays necessary to represent the optical beam path in a meaningful and computationally efficient way. This makes the program particularly suited for experimental planning and educational purposes, where conceptual clarity and spatial awareness are more important than sub-micron precision. In the near future we plan the inclusion of LightPipes [30] for wave optics simulations.

7. Summary

We developed an open-source, Python-based software toolkit for the modular and parametric design of optical setups. LaserCAD allows users to script complex assemblies with minimal code while automatically including realistic opto-mechanical components. The integration with FreeCAD provides detailed 3D visualization and enables seamless transition to further mechanical design and analysis.

Future work will focus on expanding the framework toward wave-optical simulations, automation, and the integration of external optimization libraries. This will further enhance LaserCAD as a comprehensive and flexible environment for both optical and mechanical system design.