Developer Documentation

SentariX Prime™ SDK

The SentariX Prime™ SDK provides a sealed temporal stability layer for real time systems. This page describes the public interface, usage pattern, and integration expectations for teams evaluating Prime under NDA.

SDK overview

SentariX Prime™ is delivered as a compiled, sealed SDK that exposes a small, deterministic interface. It introduces a stable perceived timeline that systems can align to, while all internal logic remains fully contained inside the binary.

Sealed temporal layer

Prime runs as an internal temporal stability layer. Teams use its outputs without managing configuration, parameters, or internal behavior.

Single input, single output

Systems feed a raw timing measurement into Prime and receive a canonical timestep in microseconds. That timestep becomes the reference for time based logic and user perception code.

No configuration knobs

Prime is designed as a fixed, tuned layer. There are no public configuration options for developers to adjust, preventing accidental changes that could weaken stability guarantees.

Public API

The SDK exposes the same conceptual interface across language bindings. A SentariX instance is created, receives timing samples, and returns a timestep that is used for all user perception and time dependent logic.

Core operations

Every binding of the SentariX Prime™ SDK provides the following core operations:

Create a new SentariX instance
Update with a raw timing sample in microseconds
Step to obtain the canonical timestep in microseconds
Reset to clear internal state while keeping configuration

Diagnostics (optional)

For evaluation and monitoring, the SDK also exposes safe diagnostics such as the last timing sample and the masked perceived timeline. These are optional to use and do not reveal internal implementation details.

Python SDK

The Python binding wraps the compiled SentariX core in a thin, sealed interface. It is provided as a wheel for supported Python versions on Windows and Linux.

Public class

The main entry point is a single class:

SentariX()

Public API:
    sx.update(rtt_us: int)
    step = sx.step_us()
    sx.reset()

Diagnostics:
    sx.last_rtt_us
    sx.perceived_us

Typical usage

In a real time loop (for example a game, simulation, or control system), the integration pattern is:

# Pseudocode; import path depends on your evaluation build
sx = SentariX()

while running:
    rtt_us = read_current_timing_sample()   # microseconds
    sx.update(rtt_us)

    step_us = sx.step_us()                  # canonical timestep (µs)

    # Use step_us for any logic tied to perceived time:
    # - movement and input feel
    # - simulation stepping
    # - user-facing timing behavior
    update_system_with(step_us)

There are no parameters to tune. The same code path runs for every user and every environment.

C# and engine integration

For engine and runtime integrations, SentariX Prime™ is also exposed as a sealed C# wrapper around the native binary. This allows engines such as Unity or custom C# stacks to use the same temporal stability layer through a familiar interface.

C# wrapper

The C# binding mirrors the Python API in structure:

var sx = new SentariX();

while (running)
{
    ulong rttUs = ReadCurrentTimingSample();
    sx.Update(rttUs);

    long stepUs = sx.StepUs;
    ApplyStepToPerception(stepUs);
}

// Optional:
sx.Reset();

Diagnostics such as LastRttUs and PerceivedUs are also available for monitoring and analysis during evaluation. :contentReference[oaicite:0]{index=0}

Binary delivery

Engine integrations receive a compiled native library and a managed wrapper. The binary remains sealed; only the public methods and properties described here are intended to be used.

Integration pattern

Prime is designed to fit into existing real time pipelines without structural changes. The integration pattern is consistent across languages and environments.

1. Create a SentariX instance

Construct a single SentariX instance for the relevant loop or context. No configuration or tuning is required.

2. Feed timing samples

On each tick or frame where timing is updated, call update(rtt_us) or the equivalent binding method, passing a timing measurement in microseconds.

3. Use the canonical timestep

On each loop iteration, read the canonical timestep via step_us() or the equivalent property. Use this value for all logic tied to perceived time, ensuring a consistent feel across conditions.

Versioning and developer assurance

SentariX Prime™ is versioned and delivered as a sealed SDK intended for long term stability. Evaluation builds are provided under NDA and follow a clear, predictable update model.

Versioning

The SDK is released with explicit version identifiers. Interfaces are kept stable, with changes communicated through release notes and evaluation updates.

Current evaluation version: 1.0.0

Developer assurance

Teams integrating Prime can expect:

A small, deterministic public interface
No breaking changes to the core API within a given major version
Sealed binaries with no requirement to manage internals
Clear guidance for integration into real time loops

Operation model

Prime operates locally within your system. It does not transmit or store external data, and all computation remains under your infrastructure’s control.

Evaluation and support

Access to the SentariX Prime™ SDK is provided on a selective basis under NDA. Teams interested in evaluation, engine integration, or production use can reach out directly.

Contact SentariX

For developer specific inquiries, include a brief overview of your system, target environment, and how you are considering Prime. This helps align evaluation and integration discussions from the start.