arXiv:2606.17927v1 [cs.LG] 16 Jun 2026
KANLib - An Modular, Extensible and Fast Kolmogorov-Arnold Network Implementation 1st Julian Hoever
2nd Gregor Schiele
Intelligent Embedded Systems University of Duisburg-Essen Duisburg, Germany [email protected]
Intelligent Embedded Systems University of Duisburg-Essen Duisburg, Germany [email protected]
Abstract—Kolmogorov-Arnold Networks (KANs) have recently emerged as a promising alternative to traditional multilayer perceptrons by replacing linear weights with learnable univariate functions. Despite their theoretical advantages in interpretability and expressiveness, practical research of KANs remains difficult due to high computational costs and inconsistent feature support across existing frameworks. This paper introduces KANLib, a modular, extensible, and computationally efficient framework for developing and evaluating KAN architectures. KANLib unifies core concepts from existing implementations, including PyKAN, EfficientKAN, and FastKAN, within a consistent software architecture that emphasizes flexibility, feature parity, and high performance. The framework supports two basis function types, adaptive grid rescaling, grid extension, and fine-grained architectural customization while maintaining compatibility with standard PyTorch workflows. Experimental evaluation on the California Housing benchmark demonstrates that KANLib reproduces the predictive behavior of established reference KAN implementations while achieving competitive computational efficiency. Furthermore, the framework enables the exploration of architectural variations beyond standard KAN formulations with only minor impacts on predictive performance. Overall, KANLib provides a robust foundation for future research on scalable and extensible KAN architectures. Index Terms—Kolmogorov-Arnold Networks, Interpretable Machine Learning, Spline-Based Neural Network, Deep Learning Framework, Computational Efficiency, PyTorch.
I. I NTRODUCTION Artificial neural networks have become the dominant paradigm in modern machine learning, achieving remarkable performance across diverse domains such as computer vision, natural language processing, and audio analysis. Despite the variety of architectures developed for these fields, most share a common structural principle: information is processed through a sequence of affine transformations followed by a fixed non-linear activation function. Formally, each layer computes y = σ(W x + b) where W and b are learnable parameters, and σ denotes a non-linear activation function (e.g. ReLU). In traditional multilayer perceptrons (MLPs), this framework has been shown to possess universal approximation capabilities when properly configured and trained [1]. A key limitation of MLPs lies in their reliance on a fixed activation function: only the affine parameters W and b are trainable. This constraint limits interpretability, as each neuron’s output is influenced by all linearly transformed inputs from the
previous layer. As a result, individual non-linear relationships between inputs and outputs within a single MLP layer cannot be captured directly. To enhance interpretability, particularly in scientific discovery tasks, Liu et al. [2] proposed Kolmogorov-Arnold networks (KANs), a novel framework to construct multi-layer networks in which the linear parameters of MLPs are replaced by learnable non-linear functions. Formally, P the j-th output of a single KAN layer is defined as yj = i Φi,j (xi ) where Φi,j are learnable non-linear functions. This design eliminates the need for fixed activation functions, as each connection in the network inherently introduces its own non-linearity. Despite their potential, the evaluation of KANs in practical applications is often hindered by high computational cost, complex implementations, or a lack of consistent features across different existing implementations. To bridge the gap between KAN theory and practical application, this work introduces an optimized framework, KANLib [3], designed with the following objectives in mind: • Computational Efficiency: The framework should support fast training and inference to make KANs feasible for larger datasets. • Modularity and Extensibility: The framework should be modular and allow to easily add new features in order to accelerate the development of new KAN experiments. • Consistent Feature Set: The framework should facilitate rigorous benchmarking by providing a consistent suite of features across all supported KAN implementations where applicable. The remainder of this paper is structured as follows: Section II introduces the theoretical concept of KANs, while Section III describes three established implementations. Section IV presents our KANLib framework combining contributions from the previously described implementations. Section V evaluates KANLib’s predictive performance and computational efficiency. Finally, Section VI concludes the paper and outlines future work. II. KOLMOGOROV-A RNOLD N ETWORKS A fundamental concept underlying KANs is the Kolmogorov-Arnold representation theorem [4]. The theorem states that each continuous multivariate function
f : [0, 1]n → R with n ≥ 2 can be represented as finite sums of univariate functions ψp,q : [0, 1] → R and χq : R → R such that f (x1 , . . . , xn ) =
2n+1 X
χq (
q=1
n X
ψp,q (xp ))
(1)
p=1
Equation 1 naturally suggests the structure of a two-layer network with the input features x1 , . . . , xn , the networks output f and ψp,q , χq as learnable functions of the first and second layer. However, there is some criticism that the theorem cannot be applied to machine learning in practice, due to the potentially non-smooth behavior of the inner functions ψp,q [5]. Liu et al. [2] take a more optimistic perspective on the usability of the Kolmogorov-Arnold representation theorem in machine learning and generalize Equation 1 to an arbitrary number of layers (depth) and output features (width). To formalize this, let L denote the number of KAN layers, and let n1 , . . . nL represent the number of output features for each layer. The number of input features in the first layer is denoted by n0 . Each KAN layer l ∈ {1, . . . , L} is associated with a matrix Φ(l) of shape nl × nl−1 , whose entries are learnable univariate functions [2]. Using this, the output feature vector x(l) ∈ Rnl of a layer for a given input feature vector x(l−1) ∈ Rnl−1 can be computed as follows [2]: Pn
(l) (l−1) ϕ (x ) i i=1 1,i .. x(l) = Φ(l) ◦ x(l−1) = . Pnl−1 (l) (l−1) ϕ (x ) i=1 nl ,i i l−1
(2)
Therefore, a KAN network can be defined by successively applying the input vector x ∈ Rn0 to the matrices of learnable univariate functions: KAN(x) = Φ(L) ◦ . . . (Φ(2) ◦ (Φ(1) ◦ x)) . . .
(3)
In a KAN, each learnable univariate function ϕ can model a non-linear relationship, allowing each layer to directly represent non-linear influences of individual input features on (intermediate) output features. In practice, learnable univariate functions are typically realized as splines [2], [6], [7]. III. KAN I MPLEMENTATIONS Since the publication of the KAN architecture by Liu et al. [2] in 2024, the field has seen a significant increase in research work. While many approaches utilize spline-based architectures [2], [6], [7], others explore alternative methods for realizing learnable univariate functions, such as Fourier series [8] or Jacobi basis functions [9]. This section focuses on three prominent spline-based KAN implementations. Specifically, the official PyKAN framework of Liu et al. [2], [10] is evaluated alongside two computationally efficient versions: EfficientKAN [7] and FastKAN [6], [11]. Subsequently, in Section IV, the KANLib framework
[3] is introduced, which consolidates features from these implementations to provide a fast and modular environment for KAN research. All the considered implementations support MLP-like KAN models only (no convolutional KANs, etc.). The PyKAN, EfficientKAN, and FastKAN frameworks were selected because they are widely recognized and provide a consistent baseline for research. While numerous other KAN variants have emerged in recent years [12], they remain outside the scope of this comparison. A. PyKAN The seminal work by Liu et al. [2] generalized the Kolmogorov-Arnold representation theorem to networks of arbitrary depth, as discussed in Section II. The official implementation, PyKAN [10], utilizes B-splines to model the univariate continuous non-linear functions ϕ within the weight matrix. To enhance optimizability, the authors define each learnable function ϕ as a weighted combination of a learnable B-spline spline(x) and a residual branch b(x) [2]: ϕ(x) = wb b(x) + ws spline(x)
(4)
In this definition, the residual branch b(x) employs the SiLU (Sigmoid Linear Unit) activation function, b(x) = SiLU(x) = x/(1+exp(−x)). The spline component is defined P as spline(x) = i ci Bi (x) with the B-spline basis functions Bi and their corresponding learnable coefficients ci . Beyond the core architecture, PyKAN [10] provides an extensive suite of functionality for model creation, manipulation and training. The PyKAN framework is designed to be an interactive scientific discovery tool [10]. Therefore, a primary focus of the framework is interpretability; it includes built-in functionality for pruning and symbolic regression by replacing learned splines with symbolic mathematical expressions (e.g., sin or exp). This allows researchers to transform complex neural representations into transparent, closed-form equations. To facilitate the interpretation of these representations, PyKAN incorporates visualization capabilities. Researchers can render the entire network graph, where each edge displays the shape of its corresponding learned univariate function ϕ. Furthermore, the framework supports sophisticated grid manipulation techniques to refine the accuracy of the spline approximations during the training process. 1) Grid Manipulation: A significant advantage of KANs is that their learnable edges are continuous univariate functions, which can be dynamically re-projected onto different grids without losing learned information. PyKAN leverages this property through two main mechanisms: • Grid Extension: When creating a KAN, an initial grid size has to be specified. Grid extension allows to gradually learn higher-frequency details during training by replacing a coarse-grained grid with a finer-grained grid and projecting the already-learned spline onto the finegrained grid to make the spline more accurate [2]. • Adaptive Grid Rescaling: During training, input values of layers in KANs may shift outside the initial grid
1.0
B-Spline Basis
range or input values are not equally distributed over all grid points. PyKAN addresses this by updating the grid boundaries and distribution based on the input data statistics.
Equidistant Grid
Non-Equidistant Grid
1.00 0.75 0.50 0.25 0.00 0.25 0.50 0.75 1.00 x
1.00 0.75 0.50 0.25 0.00 0.25 0.50 0.75 1.00 x
0.8 0.6 0.4 0.2
The initial PyKAN implementation faced performance issues due to the high computational overhead of B-spline basis function evaluations. Furthermore, to support the extensive feature set offered by PyKAN, the implementation computes and composes various intermediate results. This architectural choice limits the ability to represent large segments of the computational graph using highly efficient PyTorch operations. To address the computational limitations of PyKAN, EfficientKAN [7] introduces three main optimizations: a more efficient B-spline basis evaluation, an optimized KAN linear layer computation, and a faster residual branch implementation. The original PyKAN framework expands the input tensor from a shape of (nbatch , ninputs ) to (nbatch , noutputs , ninputs ), duplicating inputs for each output feature. Since B-spline basis evaluation is computationally expensive, this increases the evaluation cost by a factor of noutputs . EfficientKAN avoids this expansion by computing B-spline basis values directly from the input. This optimization was later integrated into PyKAN in June 2024 [13]. EfficientKAN further combines the B-spline basis weighting and linear layer computation into a single, highly optimized torch.nn.functional.linear function call. The residual branch weighting is implemented similarly. However, these coarse-grained PyTorch operations omit intermediate activations, making some PyKAN features infeasible, including the activation-based L1 regularization proposed by Liu et al. [2]. Instead, EfficientKAN applies standard L1 regularization to the spline coefficients [7]. Overall, EfficientKAN prioritizes computational efficiency over feature completeness. The framework supports MLP-like KAN models, adaptive grid rescaling similar to PyKAN, and coefficient-based L1 regularization [7]. C. FastKAN The FastKAN framework [6], [11], developed by Ziyao Li, builds upon the optimizations introduced by EfficientKAN to further accelerate KANs. Its main contribution is to replace third-order B-spline basis functions with Gaussian radial basis functions (RBFs) [6]. 1) Gaussian Radial Basis Functions: The primary motivation for utilizing Gaussian RBFs is to circumvent the computational complexity associated with B-splines. A Gaussian radial basis function BRBF,i for an input x, a center point xi , and a spread σ is defined as: ||x − xi ||2 (5) BRBF,i (x) = exp − 2σ 2 By substituting the B-spline basis Bi in the spline computation, with this Gaussian RBF, FastKAN eliminates the need
Gaussian RBF Basis
0.0
B. EfficientKAN
1.0 0.8 0.6 0.4 0.2 0.0
Fig. 1. Examples of B-spline and Gaussian radial basis functions with equiand non-equidistant grids.
for the iterative or recursive computations (such as the CoxdeBoor recursion) typically required for B-spline evaluations. This allows for direct computation of the basis function values, promising a significant increase in training and inference throughput. 2) Grid Considerations: In the context of FastKAN, the grid of a spline is defined by the center points xi of the Gaussian RBFs (see Equation 5). While Gaussian RBFs offer computational advantages, their ability to approximate thirdorder B-spline basis functions is highly dependent on the grid’s distribution. As demonstrated by Ziyao Li, Gaussian RBFs can effectively approximate B-spline basis functions through linear transformations, provided the grid is equidistant [6]. However, this approximation capability breaks down on non-equidistant grids. As illustrated in Figure 1, Gaussian RBFs fail to maintain the necessary local characteristics to mimic B-spline basis function behavior when grid spacing is not equidistant, as they cannot approximate the B-spline basis functions through linear transformations alone in such configurations. 3) Implementation: Consistent with its focus on computational performance, the FastKAN implementation [11] offers a more restricted feature set compared to both PyKAN [10] and EfficientKAN [7]. The framework primarily supports the construction of MLP-like KAN models and provides basic visualization functionality for plotting learned spline functions. Notably, FastKAN does not support the adaptive grid rescaling mechanism found in PyKAN and EfficientKAN. To compensate the lack of grid rescaling abilities, it applies Layer Normalization [14] to the inputs before the basis function evaluation, effectively mapping the input distribution to the RBFs’ active range [11]. IV. KANL IB To accelerate the research and development of KANs, our KANLib framework [3] synthesizes the core innovations of PyKAN [2], [10], EfficientKAN [7], and FastKAN [6], [11]. The framework is designed to provide researchers with a highly flexible environment for creating and training KAN models while maintaining high computational performance.
The architectural design of KANLib is guided by three primary requirements: computational efficiency, modularity, and feature consistency. While existing implementations provide disparate and often incompatible feature sets, KANLib consolidates these diverse approaches within a unified software architecture. These design goals are specifically tailored to our research needs. By providing a computationally efficient implementation, KANLib allows for the evaluation of KANs on resource-restricted hardware using large datasets. A. Supported Features The modular design ensures that all linear layer types regardless of the underlying basis function, share a consistent feature set. This consistency is critical for facilitating direct, rigorous comparisons between different KAN variations. Currently, KANLib supports the following features: • MLP-like KAN models: Users can create pure MLPlike KAN models by stacking KANLib’s linear layers. Furthermore, the framework’s design allows these layers to be integrated into any standard PyTorch model to facilitate the development of hybrid architectures. • Fine-Grained Control: Following the definition in Equation 4, KANLib utilizes learnable functions consisting of a spline and a residual branch. However, unlike presented implementations, KANLib provides the granular control to selectively disable the residual branch wb b(x) or the extra spline weighting ws . Additionally, similar to FastKAN [6], [11], KANLib supports Layer Normalization [14] to rescale inputs into the active range of the basis functions. • Adaptive Grid Rescaling: While PyKAN and EfficientKAN offer adaptive grid rescaling for B-splines, FastKAN lacks this mechanism, relying instead on input normalization. KANLib implements the adaptive rescaling strategy for B-spline layers and extends this support to Gaussian RBF-based layers. For Gaussian RBF layers, this is restricted to equidistant grids, as non-equidistant grid configurations are not beneficial (see Section III-C2). • Grid Extension: A notable feature of PyKAN is the ability to increase spline resolution during training without losing learned information (see Section III-A1). While omitted in EfficientKAN and FastKAN, KANLib supports grid extension for both B-spline and Gaussian RBFbased linear layers. • Training and Visualization: The framework includes a predefined training function that allows to use adaptive grid rescaling and grid extension steps during training. Additionally, it offers functionality to visualize individual learned spline functions to assist in evaluating the learned knowledge. The KANLib framework is publicly available on GitHub for experimental use [3]. V. E VALUATION The goal of this evaluation is to assess whether KANLib reproduces the predictive behavior and computational char-
acteristics of established KAN implementations while simultaneously providing the architectural flexibility discussed in the previous sections. Rather than focusing exclusively on maximizing predictive accuracy, the experiments are designed to validate the correctness, consistency, and extensibility of the framework across different basis function implementations and layer configurations. To this end, we compare KANLib against reference implementations presented in Section III of both B-splinebased and Gaussian radial basis function (GRBF)-based KAN architectures on the California Housing dataset [15]. The dataset is derived from the 1990 U.S. census and contains 20,640 samples with eight numerical input features, including median income, average number of rooms, and house age. The task is to predict the median house value and therefore provides a simple but well-established regression benchmark for evaluating neural network architectures. In the following, KANLib (B-spline) denotes KANLib models using B-spline basis functions, while KANLib (GRBF) refers to KANLib models based on Gaussian radial basis functions. A. Experimental Setup To ensure a fair and reproducible comparison, all evaluated implementations use the same network architecture and training configuration. Each model consists of a two-layer KAN architecture with a hidden dimension of 30 neurons. Since Gaussian RBFs approximate third-order B-splines, all B-spline-based variants use spline order 3 in order to maintain architectural consistency across experiments. Furthermore, the grid size is fixed to 10 and the grid range is defined as [−1, 1]. To minimize implementation-specific influences, advanced features such as adaptive grid rescaling and Layer Normalization are intentionally disabled. This allows the comparison to focus on the underlying KAN implementations rather than additional implementation-specific optimization techniques. The California Housing dataset is split into a training set containing 80% of the samples and a validation set containing the remaining 20%. Prior to training, all input features are rescaled to the range [−1, 1] in order to align the input distribution with the B-spline and Gaussian RBF grid domains used in the first layer. All models are trained for 300 epochs using the Adam optimizer with a learning rate of 10−3 , a batch size of 1024, and the mean squared error loss function. To account for stochastic variation caused by random parameter initialization, each experiment is repeated 20 times using independent weight initialization. The reported metrics correspond to the mean and standard deviation across all runs. Overall, this evaluation setup provides a standardized environment for comparing different KAN implementations and for validating the consistency and correctness of the KANLib framework. B. Predictive Performance Table I summarizes the predictive performance and computational characteristics of all evaluated implementations on
the California Housing dataset. Results are reported as mean values and standard deviations across 20 independent training runs. Among the evaluated B-spline-based implementations, KANLib (B-spline) achieves the best predictive performance with an RMSE of 0.5376 ± 0.0044 and an coefficient of determination (R2 score) of 0.7852 ± 0.0035. Compared to KANLib (B-spline), PyKAN exhibits an approximately 1.1% higher RMSE, while EfficientKAN differs by roughly 1.6%. These comparatively small deviations indicate that KANLib successfully reproduces the predictive characteristics of existing spline-based KAN implementations. A similar observation can be made for the GRBF-based architectures. KANLib (GRBF) achieves an RMSE of 0.5471 ± 0.0078 and an R2 score of 0.7776 ± 0.0063, while FastKAN differs by only an RMSE that is approximately 0.6% higher. This demonstrates that KANLib is capable of reproducing the behavior of established GRBF-based KAN implementations. Overall, the predictive results show that KANLib remains fully competitive with widely used reference implementations despite its additional abstraction layers and architectural flexibility. C. Computational Efficiency In addition to predictive performance, we evaluate the computational efficiency of the different KAN implementations by comparing the number of trainable parameters and the inference time on CPU (AMD Ryzen 9 9950X). Inference time is measured by averaging the time required to process 1000 independently sampled inputs. As shown in Table I, all evaluated models except FastKAN contain 4050 trainable parameters. These parameters include spline coefficients ci , residual branch weights wb , and additional spline weights ws . FastKAN contains fewer parameters because it omits the additional spline weighting mechanism implemented in PyKAN, EfficientKAN, and KANLib. The measured inference times reveal several important trends. First, PyKAN is the slowest implementation with an inference time of 212.19 ± 2.55 ms. EfficientKAN and KANLib (B-spline) substantially improve computational efficiency and reduce inference time by approximately 32.7% compared to PyKAN. This similarity is expected because the KANLib implementation incorporates several optimizations introduced by EfficientKAN. Replacing B-splines with Gaussian radial basis functions leads to an additional reduction in inference time. KANLib (GRBF) achieves an inference time of 80.58 ± 4.21 ms, corresponding to an improvement of approximately 62.0% compared to PyKAN. FastKAN achieves the fastest execution with 41.02 ± 0.25 ms and therefore improves inference speed by approximately 80.7% relative to PyKAN. Despite these improvements, KANLib (GRBF) remains significantly slower than FastKAN. The primary reason is the current implementation of the Gaussian RBF computation, which was designed to support the adaptive grid rescaling functionality of KANLib and therefore introduces additional
computational overhead. Optimizing this component represents an important direction for future work. D. KAN Architecture Exploration As discussed in Section IV, one of the primary goals of KANLib is to provide a flexible research framework for exploring different KAN architectures. Consequently, the framework must support modifications of the traditional KAN layer structure defined in Equation 4. Table II demonstrates that KANLib supports several architectural variations beyond the standard KAN formulation. The Default configuration corresponds to Equation 4 and includes both the residual branch wb b(x) and the spline weight ws . The Plain configuration represents a minimal KAN layer in which both the residual branch and spline weights are removed, leaving only the spline computations. All experiments use the same two-layer architecture and training setup introduced in Section V-A. Across both basis function types, the Default and No Residual configurations achieve the strongest predictive performance. However, the overall differences between configurations remain comparatively small, indicating that all considered variants represent viable architectural alternatives. More substantial differences can be observed in terms of parameter count and inference time. The Default configuration contains 4050 trainable parameters, while removing either the residual branch or the spline weights reduces the parameter count to 3780. The Plain configuration further reduces the parameter count to 3510. The inference time measurements reveal that removing the residual branch produces a larger speedup than removing the spline weights. Relative to the Default configuration, removing the residual branch reduces inference time by approximately 6.2% for B-spline-based models and 10.5% for GRBF-based models. Removing the spline weights reduces inference time by approximately 4.1% and 6.3%, respectively. These observations are consistent with the underlying computational structure of the layer implementations. Spline weights represent a comparatively inexpensive operation because they can be folded into the spline coefficients during the forward pass [3], [7]. In contrast, the residual branch introduces an additional SiLU activation and a matrix multiplication proportional to the input and output dimensions of the layer. Overall, our experiments demonstrate that KANLib enables systematic exploration of alternative KAN architectures while maintaining competitive predictive performance. Depending on the selected configuration, inference time can be reduced by up to approximately 10.0% for B-spline-based models and 16.8% for GRBF-based models in the considered experimental setting. VI. C ONCLUSION This paper introduced KANLib, a modular and extensible framework for Kolmogorov-Arnold Networks (KANs). KANLib provides a flexible foundation for future research on KAN architectures, basis functions, and optimization strategies.
TABLE I P ERFORMANCE ON THE C ALIFORNIA H OUSING DATASET ACROSS 20 TRAINING RUNS PER IMPLEMENTATION . R ESULTS ARE REPORTED AS MEAN ± STANDARD DEVIATION FOR VALIDATION RMSE, R2 , AND INFERENCE TIME . Implementation FastKAN KANLib (GRBF) PyKAN EfficientKAN KANLib (B-spline)
RMSE 0.5506 ± 0.0041 0.5471 ± 0.0078 0.5434 ± 0.0051 0.5463 ± 0.0053 0.5376 ± 0.0044
R2 0.7748 ± 0.0033 0.7776 ± 0.0063 0.7806 ± 0.0042 0.7782 ± 0.0043 0.7852 ± 0.0035
#params 3811 4050 4050 4050 4050
Inference Time [ms] 41.02 ± 0.25 80.58 ± 4.21 212.19 ± 2.55 143.60 ± 1.90 142.03 ± 1.65
TABLE II P ERFORMANCE OF DIFFERENT KANL IB ARCHITECTURE CONFIGURATIONS ON THE C ALIFORNIA H OUSING DATASET ACROSS 20 TRAINING RUNS . R ESULTS ARE REPORTED AS MEAN ± STANDARD DEVIATION FOR VALIDATION RMSE, R2 , AND INFERENCE TIME . Basis Function B-spline
GRBF
Configuration Default No Residual No Spline Weight Plain Default No Residual No Spline Weight Plain
RMSE 0.5399 ± 0.0068 0.5350 ± 0.0061 0.5498 ± 0.0042 0.5455 ± 0.0036 0.5470 ± 0.0073 0.5454 ± 0.0063 0.5586 ± 0.0064 0.5552 ± 0.0066
In contrast to existing implementations such as PyKAN [2], [10], [13], EfficientKAN [7], and FastKAN [6], [11], which are typically designed around a single type of basis function and a fixed architectural design, KANLib was developed with a strong focus on research-oriented extensibility and flexibility. The evaluation shows that KANLib reproduces the predictive behavior of established KAN implementations while maintaining competitive computational performance. Furthermore, the framework supports architectural variations beyond the standard KAN formulation with only minor impacts on predictive quality. Future work includes optimizing the computational cost of the Gaussian RBF basis function computation to reduce the inference time gap compared to FastKAN. In addition, supporting KAN-based 1D convolutions represents an important next step toward applying KANs to time-dependent sensor data such as ECG, EEG, and audio signals. ACKNOWLEDGMENT The authors acknowledge using AI tools (ChatGPT, Gemini, and DeepL) for brainstorming, proofreading, and structuring the work. The authors acknowledge the financial support by the German Federal Ministry for Economic Affairs and Energy (BMWE) and by the Ministry of Economic Affairs, Industry, Climate Action and Energy of the State of North RhineWestphalia (MWIKE NRW) in the ”5-Standorte Programm”, joint project ZaKI.D, funding number: 11-09862. R EFERENCES [1] K. Hornik, M. Stinchcombe, and H. White, “Multilayer feedforward networks are universal approximators,” Neural Networks, vol. 2, no. 5, pp. 359–366, Jan. 1989. [Online]. Available: https://www.sciencedirect. com/science/article/pii/0893608089900208 [2] Z. Liu, Y. Wang, S. Vaidya, F. Ruehle, J. Halverson, M. Soljačić, T. Y. Hou, and M. Tegmark, “KAN: Kolmogorov-Arnold Networks,” Feb. 2025, arXiv:2404.19756 [cs]. [Online]. Available: http://arxiv.org/abs/ 2404.19756
R2 0.7834 ± 0.0054 0.7873 ± 0.0049 0.7754 ± 0.0034 0.7789 ± 0.0029 0.7777 ± 0.0059 0.7790 ± 0.0051 0.7681 ± 0.0053 0.7709 ± 0.0054
#params 4050 3780 3780 3510 4050 3780 3780 3510
Inference Time [ms] 140.65 ± 1.48 131.93 ± 1.79 134.84 ± 1.98 126.55 ± 4.74 79.37 ± 6.02 71.02 ± 5.78 74.38 ± 3.99 66.03 ± 5.13
[3] J. Hoever, “julianhoever/KANLib,” Jan. 2026, original-date: 202507-24T06:53:54Z. [Online]. Available: https://github.com/julianhoever/ KANLib [4] A. N. Kolmogorov, “On the Representation of Continuous Functions of Several Variables by Superposition of Continuous Functions of One Variable and Addition,” Doklady Akademii Nauk SSSR, vol. 114, pp. 369–373, 1957. [5] F. Girosi and T. Poggio, “Representation Properties of Networks: Kolmogorov’s Theorem Is Irrelevant,” Neural Computation, vol. 1, no. 4, pp. 465–469, Dec. 1989. [Online]. Available: https://doi.org/10. 1162/neco.1989.1.4.465 [6] Z. Li, “Kolmogorov-Arnold Networks are Radial Basis Function Networks,” May 2024, arXiv:2405.06721 [cs]. [Online]. Available: http://arxiv.org/abs/2405.06721 [7] Blealtan, “Blealtan/efficient-kan,” Oct. 2025, original-date: 202405-02T14:19:28Z. [Online]. Available: https://github.com/Blealtan/ efficient-kan [8] J. Xu, Z. Chen, J. Li, S. Yang, W. Wang, X. Hu, and E. Ngai, “Enhancing Graph Collaborative Filtering with FourierKAN Feature Transformation,” Aug. 2025, arXiv:2406.01034 [cs] version: 3. [Online]. Available: http://arxiv.org/abs/2406.01034 [9] A. Afzal Aghaei, “fKAN: Fractional Kolmogorov–Arnold Networks with trainable Jacobi basis functions,” Neurocomputing, vol. 623, p. 129414, Mar. 2025. [Online]. Available: https://www.sciencedirect.com/ science/article/pii/S0925231225000864 [10] Z. Liu, “KindXiaoming/pykan,” Oct. 2025, original-date: 2024-0427T21:25:35Z. [Online]. Available: https://github.com/KindXiaoming/ pykan [11] Z. Li, “ZiyaoLi/fast-kan,” Oct. 2025, original-date: 2024-0509T10:34:01Z. [Online]. Available: https://github.com/ZiyaoLi/fast-kan [12] Jinhui.Lin, “mintisan/awesome-kan,” Jan. 2026, original-date: 202405-08T03:24:36Z. [Online]. Available: https://github.com/mintisan/ awesome-kan [13] Z. Liu, P. Ma, Y. Wang, W. Matusik, and M. Tegmark, “KAN 2.0: Kolmogorov-Arnold Networks Meet Science,” Aug. 2024, arXiv:2408.10205 [cs]. [Online]. Available: http://arxiv.org/abs/2408. 10205 [14] J. L. Ba, J. R. Kiros, and G. E. Hinton, “Layer Normalization,” Jul. 2016, arXiv:1607.06450 [stat]. [Online]. Available: http://arxiv.org/abs/ 1607.06450 [15] “The California housing dataset — Scikit-learn course.” [Online]. Available: https://inria.github.io/scikit-learn-mooc/python scripts/datasets california housing.html#