Skip to content
GGUF RuntimeC# host application portal
Public technical index

Search the developer portal

Search public pages, documentation, examples, packages, topics, status labels, roadmap records, updates, and glossary terms. Queries are not sent to a third-party service.

Enter at least two characters.

    C# · .NET · Local GGUF

    Build transparent local GGUF applications in C#.

    GgufRuntime.com is the developer-facing host and interface guide for verified GGUF intake, explicit model and session ownership, bounded local inference, visible backend evidence, and cross-platform applications built around UAIX.LmRuntime.

    Run the managed CPU quick startExplore the host architecture

    No model downloader No provider fallback No hidden telemetry

    HOST / RUNTIME EVIDENCE
    artifact.identitysha256 + byte_countHOST
    model.loadverified local pathRUNTIME
    session.scopeisolated + disposableRUNTIME
    generation.boundtoken limit + cancellationHOST
    backend.stateregistration ≠ executionEVIDENCE
    output retained with method, environment, and limitations
    current.lanemanaged CPU application path
    fallback.policyvisible or fail closed
    AvailablePublic runtime packages
    Host-ownedTrust, limits, and policy
    Evidence gateExecuted result retained
    .NET CLI · version-free
    dotnet add package UAIX.LmRuntime.LocalEndpoint

    The package installs the local runtime facade. It is not a finished desktop or web UI product. Resolve and pin versions through the consuming project’s normal dependency policy.

    Package/API claims last reviewed .

    What exists today

    Use the available runtime foundation without promoting roadmap intent into fact.

    The two columns deliberately separate public package capability from UI and compatibility claims that still require implementation or retained evidence.

    Evidence available

    Available today

    • Public UAIX.LmRuntime package family
    • Verified local GGUF intake
    • Managed CPU application path
    • GGUF parsing and metadata inspection
    • Tokenization and LLaMA package layers
    • Isolated sessions
    • Bounded generation
    • Explicit backend registration and diagnostics
    • Visible CPU fallback state
    Not claimed

    Not yet claimed

    • Finished cross-platform GGUF desktop application
    • Universal model compatibility
    • Automatic model acquisition
    • Automatic licensing validation
    • GPU inference from registration alone
    • Production or safety certification
    • Platform parity without test evidence

    Review the current implementation state

    Choose your developer path

    Start from the task the host application must own.

    Each path leads to a finished route with explicit prerequisites, runtime boundaries, non-claims, and canonical source links.

    01 / EXECUTE

    Run a local model

    For C# developers who need the verified LocalEndpoint intake, isolated session, bounded generation, cancellation, and disposal sequence.

    Open Getting Started →    02 / INSPECT

    Inspect a GGUF artifact

    For tooling authors who need container validation, metadata, tensor descriptors, SHA-256 identity, and compatibility boundaries before execution.

    Open inspection guidance →    03 / PRESENT

    Build a desktop interface

    For application teams designing model intake, session state, cancellation, output dispatch, diagnostics, accessibility, and host adapters.

    Open host architecture →    04 / PROVE

    Understand backend evidence

    For teams that must keep package presence, registration, declared compatibility, probing, selection, fallback, and executed inference separate.

    Open the evidence ladder →

    Runtime ownership map

    Follow authority, execution, and evidence through the complete host workflow.

    The diagram distinguishes behavior the application owns, behavior the runtime owns, evidence-only state, and proposed reference-interface work.

    Host-ownedRuntime-ownedEvidence stateProposed UI
    1. 1
      Host application and UIFile choice, trust, licensing, prompt assembly, limits, cancellation, persistence, transport, presentation
    2. 2
      Verified LocalEndpoint intakeAllowed root, reparse-point policy, byte limit, expected SHA-256, expected byte count
    3. 3
      GGUF → tokenization → tensors → LLaMA → samplingParsed metadata, mapped weights, model ownership, isolated session, bounded deterministic generation
    4. 4
      Backend registration → probe → selection → execution evidenceEach state remains independently visible; registration never substitutes for completed inference
    5. 5
      Output, cancellation, telemetry, and disposalUI-thread dispatch, explicit stop state, defined timing method, retained limitations, session before model disposal
    ProposedReference interface surfacesDesktop and cross-platform adapters visualize this flow but do not expand runtime authority.
    Text equivalent: the host chooses and trusts the model, defines limits and policy, and presents results. LocalEndpoint verifies the local artifact and owns loaded model and session operations. Lower runtime packages parse GGUF data, tokenize, bind tensors, execute the documented model path, and sample output. Backend registration, probing, selection, and execution proof remain separate evidence records. The host passes cancellation, measures with a disclosed method, exports evidence, and disposes each session before disposing the model.

    Open all architecture diagrams

    Reference interface surfaces

    Present runtime state without hiding the host boundary.

    Status labels describe retained site or package evidence, not the existence of a finished downloadable cross-platform application.

    MODEL.INTAKEEvidence available

    Model intake

    Expected hash, byte count, trusted root, reparse policy, maximum size, and technical failure detail.

    GGUF.INSPECTExperimental

    GGUF inspector

    Container version, metadata, tensor catalog, alignment, storage traits, and compatibility questions.

    SESSION.STATEEvidence available

    Session control

    Explicit model scope, isolated session identity, reset behavior, bounds, stop state, and disposal order.

    TOKEN.OUTPUTExperimental

    Token output

    Incremental observation, sequence and token identifiers, selected logit, UI dispatch, and bounded presentation.

    CANCEL.PASSEvidence available

    Cancellation

    A host-owned CancellationToken flows into generation; cancellation remains distinct from a normal stop reason.

    RUNTIME.METRICSProposed

    Runtime metrics

    Time to first token, throughput, memory method, environment, and known limitations with disclosed measurement rules.

    BACKEND.STATEIn progress

    Backend diagnostics

    Package presence, registration, compatibility declaration, local probe, selected backend, fallback, and proof.

    EVIDENCE.JSONReleased

    Evidence export

    A browser-local JSON builder records observations without model paths, credentials, or benchmark-certificate language.

    HOST.ADAPTERProposed

    Cross-platform host adapters

    Desktop-first file access, UI-thread dispatch, mobile storage, thermal state, packaging, signing, and device evidence.

    Package selector preview

    Choose by application task.

    Package names follow the public family. Exact package dependencies and current release metadata remain canonical on LMRuntime.com and NuGet.

    TaskStarting packageBoundary
    Application integrationUAIX.LmRuntime.LocalEndpointFacade, not a finished UI or downloader
    GGUF inspectionUAIX.LmRuntime.GgufParsing is not compatibility or trust proof
    TokenizationUAIX.LmRuntime.TokenizationHost owns prompt-template correctness
    LLaMA internalsUAIX.LmRuntime.Models.LlamaNo universal architecture claim
    SamplingUAIX.LmRuntime.SamplingHost owns generation policy and limits
    CPU kernelsUAIX.LmRuntime.Kernels.CpuObserved execution still requires evidence
    Backend selectionUAIX.LmRuntime.BackendsSelection differs from registration and proof
    Backend registrationUAIX.LmRuntime.Backends.CpuManagedInstallation alone proves no execution
    Open the package selectorRead package-selection guidance

    Evidence ladder

    Do not collapse eight independent states into “supported.”

    Each rung answers a different question. A later state requires its own retained evidence rather than inference from an earlier state.

    1. 01
      Package installedDependency resolution succeeded.
    2. 02
      Backend registeredA backend identity is available to the host.
    3. 03
      Compatibility declaredThe backend reports a theoretical or declared lane.
    4. 04
      Local probe completedThe current environment produced a probe observation.
    5. 05
      Backend selectedHost policy chose a lane and records fallback state.
    6. 06
      Model loadedVerified bytes were accepted and model ownership began.
    7. 07
      Inference executedThe selected lane completed bounded generation.
    8. 08
      Results retainedMethod, environment, outcomes, and limitations were recorded.

    Review backend evidence rules

    Cross-platform direction

    Treat every operating system as a separate evidence lane.

    Avalonia-oriented guidance provides a reference direction. Roadmap intent is not a tested build, signed package, device result, or platform-support claim.

    PlatformRoadmap intentPrimary constraintsEvidence / public claim
    WindowsDesktop baselinex64 package, file picker, memory pressure, UI dispatch, optional backend proof, signingIn progressPublic claim: Not claimed
    LinuxPrimary desktop targetDistribution packaging, graphics stack, permissions, desktop integration, tested distributionsProposedPublic claim: Not claimed
    macOSDesktop expansionSandbox access, architecture matrix, signing, notarization, package validationProposedPublic claim: Not claimed
    AndroidMobile evaluationScoped storage, 64-bit process, memory ceiling, thermal state, battery, device matrixProposedPublic claim: Not claimed
    iOSMobile evaluationSandbox bookmarks, signing, memory ceiling, thermal state, device and store policyProposedPublic claim: Not claimed

    Open the compatibility decision tree

    Latest documentation

    Reviewed host guidance, not the WordPress default post.

    Browse all documentation →

    Roadmap snapshot

    Four implementation phases, each gated by evidence.

    Dates are not commitments. Each phase exposes scope, dependencies, a proof gate, review state, and an explicit non-claim.

    1. 01
      In progress

      Artifact inspection and intake

      Trusted file selection, identity verification, GGUF metadata, tensor catalog, tokenizer visibility, and load-risk presentation.

      Evidence gate
      Parser output and trust record retained before execution
    2. 02
      Proposed

      Execution workflow

      Model lifecycle, session lifecycle, generation controls, cancellation, output, timing method, and technical error display.

      Evidence gate
      Bounded run and lifecycle evidence retained
    3. 03
      Proposed

      Hardware and backend evidence

      CPU capabilities, backend declarations, local probes, selection policy, visible fallback, execution proof, and fail-closed states.

      Evidence gate
      Selected lane completes and records inference
    4. 04
      Proposed

      Cross-platform host expansion

      Avalonia host, desktop evidence, mobile file access, memory and thermal state, packaging, signing, accessibility, and device tests.

      Evidence gate
      Signed artifacts and per-platform test matrix
    Review all roadmap records

    Source-of-truth panel

    Use the canonical owner for each kind of claim.

    GgufRuntime.com summarizes host-facing implications. It does not replace package documentation, release metadata, or portable exchange standards.

    PACKAGE / API

    LMRuntime.com

    Canonical package family, API, architecture, capability, evidence, release, and package-roadmap documentation.

    Open LMRuntime.com →
    RELEASE METADATA

    NuGet

    Canonical current package version, target frameworks, dependency graph, ownership, and package retrieval metadata.

    Open the package →
    HOST / UI

    GgufRuntime.com

    C# host applications, verified intake workflows, lifecycle presentation, tools, examples, evidence visualization, and UI roadmap.

    Review this site’s scope →
    PORTABLE CONTEXT

    UAIX.org

    UAI exchange, AI Memory, Project Handoff, conformance, evidence portability, and standards boundaries—not runtime authority.

    Open UAIX.org →
    SEARCH / ANSWER DISCOVERY

    Readable by people and machines

    Answer-first pages, route inventory, publication readiness, and advisory discovery files are aligned with visible public content and do not grant runtime authority.

    Review site discovery →

    Explicit from the first byte

    Start with a verified artifact and an explicit host boundary.

    Identify the model, disclose host policy, bound generation, pass cancellation, retain evidence, and keep every fallback visible.

    Open Getting StartedBuild a host configurationReview current status →