jumpstation

JumpBundle Format

What Is a JumpBundle?

A JumpBundle is the universal AI deployment artifact for the JumpStation ecosystem. Every AI application that runs on a JumpStation device — from a keyword spotter on an Arduino UNO to a vision model on an Orion O9 — is packaged and deployed as a JumpBundle.

JumpBundles are produced by the JumpStation targeting suite (profiler → target selector → distillation → builder) and consumed by the runtime on any device in the catalog. The targeting suite ensures the bundle contains model weights at the correct precision for the declared target hardware; the runtime enforces compatibility at install and launch time.

Bundle Structure

A JumpBundle is a directory (or .jbundle zip archive) with the following layout:

my-model.jbundle/
├── manifest.json       # Required: bundle metadata, model info, device requirements
├── model/
│   └── weights.tflite  # Required (if AI bundle): optimized model weights
├── icon.png            # Required for launcher-visible bundles
├── main.py             # Required: entry point
├── assets/             # Optional: images, audio, fonts
└── data/               # Optional: read-only bundled data (labels, configs)

For microcontroller targets (Pico, UNO), the bundle is a firmware image + config rather than a Python package. The manifest format is identical; only the entry point and weights format differ.

manifest.json

The manifest is the heart of a JumpBundle. It is validated against core/jumpbundle/schema.json at build and install time.

Example

{
  "id": "com.zachtech.plant-classifier",
  "name": "Plant Classifier",
  "version": "1.0.0",
  "author": "Zachtech",
  "description": "MobileNetV3 INT8 plant species classifier. Targets Pico via TFLite Micro.",
  "entry": "main.py",
  "targets": ["pico"],
  "requirements": {
    "min_ram_kb": 192,
    "storage_kb": 512,
    "inference_backend": "tflite_micro"
  },
  "icon": "icon.png",
  "category": "tool",
  "model": {
    "framework": "tflite_micro",
    "precision": "int8",
    "weights": "model/weights.tflite",
    "input_shape": [1, 96, 96, 3],
    "output_shape": [1, 50],
    "flops": 15200000,
    "peak_ram_kb": 148,
    "latency_ms_turbo": 1.2,
    "targeting_version": "0.1.0"
  }
}

Manifest Fields

Field Type Required Description
id string Yes Reverse-DNS unique identifier
name string Yes Display name shown in launcher
version string Yes Semantic version string
author string Yes Publisher or individual name
description string No Short description for launcher
entry string Yes Entry point file, relative to bundle root
targets array Yes Device class names this bundle supports
requirements object Yes Hardware requirements (see below)
icon string Yes Path to icon file within bundle
category string No One of: game, tool, education, media, system
rating string No Content rating: E, E10, T
model object No AI model metadata. Present whenever the bundle contains ML inference.

requirements Object

Field Type Description
min_ram_kb int Minimum available RAM in kilobytes
storage_kb int Estimated storage footprint in kilobytes
inference_backend string Required backend: tflite, tflite_micro, onnx, dx_m1, orion_npu
display.min_width int Minimum display width in pixels (UI bundles only)
display.min_height int Minimum display height in pixels (UI bundles only)
display.color bool Whether a color display is required
input array Required input types: buttons, touch, keyboard, gamepad
connectivity array Optional: wifi, bluetooth, serial

model Object

Field Type Description
framework string Inference framework: tflite, tflite_micro, onnx, pytorch_mobile, dx_m1, orion_npu
precision string Weight precision: fp32, fp16, int8, int4
weights string Path to weights file, relative to bundle root
input_shape array Input tensor shape (integers; -1 for dynamic)
output_shape array Output tensor shape
flops int Approximate FLOPs per inference, measured by the JumpStation profiler
peak_ram_kb int Peak RAM during inference in KB, measured by the profiler
latency_ms_turbo float Measured inference latency on Turbo DX-M1 in ms
targeting_version string Version of the JumpStation targeting suite that produced this bundle

Building a JumpBundle

The canonical workflow is to produce a JumpBundle through the targeting suite:

# 1. Profile the model and select a target
python core/targeting/profiler.py --model ./my_model.onnx --output ./profile.json
python core/targeting/target_selector.py --profile ./profile.json
# -> outputs: target = "pico", recommended precision = "int8"

# 2. Distill and quantize for the selected target
python core/distillation/quantizer.py --model ./my_model.onnx --target pico --output ./model/weights.tflite

# 3. Package the bundle
python core/jumpbundle/builder.py --source ./my-app --output ./dist/my-app.jbundle

The builder will:

  1. Validate manifest.json against the schema (including model field if present)
  2. Verify the weights file declared in model.weights exists at the declared path
  3. Run UI assets through the Silhouette pipeline if --process-assets is passed
  4. Verify the entry point exists
  5. Package into a .jbundle archive (zip with manifest at root)

Installation

JumpBundles are installed to the device via:

The launcher scans the bundles/ directory at boot and re-validates all manifests. Invalid or incompatible bundles are flagged but not removed automatically.

Compatibility

A bundle is considered compatible with a target device if:

  1. The device class name appears in targets
  2. All requirements fields are satisfied by the device profile
  3. The bundle passes schema validation

The runtime will refuse to launch an incompatible bundle and surface an error in the launcher.

Further Reading