Skip to main content

Development Workflow

This page is a high-level map of how you actually use SiMa.ai Neat day to day. Each step links into a deeper page when you are ready.

The Loop​

A typical Neat development cycle looks like this:

  1. Install — get the sima-neat package (and optionally the pyneat Python bindings) on your host or device.
  2. Try Hello Neat — confirm the library is wired up by compiling a minimal example.
  3. Pick a compiled model — Neat consumes a model package (.tar.gz, often called an MPK). You can grab one from the Model Zoo or compile your own with the SiMa.ai toolchain.
  4. Author a Model / Session / Run — load the model, compose the session, and execute it synchronously or asynchronously.
  5. Run and inspect — feed inputs, pull outputs, and use SessionReport / Run::report() to verify behavior.
  6. Iterate with tutorials — graduate from a single inference to pipelines, multi-input models, multi-stream graphs, and production-grade error handling.
  7. Deploy — link your application against the installed Neat library on the target device.

Core Concepts at a Glance​

The Programming Model breaks each of these down in depth. At a glance:

  • Model — load a compiled model package and expose it as a runnable unit.
  • Run — execute synchronously (run) or asynchronously (push / pull).
  • Node — the atomic building block of a graph.
  • Graph — hybrid DAG runtime for combining model stages and custom logic.
  • Tensor and Sample — the payload and metadata envelope passed between stages.

If you only learn one page first, start with the Inference Workflow overview — it ties Model, Graph, and Run together end to end.

Where to go next​

Step-by-step entry points for new users:

  • Installation — pick the right setup path for your environment.
  • Build — build Neat from source with build.sh (contributor workflow).
  • Hello Neat! — minimal CMake application that links against the installed library.
  • Tutorials — guided chapters that scale from "first model" to "production pipeline".

Reference material for when you need depth:

What you write vs. what Neat provides​

Neat owns the runtime: model loading, validation, pipeline construction, scheduling, teardown, and diagnostics. You own the application code that wires inputs to outputs and reacts to results. The boundary is the public API in include/, which is treated as stable — you can upgrade Neat without rewriting your application.

If you only remember three lines of code from Neat, remember these:

simaai::neat::Model   model(mpk_path);
simaai::neat::Sample  out  = model.run(input, /*timeout_ms=*/2000);
simaai::neat::Mapping view = out.tensor->map_read();  // inspect the output bytes

Everything else in this documentation — pipelines, graphs, async queues, multi-stream — is a controlled expansion of that core three-line story.