Release v0.2.0

Neat Library v0.2.0

Neat Library v0.2.0 brings the application-facing Neat runtime and APIs onto the Platform 2.1.2 generation. This release focuses on a more reliable development experience: safer installation, clearer SDK and DevKit setup, stronger runtime measurement, improved live-video graph behavior, and better alignment across the Neat Library, LLiMa, Internals, Insight, and the Neat Development Environment.

Neat Library is the recommended starting point for building Modalix applications. It provides the higher-level C++ and Python APIs for models, graphs, pipelines, media, runtime diagnostics, and DevKit deployment, while lower-level components such as LLiMa and Internals remain packaged underneath the same Neat ecosystem.

Highlights

Built For Platform 2.1.2

This release updates Neat Library for the Platform 2.1.2 line:

• Package version moves to 0.2.0.
• Platform compatibility moves to 2.1.2.
• Package metadata is aligned with the current Vulcan artifact flow.
• LLiMa package handling now includes the CLI Debian package in the install bundle so GenAI runtime tooling is available alongside the core and development packages.

Safer Install And Update Flow

Neat Library now includes a secondary platform compatibility guard in the installer. Before modifying Python packages, apt packages, or SDK sysroot contents, the installer verifies that the package platform version matches the target environment:

• In the Neat Development Environment, it checks /etc/sdk-release.
• On Modalix DevKits, it checks /etc/buildinfo and DISTRO_VERSION.
• If versions do not match, install stops before changing the system.

This complements the compatibility checks already performed by sima-cli and protects workflows where the installer is run directly, including DevKit Sync from inside the SDK.

Better Runtime Measurement And Graph Diagnostics

v0.2.0 improves the runtime visibility needed to tune real applications:

• End-to-end latency and throughput measurement are available through production-safe defaults.
• Deeper plugin latency tracing remains opt-in for focused profiling.
• Graph run export and metric schemas are expanded for more consistent benchmark and runtime reports.
• Benchmark reporting is hardened so incomplete, dropped, or unreliable measurements fail clearly instead of producing misleading results.
• Prepared runtime bridge ABI checks catch incompatible runtime assumptions earlier.

These updates make it easier to move from “the pipeline runs” to “the pipeline is measurable, explainable, and ready to optimize.”

Stronger Live Video And Multi-Stream Behavior

This release improves graph behavior for live media workloads:

• Adds realtime graph-link policy support for live multi-stream fan-in, keeping the latest frame per stream without unnecessary upstream blocking.
• Preserves FPS metadata through Input::output_spec() and graph boundary input conversion.
• Updates raw VideoSender graph construction to add explicit raw and NV12 caps before hardware H.264 encoding.
• Stabilizes RTSP and decoder-related validation, including decoder quality comparison against a shared captured input stream.

The result is more predictable media negotiation and better behavior in graph-based video applications.

SDK, PyNeat, And Cross-Build Improvements

The 0.2.0 release includes SDK-focused build and packaging updates:

• Improves eLxr SDK cross-build behavior by selecting a host-runnable Python while using target Python headers from the SDK sysroot.
• Retags PyNeat wheels for the target Python ABI in SDK builds.
• Pins nanobind for more reproducible Python extension builds.
• Keeps exported Core CMake packages relocatable and tightens installed CMake dependency handling.
• Improves stale package repair handling during install retries.

These changes reduce friction when building and consuming Neat Library from the SDK across host architectures.

Clearer Documentation And Setup Guidance

The documentation has been reorganized around the way developers actually get started:

• A dedicated Neat Development Environment section covers installing the SDK, pairing with a DevKit, and running on hardware.
• A dedicated Neat Library section covers installing or updating Core, using PyNeat, and inspecting an environment with the Neat CLI.
• SDK install examples now use the correct GHCR tag syntax, such as ghcr:sima-neat/sdk:v2.1.2.
• Neat Library release examples use the correct tag form, such as core@v0.1.0.
• Insight documentation is assembled through autodoc so the Insight repository remains the source of truth.
• Model Zoo and getting-started navigation were refreshed for the current developer flow.

Install

Install or update Neat Library with sima-cli:

sima-cli neat install core@v0.2.0

To download only the PyNeat wheel:

sima-cli neat install core@v0.2.0 -t pyneat

Use this release with the matching Platform 2.1.2 / Neat Development Environment 2.1.2 line.

Compatibility Notes

• Compatible platform release: 2.1.2.
• Recommended SDK line: Neat Development Environment 2.1.2.
• This release should not be mixed with the Platform 2.0.0 / Neat Library 0.1.x line except for explicit compatibility testing.
• Codec service lifecycle handling has been updated for the Internals change where neat-runtime owns the Linux encoder and decoder services. When those services are present on a DevKit, the installer stops them before replacement and restarts/verifies them after install.

Known Issues

Issue	Impact	Workaround / Recommendation	Status
#392 Native C++ application builds can fail on DevKit because some public development dependencies may be missing.	DevKit-native C++ app builds may fail when consuming the installed sima-neat CMake package.	Use Neat Development Environment 2.1.2 for C++ application builds. It is more performant and provides the integrated SDK/sysroot workflow.	Planned for the next release. See the linked issue for technical details.

Validation

Release readiness was based on the successful develop, documentation, metadata, and release-promotion CI runs referenced in the release PRs. Validation covered package metadata generation, docs build, runtime/NV12 fixes, benchmark/test updates, and release hygiene checks.

Included PRs

• #375 - Add Insight autodoc source
• #376 - Merge 2.1.x preparation work into develop
• #378 - Refresh and restructure getting-started docs
• #379 - Port NV12 runtime, benchmark, graph-link, and decoder fixes
• #380 - Guard Neat installs against incompatible SDK/platform versions
• #381 - Include package manifest in Core package metadata
• #382 - Promote Neat Library develop for v0.2.0
• #385 - Include the LLiMa CLI package in the install bundle
• #388 - Update DevKit installer behavior for Internals codec services
• #389 - Fix SDK GHCR install examples
• #390 - Fix Neat Library release tag examples
• #393 - Prepare the final v0.2.0 release promotion

Full Changelog: v0.1.0...v0.2.0

Neat Library v0.1.0

This first Neat Library release introduces the application framework for building AI pipelines on SiMa.ai Modalix. Neat gives developers a typed C++ and Python programming model for turning compiled model packages, media sources, preprocessing, inference, postprocessing, and application logic into repeatable edge AI pipelines.

Instead of wiring low-level runtime pieces by hand, developers can work with higher-level primitives such as Model, Graph, Run, Tensor, and Sample, then move from a single model invocation to a reusable production pipeline using the same API family.

Platform compatibility: Neat Library v0.1.0 is compatible with the SiMa.ai platform release 2.0.0. Use this release with the matching 2.0.0 SDK, runtime, and DevKit software line.

Installation

Neat Library v0.1.0 is included in the Neat Development Environment, also known as the Neat SDK, for the 2.0.0 release.

To install Neat Library v0.1.0 on any Modalix DevKit running the 2.0.0 platform release, run:

sima-cli neat install core@v0.1.0

Why This Release Matters

Neat v0.1.0 establishes the foundation for application development on Modalix:

• A composable graph API for constructing deterministic AI and media pipelines.
• C++20 APIs for production applications and Python bindings for fast development, testing, and automation.
• A Model workflow for loading compiled model archives and reusing model routes for preprocessing, inference, postprocessing, or full end-to-end execution.
• Typed tensor and sample contracts for shape, layout, dtype, storage, routing, timestamps, and stream metadata.
• Runtime diagnostics and measurement APIs for latency, throughput, plugin timing, counters, and optional board power reporting.
• Documentation and tutorials that cover first inference, asynchronous execution, benchmarking, preprocessing, multi-input models, RTSP ingest, graph composition, and GenAI workflows.

What Is Included

Core Application APIs

• Public C++ and Python API surfaces for models, graphs, nodes, runs, tensors, samples, and runtime options.
• One-shot run(...) execution and reusable build(...) / push(...) / pull(...) execution for synchronous and asynchronous application flows.
• Model route composition so compiled model packages can be used as complete routes or as reusable graph fragments.
• Improved graph build behavior, stage execution, strict sync behavior, backpressure handling, timeout handling, metadata reporting, and deterministic compilation paths.

PyNeat Python Bindings

• A production-oriented pyneat package backed by nanobind.
• Python access to graph, model, runtime, tensor, sample, benchmark, and GenAI types.
• NumPy and PyTorch interoperability through DLPack-based tensor conversion.
• Release fixes for Python enum exposure, including FormatSpec binding behavior.

Runtime, Media, and Preprocessing

• Typed input/output nodes, model execution nodes, preprocessing nodes, media source and output paths, and transport-oriented pipeline components.
• RTSP and still-image input coverage for application and tutorial workflows.
• Multi-ROI preprocessing support and expanded validation for preprocessing and ROI contracts.
• Static contract handling for runtime nodes, including model output and detection decode paths.
• GStreamer initialization, plugin diagnostics, TensorBuffer behavior, and runtime bridge integration improvements.

GenAI and LLiMa Integration

• Public GenAI headers, types, server integration paths, and tutorials for LLM, VLM, ASR, and graph-composed GenAI workflows.
• Release metadata that tracks LLiMa as a Neat dependency for the same release line.
• Documentation updates that use external-facing GenAI terminology consistently.

Documentation and Tutorials

• A redesigned documentation structure covering Getting Started, model compilation, app development, API reference, tools, tutorials, and compatibility guidance.
• C++ and Python tutorials that are self-contained and easier to copy into real projects.
• Tutorial coverage for model execution, async inference, benchmarking, image preprocessing, detection outputs, multi-input models, RTSP streams, production graph design, and GenAI usage.
• Generated API reference and search integration for the Developer Center experience.

Packaging and Release Infrastructure

• Manifest-driven package metadata for Neat Library 0.1.0 and platform compatibility 2.0.0.
• Package metadata support for platform compatibility so downstream installs can avoid mixing artifacts from different platform lines.
• Release artifact publishing, install routing, docs deployment, and tag-aware latest package resolution.

Notable Fixes and Refinements

• Fixed Python FormatSpec enum bindings before the release cutoff.
• Improved benchmark support for multi-input models and Python benchmark access.
• Fixed GenAI server teardown behavior so model registry cleanup releases MLA memory before shutdown.
• Improved graph direct-source and preprocessing sizing behavior.
• Fixed docs links, generated documentation routing, autodoc imports, and mobile documentation navigation.
• Added tag-release handling so release artifacts can publish the expected latest.tag metadata for install tools.

Known Issues

Issue	Impact	Workaround	Status
#396 Neat Library v0.1.0 install bundle does not include the LLiMa CLI package.	Installations from core@v0.1.0 include the LLiMa runtime and development packages without the matching CLI package.	Upgrade to Neat Library v0.2.0 with Neat SDK 2.1.2.	Being considered for the next 0.1.x patch release.

Getting Started

Install Neat Library with the package set that matches platform release 2.0.0, then use the documentation tutorials as the recommended path from first model run to production graph composition.

For most applications, start with the Model API, then move to Graph when you need to combine model routes with media ingest, preprocessing, custom nodes, multi-stream execution, diagnostics, or GenAI components.

Release Scope

This is the first Neat Library release. It defines the initial public API and packaging baseline for external developers building on SiMa.ai Modalix with platform release 2.0.0.

Selected change references: #340, #339, #336, #333, #331, #330, #325, #317, #315, #313, #304, #299, #295, #264, #263, #256.