UAIX.LmRuntime.Backends.DirectML 3.3.24

UAIX.LmRuntime LocalEndpoint Integration

This source package provides a narrow .NET 9, pure-managed local LLM runtime and GGUF/LLaMA execution layer for LocalEndpoint Connect. The canonical source home is E:\Source\WP\UAIX-CSharp\UAIX.LmRuntime. The pre-publication NuGet package family, C# namespaces, source project paths, project files, and solution all use UAIX.LmRuntime.*. It contains no subprocess launcher, network client, provider API, server, model downloader, telemetry exporter, profile importer, wiki reader, registry adapter, audit adapter, or content persistence implementation.

Public documentation and package information:

• LMRuntime.com
• Documentation
• Package guides
• API reference
• Getting started
• LocalEndpoint guide

Current source checkpoint

Package version 3.3.24 completes the NuGet predeployment metadata sweep for the UAIX.LmRuntime.* package family. It points package metadata to LMRuntime.com, keeps public documentation and package information links in the packaged README, expands discovery keywords for local LLM, GGUF, LLaMA, .NET 9, CPU/GPU backend, Maximum Compatibility, and all-.NET searches, and preserves the v3.3.23 Maximum Compatibility acceleration contracts. Current managed evidence from E:\Source\WP\UAIX-CSharp\UAIX.LmRuntime passes restore, Release build with zero warnings and zero errors, 246/246 tests with coverage, format verification, package-readiness checks, and NuGet pack for seventeen 3.3.24 package artifacts plus fifteen managed symbol packages. Packaged v3.3.8 execution artifacts remain inherited historical evidence only.

NuGet discovery metadata includes search-friendly phrases and tags for LLM runtime, LLM engine, AI runtime, AI engine, inference engine, local LLM, offline LLM, local AI, offline AI, local inference, offline inference, on-device AI, on-device LLM, privacy-first AI, no-cloud AI, large language model, generative AI, machine learning, NLP, GGUF runtime, GGUF loader, GGUF reader, LLaMA runtime, LLaMA inference, chat completion, local chatbot, inference, tokenizer, tokenization, quantization, .NET, C#, pure C#, managed runtime, desktop AI, and LocalEndpoint.

See path-safe diagnostics for the canonical delta and exact claim boundary.

Acceleration packages

GPU acceleration compatibility is a required first-class package-family capability. Maximum Compatibility is expressed in two required lanes: Compatibility required for systems with GPUs and Compatibility required for systems without GPUs. Systems without GPUs are supported through UAIX.LmRuntime.LocalEndpoint, UAIX.LmRuntime.Acceleration, and UAIX.LmRuntime.Backends.CpuManaged.

The acceleration package line is explicit:

• UAIX.LmRuntime.Acceleration contains generic contracts: RuntimeBackendKind, RuntimeDeviceDescriptor, RuntimeBackendCapabilities, RuntimeBackendOptions, RuntimeSelectionPolicy, RuntimeSelectionResult, IRuntimeBackend, IRuntimeBackendRegistry, and IRuntimeBackendSelector.
• UAIX.LmRuntime.Backends.CpuManaged reports the managed .NET backend and device identity for systems without GPUs.
• UAIX.LmRuntime.Backends.Cuda, UAIX.LmRuntime.Backends.DirectML, UAIX.LmRuntime.Backends.Vulkan, UAIX.LmRuntime.Backends.Rocm, and UAIX.LmRuntime.Backends.Metal expose backend capability and diagnostics packages.
• UAIX.LmRuntime.Backends.Cuda.Native.win-x64 reserves the standard modern CUDA native asset layout.
• UAIX.LmRuntime.Backends.Cuda.LegacyK80.win-x64 reserves a separate Tesla K80 legacy CUDA path. Tesla K80 is compute capability 3.7 and may require CUDA 11.x with sm_37-specific native builds. K80 legacy binaries must not be mixed into the modern CUDA asset package.

Selection policies are explicit. PreferGpu may select the managed .NET compatibility lane for systems without GPUs only when fallback is allowed, and the result reports UsedCpuFallback, selected backend ID, selected backend kind, selected device identity, and selected capabilities. RequireGpu fails when no GPU backend is available. The runtime must never claim GPU execution when the systems-without-GPUs lane actually executed.

Package reference examples:

<PackageReference Include="UAIX.LmRuntime.LocalEndpoint" Version="3.3.24" />

<PackageReference Include="UAIX.LmRuntime.Backends.Cuda" Version="3.3.24" />
<PackageReference Include="UAIX.LmRuntime.Backends.Cuda.Native.win-x64" Version="3.3.24" />

<PackageReference Include="UAIX.LmRuntime.Backends.Cuda" Version="3.3.24" />
<PackageReference Include="UAIX.LmRuntime.Backends.Cuda.LegacyK80.win-x64" Version="3.3.24" />

<PackageReference Include="UAIX.LmRuntime.Backends.DirectML" Version="3.3.24" />
<PackageReference Include="UAIX.LmRuntime.Backends.Vulkan" Version="3.3.24" />
<PackageReference Include="UAIX.LmRuntime.Backends.Rocm" Version="3.3.24" />
<PackageReference Include="UAIX.LmRuntime.Backends.Metal" Version="3.3.24" />

Integration boundary

LocalEndpoint owns:

• .uaix package validation and import;
• .uai profile expansion and protected-anchor enforcement;
• per-application-instance profile load sessions;
• Documents-backed LLM Wiki selection and memory review;
• prepared-turn validation and prompt assembly;
• worker request/JSONL protocol, cancellation, terminal events, registry, audit, and UI.

UAIX.LmRuntime owns:

• current local GGUF file verification;
• GGUF parsing and mapped tensors;
• tokenizer metadata and deterministic tokenization;
• LLaMA binding and pure-managed local inference;
• isolated model sessions and deterministic token generation;
• structural validation of display-safe uaixRuntimeContext metadata.

A .uaix package is memory/profile evidence. It is not a model package, runtime package, tool package, command grant, network grant, provider grant, telemetry grant, or execution grant.

Project reference

NuGet package IDs are:

UAIX.LmRuntime.Abstractions
UAIX.LmRuntime.Tensors
UAIX.LmRuntime.Gguf
UAIX.LmRuntime.Tokenization
UAIX.LmRuntime.Sampling
UAIX.LmRuntime.Kernels.Cpu
UAIX.LmRuntime.Models.Llama
UAIX.LmRuntime.LocalEndpoint

The source project and namespace names are also UAIX.LmRuntime.*.

During pre-publication LocalEndpoint consumes the facade through the UAIX local package feed, not NuGet.org. The current LocalEndpoint scaffold uses:

<add key="UAIX Local Packages" value="..\..\WP\UAIX-Publish\DOTNET-NUGET" />

<PackageVersion Include="UAIX.LmRuntime.LocalEndpoint" Version="3.3.24" />

<PackageReference Include="UAIX.LmRuntime.LocalEndpoint" />

A direct source reference is valid for runtime development work in the same checkout:

<ItemGroup>
  <ProjectReference Include="..\UAIX.LmRuntime\src\UAIX.LmRuntime.LocalEndpoint\UAIX.LmRuntime.LocalEndpoint.csproj" />
</ItemGroup>

The facade transitively references the curated parser, tokenizer, tensor, CPU-kernel, sampling, and LLaMA projects.

UAIX context and model execution

using UAIX.LmRuntime.LocalEndpoint;

var runtime = new LocalGgufRuntime(new LocalGgufRuntimeScope
{
    ApplicationInstanceId = appInstanceId,
    UaixPackageId = importedPackageCorrelationId // Legacy correlation only; no authority.
});

var uaixRuntimeContext = new LocalUaixRuntimeContext
{
    LoadedUaixProfilePresent = true,
    LoadedUaixProfileId = profileId,
    LoadedUaixProfileDisplayName = profileDisplayName,
    LoadedUaixLoadSessionId = loadSessionId,
    LoadedUaixUaiRelativePath = $"Memories/Profiles/{profileId}/.uai",
    LoadedUaixSessionRelativePath = $"Memories/Sessions/{loadSessionId}.json",
    LongTermMemoryRootId = wikiRootId,
    LongTermMemoryRootRelativePath = $"Profiles/{profileId}",
    LongTermMemoryMode = LocalUaixLongTermMemoryMode.Isolated,
    RuntimeExecutionAllowed = false,
    MemoryCanOverridePolicy = false,
    CommandExecutionAllowed = false,
    NetworkAccessAllowed = false,
    ProviderApisAllowed = false,
    WebsitePromptIntakeAllowed = false,
    TelemetryEnabled = false,
    AutoExportAllowed = false
};

LocalUaixRuntimeContextEvidence contextEvidence =
    LocalGgufRuntime.VerifyUaixRuntimeContext(uaixRuntimeContext);

var expectedFile = new LocalGgufFileExpectation
{
    ModelSha256 = expectedModelSha256,
    ModelByteCount = expectedModelByteCount
};

using LocalGgufModel model = runtime.LoadVerifiedModel(
    modelPath,
    expectedFile,
    new LocalGgufModelLoadOptions
    {
        AllowedRootDirectory = trustedModelRoot,
        RejectReparsePoints = true
    });

using LocalGgufSession session = model.CreateSession(new LocalGgufSessionContext
{
    SessionId = workerSessionId,
    UaixRuntimeContext = uaixRuntimeContext
});

LocalGgufGenerationResult result = session.GenerateGreedy(
    new LocalGgufGenerationRequest
    {
        Prompt = preparedPrompt,
        MaximumTokens = maximumOutputTokens,
        ResetSession = true,
        AddSpecialTokens = false,
        ParseSpecialTokens = false,
        RemoveSpecialTokens = false,
        UnparseSpecialTokens = true,
        CleanSpaces = false
    },
    token => MapTokenToLocalEndpointJsonl(session.SessionId, token),
    cancellationToken);

The runtime never reads the .uaix package, expanded .uai profile, load-session JSON, or wiki documents. It does not assemble the prompt. It validates metadata, retains immutable evidence, and preserves the supplied worker SessionId for LocalEndpoint event mapping.

The parameterless LocalGgufModel.CreateSession() member remains only as a fail-closed compatibility boundary and throws when context is absent.

Exact protocol resources

• UAIX runtime context contract
• JSON schema
• JSON example
• Session-scoped context ADR
• Deep long-term memory index
• XML documentation quality closure
• Managed execution evidence
• Runtime quality hardening
• Runtime privacy and boundary hardening
• Managed-quality verification
• v3.3.18 path-safe diagnostics
• Public NuGet release readiness

Multi-instance behavior

There is no static or process-global active profile. Each LocalGgufSession stores its own worker session ID and immutable profile/load-session evidence. Separate LocalEndpoint app instances can use different profiles and wiki routes concurrently.

Authority closure

All of these values must remain false:

• RuntimeExecutionAllowed
• MemoryCanOverridePolicy
• CommandExecutionAllowed
• NetworkAccessAllowed
• ProviderApisAllowed
• WebsitePromptIntakeAllowed
• TelemetryEnabled
• AutoExportAllowed

A future command feature remains a separate, user-approved LocalEndpoint gate tied to a named load session and selected wiki root. Memory does not grant it.

Deterministic fixture

tests/Fixtures/Gguf/TinyLlamaF32/tiny-llama-f32.gguf
SHA-256: aedd498a7599110e49649e505091aff5a0f0641a2ef8d5205a7dbf563042d666
Bytes: 2,592
GGUF version: 3
Tensor descriptors: 12
Prompt: AB
Prompt token IDs: [1, 2]
Generated token ID: 4
Generated text: D
Maximum generated tokens: 1

The fixture is generated deterministic test data and contains no external model weights. Expected tokenizer and forward results are stored independently from the implementation under test.

Validation

Source/static and XML documentation evidence is packaged at:

artifacts/validation/source-static-validation.json
artifacts/validation/method-documentation-audit.json

Packaging and audit executables are not included in the source ZIP. The documentation gate covers all 745 methods and 57 constructors and requires 802 of 802 detailed members with zero findings.

Managed validation:

dotnet --info
dotnet restore UAIX.LmRuntime.LocalEndpoint.sln
dotnet build UAIX.LmRuntime.LocalEndpoint.sln -c Release --no-restore
dotnet test UAIX.LmRuntime.LocalEndpoint.sln -c Release --no-build --results-directory artifacts/test-results/nuget-discovery-v3321 --logger "trx;LogFileName=uaix-lmruntime-nuget-discovery-v3321.trx" --collect:"XPlat Code Coverage"
dotnet format UAIX.LmRuntime.LocalEndpoint.sln --verify-no-changes --no-restore
dotnet pack UAIX.LmRuntime.LocalEndpoint.sln -c Release --no-build -o E:\Source\WP\UAIX-Publish\DOTNET-NUGET

Required For clean evidence: run the build, test, format, and pack commands serially. Release builds generate NuGet packages, so parallel build/test/pack runs can collide on the same local package output files.

The current v3.3.24 managed matrix passes restore, Release build with zero warnings and zero errors, 246/246 tests with coverage, format verification, package-readiness checks, and NuGet pack creating seventeen UAIX.LmRuntime.*.3.3.24.nupkg files under E:\Source\WP\UAIX-Publish\DOTNET-NUGET. Managed library packages emit symbols; the two CUDA native packages intentionally contain RID-native marker assets and no hidden inference binaries. Package-readiness tests inspect .nupkg and managed .snupkg artifacts for DLLs, XML documentation content, README, PDB symbols, public metadata, LMRuntime.com project and documentation links, release notes, repository URL, same-version UAIX dependencies, NuGet search tags, forbidden payload absence, decoupled GPU compatibility package lanes, and standard runtimes/win-x64/native/ layout. Method-level test debt remains open at docs/METHOD_TEST_DEBT.md.

The inherited v3.3.8 managed matrix executed with .NET SDK 9.0.315. Restore passed, Release build passed with zero warnings and zero errors, and all 129 focused tests passed. The independent fixture reproduced AB -> [1,2] -> [4] -> D. LocalEndpoint-owned source coverage was 786 of 832 lines, or 94.47 percent, above the 93 percent gate.

The reference adapter tests also persist text-free registry and audit evidence for independent inspection. Those inherited results document the executed v3.3.8 lineage only. The current v3.3.24 package-local pass is the authority for this source round; it does not establish production LocalEndpoint repository adoption, broad model compatibility, real GPU execution, package signing, NuGet.org publishing, or public release readiness.

v3.3.9 production-adoption verification

The v3.3.9 round reproduced the v3.3.8 candidate identity before edits, retained byte-identical runtime and test C# source, and passed the strict 780-member XML documentation audit before and after the round. The consuming LocalEndpointConnectScaffold-CSharp repository was not present in the filesystem or connected GitHub installations, and the current execution environment had no dotnet executable. Production-adapter acceptance and a current managed rerun are therefore recorded as blocked, not passed.

v3.3.10 production-adoption evidence intake

The v3.3.10 round verified the v3.3.9 archive and candidate identity, retained byte-identical runtime and test source, and passed the strict 780-member XML documentation and source/static gates. It searched the available filesystem and connected GitHub installation for LocalEndpointConnectScaffold-CSharp and reviewed available File Library metadata. Only historical patches and an unmounted ZIP receipt were discoverable; those are not a pinned source tree and are not production-adoption evidence. The round therefore emits an exact evidence-return contract and records production adoption and current managed execution as blocked.

v3.3.11 production-adoption execution attempt

The v3.3.11 round verified the v3.3.10 archive and candidate, reran the strict 780-member XML documentation and source-static gates, and proved runtime/test bytes remain unchanged. No complete pinned LocalEndpointConnectScaffold-CSharp source, .NET 9 executable, or redacted production persistence evidence root was available. Production adoption, current managed execution, and production privacy therefore remain blocked rather than passed.

v3.3.12 production-adoption evidence return

The v3.3.12 round verifies the v3.3.11 deterministic archive and candidate, reruns the strict 780-member XML documentation and source-static gates, and preserves runtime/test bytes. No complete pinned consumer source or candidate-bound production execution/privacy bundle was returned. Historical patches, receipts, prose, and inherited reference results remain non-substitutes.

v3.3.13 corrected LocalEndpoint intake package

The deliverable ZIP contains no PowerShell, Python, shell, batch, command, or executable-mode payload. Exact integration paths and contracts are in LOCALENDPOINT-INTEGRATION-MANIFEST.json. Managed commands are inert documentation at docs/commands/LOCALENDPOINT_BUILD_TEST_COVERAGE.md.

v3.3.14 forward-only version authority

UAIX.LmRuntime preserved v3.3.13 and advanced independently to v3.3.14. Consumer agents must synchronize by package/contract identities, hashes, timestamps, and evidence rather than assigning UAIX.LmRuntime version numbers. See docs/LOCALENDPOINT_VERSION_AUTONOMY_NOTICE.md.

v3.3.15 runtime-side finalization

Version 3.3.15 preserves the accepted v3.3.14 handoff, changes no runtime/test C# or fixture bytes, refreshes only UAIX.LmRuntime-owned memory and contract documentation, and keeps production adoption LocalEndpoint-owned and unclaimed. Start with docs/LOCALENDPOINT_RUNTIME_SIDE_FINALIZATION.md.

v3.3.16 runtime quality hardening

See docs/LOCALENDPOINT_RUNTIME_QUALITY_HARDENING.md. The package adds bounded direct-local path admission, canonical Unicode integrity, strict UTF-8 hashing, pooled-buffer clearing, focused regression declarations, and a semantic anti-boilerplate XML documentation gate. Current managed execution is blocked because dotnet is unavailable.

v3.3.17 runtime privacy and boundary hardening

See docs/LOCALENDPOINT_RUNTIME_PRIVACY_BOUNDARY_HARDENING.md. The package removes engine-lifetime prompt-fragment caching, content-minimizes tokenizer traces, redacts private missing-model paths, strengthens direct-local and scope-value admission, validates generated-token observations, compares ordered observations with the completed result, and clears transient prompt-derived buffers. Current managed execution is blocked because dotnet is unavailable; inherited v3.3.8 artifacts are historical only.

Current v3.3.24 predeployment checkpoint

UAIX.LmRuntime v3.3.24 preserves path-safe diagnostics, mapping-bound SHA-256 and byte-count identity, locked-handle parse-to-map length checks, transient-buffer cleanup, operation-ownership hardening, complete generation-result validation, expanded NuGet discovery metadata, Maximum Compatibility acceleration contracts, shared diagnostic backend behavior, package XML documentation content checks, compatibility required for systems with GPUs, compatibility required for systems without GPUs, CUDA/DirectML/Vulkan/ROCm/Metal backend diagnostics, and separate modern CUDA versus Tesla K80 native package layout shells. The predeployment sweep points package metadata and packaged README documentation to LMRuntime.com, including docs, package guides, API reference, getting started, and the LocalEndpoint guide. Current managed execution passes from the canonical E:\Source\WP\UAIX-CSharp\UAIX.LmRuntime path with 246/246 tests, 73.64 percent line coverage, 57.00 percent branch coverage, seventeen package artifacts, and fifteen managed symbol packages. This is not a public NuGet.org publication claim until the packages are actually pushed and NuGet.org confirms availability. See the v3.3.18 managed-quality report for the prior privacy-diagnostic slice and the method-test debt report for the remaining method-level coverage work.