Thanks for your feedback and suggestions! I'm glad you appreciated our work.

Here are some responses to your questions and concerns:

---

For the conditional airfoil generation task, only one baseline is provided for the smaller UIUC and Super datasets. I see that the best performing baseline on AF-200K was used for the other datasets as well, but given that the other datasets are way smaller in terms of the number of samples available, it would be interesting to see how at least one more baseline model copes with the limited data regime (that is usually the big constraint in this domain). Is there a reason that only PK-DiT is provided as baseline for the UIUC and Super datasets?

Thank you for your warm suggestion. The original AFBench paper did not report information except for the PK-DiT model, so only PK-DiT was included in Table 1 for the UIUC and Super datasets. However, we trained the PK-VAE model using the original AFBench code and same settings. We have now added new comparison experiments, and the results are as follows:

FuncGenFoil outperforms both PK-VAE and PK-DIT on the UIUC and Supercritical datasets, even in the relatively limited data regime.

---

The model seems to have issues learning angles as the label error on the PARSEC parameters and are quite large relative to baselines. Could you elaborate on that? Could you elaborate on the model performance on the error of the PARSEC angle parameters, in particular give an explanation why the model struggles?

This is because we changed the definition of the trailing-edge angle, as explained in Appendix A.2. In this work, we perform super-resolution inference, increasing the resolution from 257 to 1025 points, as shown in Table 2. We found that the traditional method for calculating the trailing-edge angle is not suitable or numerically stable at higher resolutions, so we updated the definition in our dataset.

This new definition is not sensitive for the supercritical airfoil dataset (which is the main cluster for modern commercial aircraft design), but it can introduce additional noise and linear regression error for other datasets. As a result, FuncGenFoil shows a higher label error on these particular parameters compared to baselines. However, this deterioration in performance is generally not significant on average, and it has little practical impact on the use of the generated airfoils. The trailing-edge angle can typically be changed very rapidly by adjusting the position of only a small number of design points by a small amount, leaving the main shape of the airfoil largely unchanged, which may suggest that the FuncGenFoil model is focusing more on the overall shape of the airfoil rather than the trailing-edge angle.

---

The experiment on airfoil editing shows that the model is able to incorporate user constraints. It seems like the editing scales and perturbations during editing are rather small. It would be interesting to see how robust the model is when asked for larger edits. How does the model handle large edits? Is it robust?

Here we provide results for three additional editing scales under the same experimental setting, with the largest being 8 times greater than the original. As shown, the edit error increases at an accelerating rate with larger edits but remains relatively low overall. Given that the average thickness of an airfoil is about 0.1, our editing method remains effective for edit ranges from -5% to 5% under a conservative estimate. In practice, by increasing the finetuning steps and choosing suitable time steps, even larger edit scales or denser constraints are possible, as demonstrated in Figure 4.

---

Could you provide some visualizations of generated airfoils by the model, maybe also for the baselines?

Thank you for your suggestion. Due to the new NeurIPS 2025 policy, we are unable to upload PDFs or share external links at this stage. If the paper is accepted, we will include visualizations of the generated airfoils by our model and the baselines both on the public project page and in the appendix of the camera-ready version.

Thanks for your valuable feedback and thoughtful suggestions!

We address your questions and concerns in detail, and hope these responses help clarify our work.

---

(a) The limitation of classical methods is not really explained; it is just said that picking certain function families limits the design space. But how strong of a limitation is this in practice? (b) Furthermore, neural networks are not random functions [2]. So there is also a clear bias in the shapes/geometries neural networks will learn, depending on the architecture, activation functions, etc, which is well explored in the neural implicit shape and geometry processing literature. We are simply using a different class of function family, but to me it is not clear what underlying problem the authors are trying to solve with this. It looks like just applying a different function class to the problem. I would ask for clarification from the authors on this point.

For question (a):

Selecting specific function families, such as NURBS, inherently limits expressiveness, as they cannot exactly represent all smooth functions (e.g., a simple sine curve), and increasing the number of control points adds significant complexity. In practice, such representations restrict the ability to fully explore the design potential of airfoils. Moreover, aerodynamic performance is highly sensitive to curvature and higher-order smoothness, especially in high Reynolds number flows. From a design perspective, it is therefore advantageous to unlock the full functional design space. The function-space generative model we proposed can represent airfoils both as point sets and continuous functions at infinite resolution.

For question (b):

Regarding the use of the Fourier neural operator instead of NURBS: as you suggested, this is indeed a choice of a different function class. Our motivation for this choice is that Fourier transforms offer theoretical elegance, as they allow us to operate in the spectral domain and recover functions via inverse transforms with minimal loss, leveraging efficient modern computational algorithms. The Fourier neural operator is also supported by theoretical guarantees as a general function approximator [1], making it a suitable and principled choice for our purposes. We agree that the exploration of alternative neural operators—potentially based on NURBS or Bézier curve —remains an open and interesting research direction.

---

While the authors provide extensive comparisons to previous DL methods, they provide none to other "classical" computational design methods. These should serve as a baseline for the data-driven approaches.

This paper presents a data-driven and model-based method that enables engineers to more effectively leverage existing high-quality data for airfoil generation. It relies on data.

Classical, model-free methods represent a complementary paradigm rather than a substitute. These methods have the advantage that they do not rely on existing data, but the disadvantage that they cannot extract information from data.

These two kinds of methods are complementary but not directly comparable. Non-data-driven, model-free methods should only be compared with algorithms that are also model-free. Therefore, they should not be included as baselines in our experiments focused on data-driven methods in Table 1.

---

(a) No comparison methods for the airfoil editing task. (b) Also, the edited airfoils from "Freestyle Airfoil editing" are not being tested for their aerodynamic performance. Instead, a new model is trained on a different dataset to test this. It is not clear to me why, please clarify.

For question (a):

To the best of our knowledge, as of the submission date, there is no existing research utilizing generative models for the Freestyle Airfoil editing task. We are the first to integrate conditional airfoil generation and freestyle airfoil editing within a unified, consistent framework, achieving highly accurate editing results.

For question (b):

For the airfoil editing task, our primary focus is on whether the model accurately follows the designer’s instructions (i.e., achieves low editing error) while preserving airfoil smoothness. Consequently, we do not evaluate aerodynamic performance for edited airfoils in this paper, as there is no well-established benchmark for comparison. For aerodynamic performance evaluation, we use the NASA Common Research Model (CRM) dataset, a widely recognized benchmark with validated working conditions and extensive use in CFD and aerodynamic studies.

---

No clear overview of the computational cost of dataset generation, training, finetuning, and inference is provided. Recent review articles of DL methods for numerical problems have raised the issue that the full computational costs of DL methods/surrogates are often not provided and compared to SoTA numerical methods (see e.g.[3]). The paper gives the training time, but this should be more thorough.

We will include a table summarizing the computational costs, memory usage, and runtimes in the paper. Regarding dataset generation time, we are unable to provide this information as we only utilize publicly available datasets created by other researchers.

---

I find Figure 4 a bit hard to read/process; the color choices (light green, light blue, light gray) seem suboptimal. Just a minor point.

Thank you for pointing this out. We will improve the color choices in Figure 4 and select a palette with higher contrast to enhance readability.

---

How does the full cost of FuncGenFoil compare to a classical method using e.g. NURBS? What is the advantage of FuncGenFoil? Are there failure cases of classical methods that it can fix? Are there failure cases of FuncGenFoil?

For an aircraft engineers, designing an airfoil using traditional NURBS methods requires several minutes of manual work and CAD expertise. Or, using a model-free optimization method takes about 5–10 minutes and thousands iterations to fit a 24-control-point NURBS airfoil, depending on the initial shape condition. In contrast, FuncGenFoil can generate a new airfoil in about one second.

Classical methods may fail when control points are too close together or too few in number, leading to numerical instability and shape errors—particularly near the leading edge where control points are densely clustered. FuncGenFoil avoids these issues by not relying on control points.

For FuncGenFoil, failures typically occur when generating airfoils far outside the training data range (e.g., specifying an unrealistic leading-edge radius, too small or too large).

---

The paper makes the point that FuncGenFoil enables superresolution with smooth, arbitrary resolution shapes. Is this smoothness not a direct consequence of the FNO backbone, which approximates the data with a finite Fourier representation of the signal (geometric curve)? Is the size of the FNO sum a limit/upper bound of FuncGenFoil similar to parametric-model-based methods?

The smoothness of the output is indeed influenced by both the type of operator used and the choice of Gaussian process kernel during operator flow matching. Since FuncGenFoil operates as both a parametric-model-based and point-based method, smoothness and resolution are primarily determined by the number of modes specified for the neural operator. Increasing the number of modes allows the model to capture more information from the data, reducing truncation error and enabling finer control over shape details. While, in theory, a Fourier transform (and its inverse without spectrum truncation) can represent smooth curves with zero error, in practice, capturing high-frequency information may require increasing the model size and mode width. In this paper, performance differences between various model sizes are minor, as demonstrated in Table 8.

---

Why use a FNO backbone instead of typical INRs like SIREN? The paper mentions it is possible in principle, but does not elaborate on this choice further. FNOs are not commonly used in neural geometry processing literature.

To model vector operators in infinite-dimensional Hilbert spaces, several options are available, including INRs and neural operators [1]. INRs are a good choice for neural geometry processing due to their ability to perform arbitrary point inference. However, when using INRs in generative models in function space, you must specifically design a functional encoder for function-type inputs to ensure the model is invariant to different resolutions. For example, as a network for the velocity operator $dx=v_{\theta}(x)$, both input $x$ and output $dx$ can be of any resolution; the original INR can only guarantee the output being of infinite resolution, but not the input. This encoder in the INR should act as an operator in the mathematical sense, since an operator is a transformation between functions and is naturally input-resolution invariant.

Neural operator is widely adopted in AI for science and engineering [1], particularly for solving PDEs and in computational fluid dynamics applications such as weather forecasting [2]. Given their strong theoretical foundation and proven effectiveness in modeling complex physical phenomena, FNO is especially suitable for aerodynamic modeling and research, so we chose the neural operator as the backbone for our approach.

[1]Neural operators for accelerating scientific simulations and design. Nature Reviews Physics, 2024.

[2]FourCastNet: Accelerating Global High-Resolution Weather Forecasting Using Adaptive Fourier Neural Operators. Proceedings of the Platform for Advanced Scientific Computing Conference. 2023

To better demonstrate the performance of classical (model-free and non-data-driven) methods, we conducted an experimental test implementing the plan of Case B memtioned in our last response. In this approach, a NURBS curve with 24 control points is used to represent the airfoil $x$. We rewrote a differentiable evaluator $c=F(x)$ to enable gradient-based optimization, aiming to minimize the gap between the evaluated 11 parameters $c$ and the required 11 parameters $c_{\text{req}}$, as measured by $\text{MSE}(c, c_{\text{req}})$.

For the experimental settings, we initialized the 24 control points to fit the average airfoil in the test dataset. The optimization was performed sequentially for all 3,825 supercritical airfoils in the test dataset. For each airfoil, we ran 100 steps of the Adam optimizer with a learning rate of $3\times10^{-4}$, ensuring that the MSE did not decrease and that the optimization converged. The total computation cost was approximately 20 GPU-hours on an Nvidia A800 GPU.

The resulting errors are summarized in the following tables:

Since we initialize the optimization from a position very close to the target in the test dataset, this baseline can be considered the optimal performance that a naive 24-control-point NURBS curve can achieve for fitting the design parameters. Compared to Table 1, the FuncGenFoil method closely approaches this upper bound in terms of accuracy.

The NURBS fitting baseline performs exceptionally well in controlling the trailing edge, as the control points are densely distributed in this region. However, FuncGenFoil demonstrates superior performance at the leading edge, since the NURBS fitting baseline tends to turn sharply at the leading edge and cannot fit it accurately with only 24 control points.

In general, this is not a fair comparison because we initialize the control points very close to the target for training stability, making convergence relatively easy. In contrast, FuncGenFoil or PK-DIT generate new airfoils starting from pure Gaussian noise. (We have observed that the optimization process is delicate and can easily become unstable if the initial control points are perturbed more randomly, causing the control points to diverge after just a few training steps.)

Nevertheless, this experiment provides a useful reference for the potential best performance of a model-free parametric method, provided that each optimization proceeds successfully. We will open-source the code for this test in our repository. We hope this information helps address your concerns. If you have any further questions or would like more details, we welcome further discussion.

Thanks for your feedback and suggestions! I'm glad you appreciated our work.

Here is the response to your several concerns:

---

The paper does not present a hardware prototype to confirm the physical fidelity of the results. For example, whether the airfoil geometry proposed by the generative model is more useful than existing designs remains unclear. This is probably beyond the scope of this work, though. Is there a way to validate the performance of these explored airfoil designs in the real world?

Yes, this work is part of a generative design module that has been integrated into modern commercial aircraft design systems in collaboration with aerodynamic experts. Due to commercial confidentiality, we are unable to disclose details regarding the real-world performance of generated or optimized airfoils deployed in industry. Instead, our study utilizes public datasets, on which the proposed techniques demonstrate similar performance trends. As shown in Figure 5, the simulation results for the generated airfoils exhibit trends that closely align with those observed in real-world applications.

---

I didn’t find any discussions on the paper’s limitations in the main paper. Please discuss.

We apologize for not including a discussion of the paper’s limitations in the main text due to the 9-page length restriction. However, we have provided this discussion in Appendix E following the main text.

The primary limitation of FuncGenFoil is that it is applicable only to curves or surfaces that can be parameterized with a suitable coordinate system. For more complex surfaces, where defining such a coordinate system is challenging, FuncGenFoil is not directly applicable. Addressing these challenges will require further theoretical advancements, which we consider an important direction for future research. In addition, we should introduce more kinds of real constraints to the model, such as mechanical constraints and manufacturing constraints, to enhance the model's applicability to real-world engineering problems.

---

I’d also like to ask about the potential of this method for 3D airfoil design.

FuncGenFoil can be applied to a variety of aircraft component surfaces, such as fuselages, engine nacelles, and turbomachinery blades, as long as a suitable coordinate system can be defined for the geometry. For example, we can generate the 3D main wing surface of an aircraft using a larger dataset of 3D airfoil geometries under cylindrical coordinate system.

For more complex and irregular shapes—such as full aircraft surfaces or automotive bodies—where it is difficult to define a parameterization or coordinate system, further advances in differential geometry and manifold theory would be needed to enhance the FuncGenFoil method. For example, generative models could be used to reconstruct the deformation of general shapes parameterized in geodesic coordinates. This remains an open and challenging problem, and is certainly a promising direction for future research.

Thanks for your feedback and suggestions! I'm glad you appreciated our work.

Here is the response to your concerns:

---

A more thorough efficiency study of the proposed method should be provided to better demonstrate its advantages. In particular, a comparison with discrete point-based generation methods would be valuable. Intuitively, the proposed approach should offer efficiency gains over these methods, and it would strengthen the paper to provide evidence supporting this.

We agree that a more thorough efficiency study is beneficial. In short, both PK-DIT and FuncGenFoil have comparable model sizes and utilize MSE-type losses (flow matching for FuncGenFoil, score matching for PK-DIT), resulting in similar computational costs during training. On my current setup, which includes an NVIDIA 4090 GPU, PK-DIT can be trained for 1000 epochs on supercritical datasets in approximately 10 hours, whereas FuncGenFoil completes 1000 epochs in less than 6 hours, benefiting from the modern dataloader provided by the TorchRL library. As for AFBench dataset, it takes around 10 times longer to train both models as the dataset is larger and more complex, but the relative performance remains similar.

For inference, PK-DIT incurs a higher computational cost due to the use of a large number of function evaluations (NFE = 50) with the DDIM sampling scheme in their original Github implementation. This could be improved by adopting more advanced diffusion inference techniques such as DPM-Solver++. In contrast, FuncGenFoil, as a flow matching model, generates flows directly and requires only 10 NFEs to achieve competitive performance.

Both PK-DIT and FuncGenFoil are lightweight and can be efficiently run on consumer GPUs. On a platform with an NVIDIA 4090 and Intel 13900K, the average inference time is 220 ms for PK-DIT and 50 ms for FuncGenFoil. GPU memory usage for both models is around 200 MB, which is quite small. We will include a table summarizing the exact computational costs, memory usage, and runtimes in the appendix if the paper is accepted.

Thanks for your feedback and suggestions! I'm glad you appreciated our work.

Here are some responses to your questions and concerns:

---

Complexity and Accessibility: The method requires a sophisticated combination of operator learning, Gaussian processes, and differential solvers, which may hinder reproducibility.

First, we have included the complete code in the supplementary material (zip file) and are committed to open-sourcing our work to ensure reproducibility. Second, our training code is built upon several widely-used open-source packages and maintains a manageable level of complexity. Specifically, our methods are implemented using a standard neural operator library [1]. Notably, we introduce a novel and tractable loss function to model functional distributions over objectives and constraints, which regularizes model outputs in function space. Additionally, we employ a learnable prior during fine-tuning, which adds some complexity compared to other generative model frameworks.

---

Generality of Shape Types & Generality Beyond Airfoils: Although the method is proposed in a general form, the experiments are restricted to airfoils and wings, which are relatively smooth and regular. Have you considered applying FuncGenFoil to more general or irregular geometries (e.g., full aircraft surfaces or automotive shapes)?

Yes, FuncGenFoil can theoretically be applied to a variety of aircraft component surfaces, such as fuselages, engine nacelles, and turbomachinery blades, as long as a suitable coordinate system can be defined for the geometry. In this paper, we focus on airfoil objects as they are important for aircraft systems lift and drag performance.

For more complex and irregular shapes—such as full aircraft surfaces or automotive bodies—where it is difficult to define a parameterization or coordinate system, further advances in differential geometry and manifold theory would be needed to enhance the FuncGenFoil method. For example, generative models could be used to reconstruct the deformation of general shapes parameterized in geodesic coordinates. This remains an open and challenging problem, and is certainly a promising direction for future research.

---

Editing Scope and Flexibility: How does the method handle conflicting or dense constraints (e.g., multiple overlapping or incompatible edits)?

For conflicting constraints, the model does not strictly satisfy all conditions but instead seeks a reasonable airfoil design that balances errors between conflicting objectives. This trade-off is quantitatively determined by the scalar value of the associated penalty term.

For overlapping or repeated constraints, the model remains effective. Technically, the multiple-constraint loss continues to perform robustly. As shown in Figure 4 and described by Equation 8, even with dense constraints—covering up to 60% of all points—repeating the constraints leads to editing errors of less than 10e−6, which is negligible.

---

Runtime Efficiency: While performance is strong, training involves millions of iterations and inference requires solving ODEs, which may be costly in time or resources.

On an NVIDIA 4090 GPU, PK-DIT can be trained for 1000 epochs on the supercritical datasets in approximately 10 hours, while FuncGenFoil completes 1000 epochs in under 6 hours. This efficiency is attributed to our use of the modern flow matching training scheme, which not only accelerates convergence but also improves performance.

For inference, PK-DIT incurs a higher computational cost due to the use of a large number of function evaluations (NFE = 50) with the DDIM sampling scheme. This can potentially be reduced by employing more advanced diffusion inference techniques, such as DPM-Solver++. In contrast, FuncGenFoil, as a flow matching model, directly generates flows and requires only 10 NFEs to achieve competitive performance.

Both PK-DIT and FuncGenFoil are lightweight models that can be efficiently executed on consumer GPUs. On a system equipped with an NVIDIA 4090 and Intel 13900K, the average inference time is 220 ms for PK-DIT and 50 ms for FuncGenFoil, with GPU memory usage for both models remaining around 200 MB.

---

Scalability and Efficiency: What are the training/inference times compared to point-based models like PK-DIT or diffusion models? It is suggested to include a table comparing computational costs, memory usage, and runtime to help readers assess deployment feasibility.

We will include a table summarizing these computational costs, memory usage, and runtimes in the the paper.

---

Design Parameter Interpretability: Can the latent space or generated airfoils be interpreted in terms of classical aerodynamic design principles?

The flow generation path acts as a bridge between the data space and the latent space. The data space consists of numerous airfoils designed according to classical aerodynamic principles by human experts, while the latent space represents a function space with a Gaussian measure. Because the generation path is reversible in both directions, every expert-designed airfoil corresponds to a unique latent function. By leveraging modern interpolation techniques such as spherical interpolation (SLERP)[3] or Latent Optimal Linear combinations (LOL)[4], we can interpolate between latent representations of different airfoils. This allows us to generate new airfoils that transition smoothly between designs, all of which adhere to classical aerodynamic design principles and exhibit similar aerodynamic performance, as illustrated in Figure 5.

[1] Jean Kossaifi and Nikola Kovachki and Zongyi Li and David Pitt and Miguel Liu-Schiaffini and Robert Joseph George and Boris Bonev and Kamyar Azizzadenesheli and Julius Berner and Anima Anandkumar. A Library for Learning Neural Operators. arXiv 2412.10354.

[2] Chen, Ricky T. Q. and Rubanova, Yulia and Bettencourt, Jesse and Duvenaud, David. Neural Ordinary Differential Equations. Neurips 2018.

[3] Ken Shoemake. Animating rotation with quaternion curves. In Proceedings of the 12th annual conference on Computer graphics and interactive techniques, pp. 245–254, 1985.

[4] Erik Bodin and Alexandru Stere and Dragos D. Margineantu and Carl Henrik Ek and Henry Moss. Linear combinations of latents in generative models: subspaces and beyond. ICLR 2025.