Justified Engine :: Developer Integration Manual & Process Pipe Contract

// DEVELOPER INTEGRATION MANUAL :: PROCESS I/O & C-ABI

Universal Integration Manual & Runtime Specification

Zero local HTTP servers. Zero background daemon listeners. Zero open TCP/IP sockets. The Justified Engine (justified_engine.exe / justified_engine) embeds directly into host applications via operating system process pipes (stdin / stdout) using Single-Line NDJSON framing, or directly in-process via native C-ABI dynamic linking under a decoupled Bring-Your-Own-Weights (BYOW) paradigm. Available with tri-platform parity for Windows 10/11 (CUDA), Enterprise Linux (POSIX), and macOS (Apple Silicon Metal).

                DUAL INTEGRATION TOPOGRAPHY: OUT-OF-PROCESS ISOLATED SHELL (NDJSON PIPES) OR IN-PROCESS C-ABI DYNAMIC LINKING
            

// SUBSTRATE EXECUTION INTERFACE :: MODE A

Mode A: Out-of-Process Shell (NDJSON Process Pipes)

Engineered for desktop software, Electron wrappers, and automation workers prioritizing total crash insulation. Spawn justified_engine.exe as an unmanaged child process from your parent runtime (.NET, Node.js, Electron, Python, C++, Go, or Rust). Point the required --model flag to any open-weights GGUF file or calibrated .jef_bin companion vault:

# Sub-Millisecond Hardware Healthcheck (Zero VRAM Allocation / Readiness Audit) justified_engine.exe --healthcheck # Production Process Invocation (Air-Gapped Perpetual Ed25519 License) justified_engine.exe --model "C:\Weights\qwen2.5-7b-instruct-q4_k_m.gguf" --pipe --license-file "license.key" # Development & Evaluation Invocation (Local Testing Sandbox) justified_engine.exe --model "C:\Weights\j8b_refactor_pro.jef_bin" --pipe --dev-mode

1. Substrate Healthcheck: Running with --healthcheck verifies OS virtual page tables, hardware acceleration capabilities, and driver bindings, returning diagnostic status in < 1.0 ms (0.42 ms verified) and exiting cleanly.

2. Ingress Stream (stdin): Write your single-line NDJSON prompt frame terminated strictly by a single newline character (\n). Ensure all internal carriage returns and linebreaks are escaped (\\n).

3. Egress Stream (stdout): The engine emits exactly one single-line JSON frame per execution cycle. All telemetry, status flags, and generated JSON fields are packed into this synchronous stdout line.

4. Epistemic Interception: If an input lacks sufficient contextual parameters, the engine emits a structured halt frame in < 1.0 ms without touching GPU memory:

{"halt_type":"DATA_INSUFFICIENT_HALT","void_count":1,"missing_keys":["auth_pin"],"message":"[DATA_INSUFFICIENT_HALT :: MISSING_PARAMETERS_DETECTED]"}

// SUBSTRATE EXECUTION INTERFACE :: MODE B

Mode B: In-Process C-ABI Dynamic Linking (Shared Memory)

Engineered for game engines (Unreal Engine, Unity), high-throughput financial systems, and native C/C++ applications requiring zero OS pipe serialization overhead. Link directly against justified_core.dll (Windows), libjustified_core.so (Linux), or libjustified_core.dylib (macOS) via the standardized 3-symbol C-ABI export surface:

// Native C/C++ In-Process Lifecycle (Initialization, Inference & Teardown) #include "justified_oem_cabi.h" #include <stdio.h> // 1. Initialize embedded runtime with model path & Ed25519 attestation int status = Justified_InitOEM( "C:\\Weights\\j8b_refactor_pro.jef_bin", "license.key", /* Pass NULL for local developer evaluation mode */ NULL /* NULL signals unrestricted offline Ed25519 token attestation */ ); if (status == JEF_SUCCESS) { // 2. Execute synchronous inference over native memory buffer char output_buffer[4096]; int bytes_written = Justified_ExecuteInference( "{\"prompt\":\"ping\"}", output_buffer, sizeof(output_buffer) ); if (bytes_written > 0) { printf("Response: %s\n", output_buffer); } // 3. Release pinned accelerator memory, transformer caches & mutex locks Justified_Free(); }

Direct Memory Exchange: Passes pointer blocks directly to the forward-pass scheduler, eliminating standard input/output string marshalling and achieving sub-millisecond execution handoffs.

Export Surface Parity: The export surface of justified_core.dll is strictly locked to three un-mangled symbols: Justified_InitOEM, Justified_ExecuteInference, and Justified_Free (aliased as Justified_ShutdownOEM).

// DISTRIBUTION GOVERNANCE :: CODE SIGNING & GATEKEEPERS

Cryptographic Provenance & OS Gatekeeper Verification

The Justified Engine is an unmanaged, closed-source B2B inference runtime distributed directly to software engineers and enterprise platforms. To ensure strict transit integrity without charging or passing along recurring commercial Certificate Authority (CA) taxes, our binaries are signed directly through an Azure Key Vault FIPS 140-2 Level 3 HSM with RFC 3161 SHA-256 DigiCert timestamping.

Enterprise Transparency Notice: Our code-signing certificate (Subject: CN=CLIGetDefaultPolicy, Thumbprint: 379A208A4223EE53525B0BBAE9FC4A7FCE76DE9C) is a self-contained private root. Because it is not enrolled in Microsoft's commercial consumer trust store, browser downloads will trigger a standard Windows SmartScreen "Unknown Publisher" prompt. This is expected by design for bare-metal B2B infrastructure.

Windows 10 / 11 (SmartScreen & WDAC)

Browser downloads apply an NTFS alternate data stream known as the Mark of the Web (Zone.Identifier = 3). To clear it immediately via PowerShell:

Unblock-File .\justified_engine_setup.msi Unblock-File .\justified_engine.exe Get-AuthenticodeSignature .\justified_engine.exe

Enterprise Fleet Deployments: Import justified_wdac_policy.xml into your Windows Defender Application Control (WDAC) policy, or inspect our 2-Click SmartScreen Guide.

Enterprise Linux (POSIX ELF64)

Linux targets execute with zero external runtime dependencies. Make executable and run natively via standard bash terminal:

chmod +x bin/justified_engine ./bin/justified_engine --healthcheck ./bin/justified_engine --model weights.gguf --pipe --dev-mode

Dynamic Library Linking: Export LD_LIBRARY_PATH=./bin:$LD_LIBRARY_PATH to link against libjustified_core.so.

macOS (Apple Silicon Metal)

Apple Silicon kernels mandate Mach-O binary integrity. Binaries ship with an embedded ad-hoc signature. If downloaded through a web browser, clear the quarantine attribute via terminal:

xattr -d com.apple.quarantine bin/justified_engine chmod +x bin/justified_engine

Terminal downloads via curl or CI/CD runners bypass quarantine flags automatically.

Mode B :: OEM In-Process Integration

When you license justified_core.dll, libjustified_core.so, or libjustified_core.dylib to embed into your commercial desktop software or game engine:

The dynamic library loads directly in-process via LoadLibrary / dlopen with zero SmartScreen intervention.
Your build pipeline signs your final application installer with your own corporate certificate.
Engine validity is enforced in-register via offline Ed25519 cryptographic token attestation.

// ZERO-RISK LOCAL PROTOTYPING

Local Developer Evaluation Mode (--dev-mode)

You do not need an active commercial license key to verify hardware integration or test local process pipes during development sprints. Invoking the engine with --dev-mode unlocks offline execution with an appended diagnostic watermark:

{ "status": "SUCCESS", "code": "OPT-001", "response": "Pong!", "tokens_generated": 3, "prefill_ms": 79.90, "tok_per_sec": 117.44, "_eval_watermark": "UNLICENSED_DEVELOPMENT_BUILD" }

// LANGUAGE WRAPPERS & SDK KITS

Drop-In Language Wrappers

Copy-paste pre-built, production-tested process wrappers directly into your application codebase. Fully compatible with Windows, Linux, and macOS:

JustifiedWorkerEngine.cs

C# / .NET 8 one-shot process pipe wrapper with leak-safe cancellation traps and dynamic license resolution.

↓ GET JustifiedWorkerEngine.cs

JustifiedAdvancedEngine.cs

High-throughput C# .NET 8 persistent ring buffer daemon with sub-10ms warm re-entry and real-time stderr draining.

↓ GET JustifiedAdvancedEngine.cs

justified_engine.js

Node.js / Electron child process pipe runner with EPIPE exception guards and natural EOF stream closure.

↓ GET justified_engine.js

justified_engine.ts

Strongly typed TypeScript process pipe wrapper with FIFO queue alignment and license parameter separation.

↓ GET justified_engine.ts

justified_oem_cabi.h

C99-compliant header defining the 3-symbol export surface for Mode B shared-memory in-process linking.

↓ GET justified_oem_cabi.h

DOWNLOAD COMPLETE SDK BUNDLE (.ZIP) HARDWARE COMPATIBILITY PROBE (.PS1)