Engineering the.NET UAI NuGet Package: Aligning UAIX Specifications and High-Performance Memory Architectures

Full report

On this page

The Convergence of Distributed Intelligence and Standardized Packaging

The architecture of high-performance artificial intelligence systems demands a rigorous, deterministic approach to software distribution. In modern enterprise and scientific computing environments, the deployment of machine learning algorithms, probabilistic graphical models, and distributed computing topologies cannot rely on ad-hoc script execution. Instead, these complex operational parameters must be encapsulated within strictly versioned, highly portable artifacts. Within the Microsoft.NET ecosystem, the NuGet package manager serves as the foundational vehicle for this encapsulation.1 The mandate to engineer a standard.NET User Access Instance (UAI) NuGet package requires a synthesis of multiple computational disciplines. The objective is not merely to bundle a set of compiled dynamic-link libraries (DLLs), but to orchestrate an entire operational framework that satisfies the stringent requirements of UAI formats, memory allocation protocols, and Universal Artificial Intelligence Exchange (UAIX) specifications.3 This exhaustive architectural blueprint delineates the precise methodologies required to engineer, compile, format, and publish a comprehensive UAI memory package using the Visual Studio and MSBuild toolchains, while fully satisfying the structural requirements of the ONNX runtime and distributed network topologies. To properly engineer this artifact, the architect must first deconstruct the underlying domains that the package will govern. The nomenclature surrounding UAI and UAIX encompasses specific file formats for probabilistic networks, Kubernetes-driven memory orchestration limits, and peering specifications for optimized data routing. By integrating these disparate but highly complementary requirements into a singular, unified.NET library, software engineers can provide an installation payload that fundamentally reconfigures the host environment for optimal artificial intelligence execution.

Deconstructing the UAIX Routing and Networking Specifications

A critical and frequently misunderstood component of distributed learning environments is the underlying network topology required to synchronize massive tensor weights across geographically dispersed nodes. The uaix.com specifications refer fundamentally to the peering parameters and routing table configurations derived from the Ukrainian Internet Exchange (UA-IX) framework.6 When engaging in federated learning or distributed model training—such as the methodologies utilized by the MedAI-UAIX HeteroSync Learning (HSL) project—bandwidth optimization and latency reduction are paramount.3

Dynamic Routing and the UA-IX Framework

The UA-IX network topology is characterized by specific Autonomous System (AS) routing parameters and subnet lists that define localized traffic.7 In a distributed.NET environment, training nodes must frequently transmit multi-gigabyte ONNX models or gradient updates. If this traffic is routed through default global gateways rather than localized peering exchanges, the resulting latency can cause synchronization bottlenecks, paralyzing the distributed learning algorithm. To address this, the UAI NuGet package must incorporate a dedicated network management module that programmatically enforces UAIX routing specifications. Drawing inspiration from historical implementations like UaixRoute, the package should contain background service workers that periodically fetch the latest subnet configurations from authoritative endpoints (e.g., noc.ua-ix.net.ua/ua-list.txt).5 Upon retrieving these specifications, the.NET package must parse the subnet masks and utilize native interoperability (P/Invoke) with Windows IP Helper APIs (iphlpapi.dll) to dynamically inject new routing table entries.5 This ensures that any data transmitted between nodes designated within the UAIX peering list is routed through the most direct, unmetered channels.5 Furthermore, the package must support automated Virtual Private Network (VPN) redialing capabilities.5 Because high-security medical AI data—such as the thyroid cancer datasets processed by MedAI-UAIX—requires encrypted SFTP protocols and strict user access controls, the routing module must intelligently re-establish secure tunnels if the peering connection drops, ensuring uninterrupted data heterogeneity processing.3

By embedding these UAIX routing specifications directly into the NuGet package, developers ensure that any application consuming the library automatically inherits an optimized, high-throughput network posture necessary for sophisticated artificial intelligence workloads.

Graphical Models and the UAI Format Specification

Beyond network topologies, the NuGet package must natively support the parsing, serialization, and evaluation of the standard UAI format. The UAI file format is the universally recognized structure within the Uncertainty in Artificial Intelligence community for representing complex probabilistic graphical models, such as Markov Networks and Bayesian Networks.10 When architecting the memory package, the.NET class library must include highly optimized ingestion pipelines capable of interpreting the four constituent components of a UAI evaluation task without triggering excessive garbage collection. The competition file formats dictate a strict separation of concerns, which the package must mirror programmatically.11

Deserializing the Probabilistic Ecosystem

The core .uai file defines the topological structure of the graphical model. It begins with a preamble declaring the network type (e.g., MARKOV or BAYES), followed by the number of variables, the domain size of each variable, the number of cliques (factors), and the specific variables contained within each clique.10 The remainder of the file contains the floating-point probability tables associated with each factor. To process these files efficiently in C\#, the UAI package should eschew standard string-splitting operations (String.Split), which rapidly fragment the Large Object Heap (LOH) when parsing massive models containing millions of probabilities. Instead, the package must utilize modern.NET memory abstractions, specifically ReadOnlySpan\<char\> and Memory\<T\>. By implementing a zero-allocation parser using StreamReader and memory-mapped files, the package can slide over the .uai specification, extracting factor dimensions and populating unmanaged contiguous memory blocks. In addition to the primary model file, the package must provide programmatic interfaces to load evidence files (.evid), which lock specific variables to observed states, and query files (.query), which define the specific marginal probabilities or Maximum a Posteriori (MAP) estimations the application seeks to resolve.11 The outputs must then be formatted to match the exact specifications of the UAI community standard result extensions (such as .pr for partition functions, .mpe for Most Probable Explanations, or .mar for marginals).11 Although other serialization formats exist, such as BIFXML or Net (.net) 12, providing a pristine, zero-allocation parser for the canonical .uai format ensures that the NuGet package remains the definitive standard for integrating academic and enterprise probabilistic models into production.NET applications.

Architecting UAI Memory Packages and HPC Orchestration

The term "memory package" in the context of User Access Instances (UAI) refers to a deeply specialized subset of configuration parameters designed to govern resource constraints within High-Performance Computing (HPC) and containerized orchestration environments.4 In ecosystems such as the HPE Cray EX architecture, a UAI serves as a lightweight, disposable, single-user interactive computing environment deployed dynamically via Kubernetes.13

Orchestrating Container Resource Specifications

When a UAI is provisioned, its performance is strictly governed by its container image, attached Kubernetes volumes, and, most crucially, its resource specifications.4 These specifications dictate the precise amount of memory and CPU the UAI is guaranteed to receive (the "request") and the absolute maximum threshold it can consume before being terminated by the out-of-memory (OOM) killer (the "limit").4 The.NET UAI memory package must encapsulate these configurations. It should expose a set of fluent APIs that allow developers to programmatically generate Kubernetes resource manifests. By defining these requests and limits within the NuGet package, platform engineers ensure that any deployed instance remains within its designated computational envelope. Furthermore, the package must facilitate the integration of Kubernetes "configmaps" and "secrets," mapping external file systems into the UAI for persistent tensor storage.4

Virtual Memory Abstractions and the AIX Legacy

To achieve true high performance, a UAI memory package must interface directly with the host operating system's virtual memory manager. The architectural philosophy required here is deeply analogous to the memory pinning mechanisms pioneered by enterprise UNIX systems, particularly IBM AIX.14 In AIX environments, memory pages can be "pinned," forcing them to remain in real physical memory and prohibiting the paging daemon (lrud) from stealing or swapping them to disk.14 This mechanism prevents catastrophic page faults during latency-sensitive operations, such as direct I/O transfers or GPU tensor copying.14 AIX utilizes parameters like minperm, maxperm, and numperm to distinguish between computational memory (executables) and non-computational memory (file system caches).15 Furthermore, AIX supports varied page sizes, including small (4K), medium (64K), large (16MB), and supreme (16GB), allowing system administrators to reduce Translation Lookaside Buffer (TLB) misses.16 A standard.NET UAI memory package must bring this level of deterministic memory control to the managed runtime. Because the.NET Common Language Runtime (CLR) inherently manages memory through a non-deterministic Garbage Collector (GC), artificial intelligence workloads are uniquely vulnerable to GC pauses and memory relocation. To counteract this, the NuGet package must implement managed abstractions for memory pinning. By utilizing the GCHandle structure with GCHandleType.Pinned, the package can explicitly instruct the CLR to freeze the memory address of a multi-dimensional tensor array. This pinned memory can then be safely passed to unmanaged high-performance computing libraries, such as the ONNX runtime, ensuring that the garbage collector does not compact or relocate the data while a background thread or GPU DMA (Direct Memory Access) controller is reading it. By wrapping these unmanaged pinning operations in safe IDisposable implementation blocks, the memory package ensures that memory is predictably released, preventing memory leaks while achieving AIX-level virtual memory stability.14

Integration of the UAI_ONNX Runtime Engine

The encapsulation of artificial intelligence execution logic is paramount to the utility of the UAI package. Within the.NET 8.0 and later ecosystems, this is optimally achieved through the integration of the UAI\_ONNX runtime abstraction.17 The native Microsoft ONNX Runtime C\# API provides the fundamental hooks for executing ONNX models, but the UAI\_ONNX library abstracts the underlying complexities, offering a streamlined mechanism for loading graphs and processing multidimensional inputs.17

Inheriting the OnnxImageProcessor

The architecture of the memory package should provide base classes that wrap the UAI\_ONNX runtime. The canonical implementation pattern involves inheriting from the OnnxImageProcessor base class.17 This architecture forces the implementation to define critical operational parameters before inference begins. For example, when constructing a facial parsing or diagnostic imaging model within the UAI package, the developer must override the default configurations to define the specific semantic labels required by the model (e.g., "Background", "Skin", "Left Eye", "Hair", etc.).17 Furthermore, the Start() method must be overridden to explicitly set the input tensor names (e.g., mapping "input" to "pixel\_values") and to configure the expected multi-dimensional tensor shapes.17

Managing Unmanaged Native Dependencies

A highly complex requirement when building the UAI memory package is the management of secondary native dependencies, most notably OpenCV (Open Source Computer Vision Library). The UAI\_ONNX specification explicitly notes that OpenCV DLLs are not automatically packaged or restored via the base NuGet dependencies and must be physically copied to the output directory of the consuming application.17 To solve this, the UAI NuGet package architecture must leverage MSBuild targets. By including a custom .targets file within the NuGet package's build/ directory, the package can inject a post-build event into the consuming application's compilation pipeline.1 This MSBuild target instructs the compiler to automatically copy the necessary unmanaged OpenCV and native ONNX binaries from the package's internal runtimes/ directory into the final output bin/ directory. This seamless automation is what distinguishes a professional, standard.NET package from a poorly engineered wrapper that requires manual developer intervention.

Project Initialization and Visual Studio Configuration

Having defined the theoretical, networking, memory, and runtime architectures, the physical creation of the NuGet artifact begins within the Visual Studio Integrated Development Environment (IDE).1 The process of transforming source code into a standardized, distributable package requires meticulous configuration of project properties and compilation targets.

Instantiating the Class Library

The workflow is initiated by launching Visual Studio 2022 (equipped with the relevant.NET workloads) and creating a new project.1

1. Navigate to File \> New \> Project.
2. Utilize the search filters to select C\#, Windows, and Library.1
3. Select the Class Library template. For packages requiring broad enterprise reach across legacy systems, the Class Library (.NET Framework) template may be chosen.1 However, for modern UAI\_ONNX support, a multi-targeted SDK-style Class Library supporting.NET Standard 2.1 and.NET 8.0 is optimal.18
4. Assign a deterministic namespace and project name, such as UAI.Memory.Core, and execute the creation sequence.1

Establishing the Compilation Profile

Before executing any packaging commands, the solution's build configuration must be strictly evaluated. By default, Visual Studio initializes projects in the Debug configuration. Packaging a Debug build into a NuGet artifact results in the distribution of unoptimized Intermediate Language (IL) code loaded with extensive debugging symbols (.pdb files) and disabled compiler optimizations. This is unacceptable for a high-performance UAI memory package. The developer must navigate to Build \> Configuration Manager and change the Active Solution Configuration from Debug to Release.1 This action ensures that the resulting DLLs are heavily optimized for runtime execution, a critical factor when managing the tight memory boundaries of Kubernetes-provisioned User Access Instances.4

Defining Project Metadata

The metadata of the package—its identity, authorship, and versioning—must be embedded deeply into the project structure. For legacy.NET Framework projects, this is accomplished by navigating to Project \> Properties, opening the Application tab, and accessing the Assembly Information dialog.1 Here, attributes such as Title, Description, Company, and Version are defined, which ultimately map to the \\ attributes within the AssemblyInfo.cs file.1 For modern SDK-style projects, Visual Studio streamlines this process. Developers can right-click the project, select Properties, and navigate directly to the Package section.21 Alternatively, the .csproj file can be edited directly to include \<PropertyGroup\> XML elements that define the package parameters.21

XML \<Project Sdk\="Microsoft.NET.Sdk"\> \<PropertyGroup\> \<TargetFrameworks\>netstandard2.1;net8.0\</TargetFrameworks\> \<PackageId\>UAI.Memory.Core\</PackageId\> \<Version\>1.0.0-beta.1\</Version\> \<Authors\>UAIX Architecture Group\</Authors\> \<Company\>UAI Systems\</Company\> \<Product\>UAI Memory Management Toolkit\</Product\> \<Description\>Standard.NET package for UAIX routing specs, ONNX runtime wrappers, and HPC memory pinning.\</Description\> \<GeneratePackageOnBuild\>true\</GeneratePackageOnBuild\> \</PropertyGroup\> \</Project\>

Setting the \<GeneratePackageOnBuild\> property to true is a highly efficient configuration. It instructs the Visual Studio build engine to automatically invoke the pack target during every successful compilation, ensuring that a fresh .nupkg file is constantly synchronized with the latest source code.19

Advanced NuGet Package Manifest (.nuspec) Engineering

The NuGet Package Manifest, characterized by the .nuspec extension, is the definitive architectural blueprint of the distribution payload. While modern SDK-style projects can generate this manifest implicitly from the .csproj file 2, legacy.NET Framework projects and complex multi-architecture payloads require precise manual engineering of the .nuspec XML file.1

Generating the Baseline Manifest

For non-SDK projects, the generation of the initial manifest is executed via the command-line interface. By launching the Developer Command Prompt from Visual Studio (via Tools \> Command Line \> Developer Command Prompt), the engineer is placed directly within the project's root directory.1 The command nuget spec \[ProjectName\].csproj is invoked.1 This command inspects the project file and generates a baseline .nuspec document populated with replacement tokens encased in dollar signs (e.g., $id$, $version$, $author$).1 These tokens instruct the NuGet packager to dynamically pull the actual values from the compiled assembly's metadata at packing time, preventing the need for manual version synchronization.1 However, several fields require explicit manual configuration. The package engineer must open the .nuspec file and replace the default placeholders for licenseUrl (or modern license expressions), projectUrl, and releaseNotes.1 Crucially, the \<tags\> element must be populated with highly relevant search terms such as "UAI", "UAIX", "ONNX", "Memory", "HPC", and "Routing", ensuring deep discoverability on the public gallery.1 If these placeholder strings are left intact, the subsequent pack command will throw fatal validation exceptions.

Architecting the Payload Directory Structure

A professional UAI memory package must support multiple Target Framework Monikers (TFMs) and specific hardware architectures (e.g., Windows x64 vs. Linux ARM64). The payload organization inside the .nupkg ZIP archive dictates how the NuGet client resolves these assets during installation.1 The internal folder architecture must strictly adhere to the Open Packaging Conventions established by Microsoft.

When resolving these assets, the NuGet engine executes a precise framework matching algorithm. If a consuming project targets .NET 8.0 and the package contains a lib/net8.0/ folder, those assets are selected.1 If an exact match is absent, NuGet algorithmically downgrades, selecting the highest available framework version in the package that is less than or equal to the project's target framework.1 If no compatible framework exists within the lib/ directory, the installation aborts, protecting the host system from runtime instability.1 Furthermore, NuGet evaluates these folders as mutually exclusive silos; it will not mix assemblies from lib/net461/ and lib/net8.0/. Therefore, every framework-specific folder must contain the complete, standalone suite of required assemblies for that environment.1

Dependency Management and Semantic Versioning 2.0.0

The long-term stability of the UAI memory package relies fundamentally on how it declares its external dependencies and manages its own versioning schema. In complex distributed AI architectures, an incompatible transitive dependency can induce silent tensor miscalculations, corrupted memory access, or complete orchestration failure.

The Nuances of Semantic Versioning (SemVer)

NuGet enforces Semantic Versioning (SemVer) protocols, heavily prioritizing the SemVer 2.0.0 specification for all modern distribution.1 The package version string is strictly formatted as Major.Minor.Patch.1

• Major: Incremented exclusively for breaking API changes, such as fundamentally altering the OnnxImageProcessor memory allocation behavior.1
• Minor: Incremented for new, backwards-compatible functional enhancements, such as adding a new UA-IX routing table configuration parser.1
• Patch: Reserved for backwards-compatible bug fixes and security remediations.1

The optional \\ denotes a pre-release build. Package authors utilize alphanumeric suffixes (e.g., \-alpha, \-beta, \-rc for Release Candidate) to distribute experimental optimization strategies to specific testing rings before general availability.1 NuGet's resolution engine inherently understands that any version lacking a suffix is stable and prioritizes it over pre-release builds. Crucially, the SemVer 2.0.0 standard introduced dot-separated numerical sorting for pre-release tags, permanently altering how NuGet prioritizes package upgrades.1 The sequence of precedence evaluates numerical values natively. For example, the resolution hierarchy from highest priority to lowest is evaluated as:

1. 1.0.1 (Stable Release)
2. 1.0.1-rc.10 (Release Candidate 10\)
3. 1.0.1-rc.2 (Because 10 is numerically greater than 2, it supersedes it—a vital upgrade over legacy SemVer 1.0 alphabetical sorting)
4. 1.0.1-beta
5. 1.0.1-alpha2.1

Furthermore, SemVer 2.0.0 permits the appending of build metadata using a \+ symbol (e.g., 1.0.0+commit.8a7b6c5). While NuGet strips this build metadata during string normalization, embedding it in the original .nuspec provides vital supply-chain telemetry, allowing engineers to trace a deployed package back to the exact Git commit hash in the source repository.1

Defining Dependency Thresholds via Interval Notation

To guarantee maximum compatibility while shielding consumers from breaking changes, the UAI package manifest must declare highly explicit dependency version ranges. Interval notation is utilized within the \<dependencies\> block of the .nuspec file (or the .csproj file) to instruct the client on acceptable dependency upgrade paths.1

When defining dependencies for multi-targeted payloads, the \<dependencies\> element in the manifest must be structurally partitioned using \<group targetFramework=""\> child tags. This isolation ensures that an application running on.NET 8.0 is not arbitrarily burdened with legacy.NET Framework 4.6.1 polyfills, preserving the pristine memory footprint required for high-performance Kubernetes execution.1

Build Automation, Packaging Toolchains, and Distribution

With the architectural foundations, source code, metadata, and manifest fully codified, the project is prepared for compilation and archival. The transition from source code to a standardized .nupkg archive can be achieved through multiple toolchains, each presenting distinct capabilities based on the underlying project framework.

The MSBuild Integration Pipeline

For projects utilizing the modern SDK-style .csproj format, the packaging process is seamlessly integrated into the MSBuild pipeline. Because the metadata traditionally housed in the .nuspec file has been migrated directly into the project file under \<PropertyGroup\> elements, an external .nuspec is entirely unnecessary.2 Packaging is invoked directly via the.NET build engine using the Developer Command Prompt: msbuild \-t:pack 19 Or, equivalently, using the cross-platform.NET CLI: dotnet pack 20 This highly integrated approach is the paramount standard for modern UAI packages because it guarantees that the compiled assemblies and the resulting package manifest remain in perfect synchronization. During execution, the compiler automatically evaluates all project PackageReference items, translates them into precise NuGet dependency graphs, compiles the code into optimized MSIL, and generates the .nupkg ZIP archive natively within the bin\\Release directory.19

The NuGet CLI Workflows

For non-SDK style projects, typically legacy.NET Framework libraries utilizing packages.config, the standalone nuget.exe Command Line Interface remains the mandatory mechanism.2 The developer opens the command prompt, navigates to the project directory containing the .csproj and customized .nuspec file, and executes: nuget pack \[ProjectName\].csproj 1 The NuGet CLI evaluates the conventions established in the working directory, executes token replacements based on the assembly metadata, sweeps the lib/, content/, and runtimes/ folders, compresses the assets, and generates a unified ZIP archive disguised with a .nupkg extension.1

Local Verification and Cache Invalidation

Before exposing the memory package to a global repository, rigorous local validation must occur to prevent the publication of corrupt payloads. Developers should establish an isolated, local package source using the CLI: nuget sources add \-name LocalTesting \-source C:\\LocalUAI\_Packages 1 By installing the freshly generated .nupkg into a clean unit test project pulling from this local directory, the engineer can empirically verify the integrity of the dependency graph, ensure correct Target Framework Moniker resolution, and validate that MSBuild targets successfully copy unmanaged native DLLs into the output path.1 If adjustments are necessary, the developer must clear the local NuGet cache (nuget locals all \-clear) before recompiling, ensuring that the test environment does not inadvertently pull a stale, cached version of the package.

Telemetry and Global Distribution

The ultimate objective is the secure publication of the UAI memory package to a centralized repository, most commonly the global nuget.org gallery or a secure corporate artifact feed. Secure transmission requires authentication via an API Key. Within the nuget.org portal, the package author must provision a dedicated key explicitly scoped for "Push" operations.1 To adhere to strict security postures and the principle of least privilege, this key must be constrained using Glob Patterns (e.g., UAI.Memory.\*). This ensures that if the API key is inadvertently compromised, the threat actor cannot use it to overwrite, hijack, or publish updates to unrelated packages within the author's portfolio.1 With the .nupkg artifact generated and the API key securely acquired, the final transmission is executed via the CLI. The command must specify the target source URL to ensure the package payload is routed directly to the V3 index API: nuget push UAI.Memory.Core.1.0.0.nupkg \<api\_key\_value\> \-Source https://api.nuget.org/v3/index.json 1 Upon execution of this command, the NuGet client initiates a cryptographic TLS handshake with the registry and uploads the archive.1 The repository immediately intercepts the payload and begins an asynchronous indexing and validation pipeline. During this critical phase, the registry executes deep malware scans, validates the manifest against SemVer 2.0.0 compliance constraints, and normalizes the version string to remove inconsistencies (such as converting 1.01 to 1.1).1 Once the indexing logic concludes successfully, the UAI memory package becomes globally available to all clients possessing a compatible.NET environment.

Synthesizing the Architectural Standard

The architectural mandate to combine UAIX networking specifications, probabilistic graphical model parsing, and sophisticated high-performance memory constraints into a singular, standardized.NET NuGet package represents a formidable convergence of software engineering disciplines. It requires an uncompromising understanding of how the.NET Common Language Runtime interacts with native virtual memory pinning, how the Open Neural Network Exchange (ONNX) consumes unmanaged resources safely, and how routing tables are manipulated to facilitate high-speed data heterogeneity across distributed learning clusters. By strictly adhering to the Open Packaging Conventions, leveraging the semantic rigor of SemVer 2.0.0, and meticulously organizing the target framework monikers within the internal directory structures, architects can deliver highly reliable, deterministic artifacts. These UAI memory packages empower distributed computing clusters to dynamically govern their Kubernetes resource allocations, process heterogeneous medical and analytical datasets via localized peerings, and execute complex AI inferences seamlessly. The orchestration of these diverse computational requirements through the NuGet ecosystem guarantees that deploying sophisticated UAI logic across thousands of enterprise endpoints is both entirely frictionless and fundamentally structurally sound.

Works cited

1. Quickstart: Create and publish a package using Visual Studio (.NET ..., accessed May 22, 2026, https://learn.microsoft.com/en-us/nuget/quickstart/create-and-publish-a-package-using-visual-studio-net-framework
2. Create a package using the nuget.exe CLI \- Microsoft Learn, accessed May 22, 2026, https://learn.microsoft.com/en-us/nuget/create-packages/creating-a-package
3. MedAI-UAIX/HeteroSync\_Learning-HSL: Addressing data heterogeneity in distributed learning. \- GitHub, accessed May 22, 2026, https://github.com/MedAI-UAIX/HeteroSync\_Learning-HSL
4. Elements of a UAI :: Cray System Management (CSM), accessed May 22, 2026, https://cray-hpe.github.io/docs-csm/en-10/operations/uas\_user\_and\_admin\_topics/elements\_of\_a\_uai/
5. UAIX/World routing tool for VPN users \- Alter.Org.UA, accessed May 22, 2026, http://alter.org.ua/en/soft/win/uaixroute/
6. Ukrainian traffic exchange network, accessed May 22, 2026, https://ix.net.ua/en
7. UA-IX \- Ukrainian Internet Exchange \- Data Center Map, accessed May 22, 2026, https://www.datacentermap.com/ixp/ua-ix/
8. AS25143 Company "Zagalni Merezhi" Ltd \- bgp.tools, accessed May 22, 2026, https://bgp.tools/as/25143
9. Addressing data heterogeneity in distributed medical imaging with heterosync learning \- PMC, accessed May 22, 2026, https://pmc.ncbi.nlm.nih.gov/articles/PMC12552729/
10. UAI 2016 Inference Evaluation, accessed May 22, 2026, https://personal.utdallas.edu/\~vibhav.gogate/uai16-evaluation/binaryformat.html
11. File Formats \- UAI 2022 Competition, accessed May 22, 2026, https://uaicompetition.github.io/uci-2022/file-formats/
12. Input/Output Formats for Bayesian Networks — pyagrum 2.1.1 documentation, accessed May 22, 2026, https://pyagrum.readthedocs.io/en/2.1.1/BNinput-output.html
13. UAIs Come of Age: Hosting Multiple Custom Interactive Login Experiences Without Dedicated Hardware \- Cray User Group, accessed May 22, 2026, https://cug.org/proceedings/cug2022\_proceedings/includes/files/pap110s2-file1.pdf
14. AIX Version 7.2: Performance management \- IBM, accessed May 22, 2026, https://www.ibm.com/docs/ssw\_aix\_72/performance/performance\_pdf.pdf
15. AIX memory utilization \- Stack Overflow, accessed May 22, 2026, https://stackoverflow.com/questions/34886650/aix-memory-utilization
16. Large Memory Pages for AIX \- TechChannel, accessed May 22, 2026, https://techchannel.com/performance/large-memory-pages-for-aix/
17. UAI\_ONNX 1.0.8.10 \- NuGet, accessed May 22, 2026, https://www-1.nuget.org/packages/UAI\_ONNX/
18. nuget.org "onnx" keyword \- Ecosyste.ms, accessed May 22, 2026, https://packages.ecosyste.ms/registries/nuget.org/keywords/onnx
19. Quickstart: Create and Publish a NuGet Package Using Visual Studio (Windows Only), accessed May 22, 2026, https://learn.microsoft.com/en-us/nuget/quickstart/create-and-publish-a-package-using-visual-studio
20. Tutorial: Create a .NET class library \- Microsoft Learn, accessed May 22, 2026, https://learn.microsoft.com/en-us/dotnet/core/tutorials/create-class-library
21. Create a NuGet package with the dotnet CLI | Microsoft Learn, accessed May 22, 2026, https://learn.microsoft.com/en-us/nuget/create-packages/creating-a-package-dotnet-cli