NVIDIA Jetson Guide

Chloros on NVIDIA Jetson enables multispectral image processing at the edge — in the field, on UAVs, and in remote installations. Chloros automatically detects your Jetson model and optimizes its processing strategy for your hardware.

---

Supported Jetson Models

Model	RAM	Processing Strategy	Recommended Use
Jetson AGX Orin	32-64GB shared	GPU_PARALLEL (4 workers)	Maximum performance, large datasets
Jetson Orin NX	8-16GB shared	GPU_PARALLEL (3 workers, 16GB) / GPU_SINGLE (8GB)	Primary recommendation for airborne and field deployment
Jetson Orin Nano	8GB shared	GPU_SINGLE (1 worker)	Entry-level edge compute
Jetson Nano	4-8GB shared	GPU_SINGLE (1 worker)	Entry-level, memory-constrained

Legacy Jetson models (TX2, TX1, Xavier NX) may not be supported. Performance will vary based on available GPU memory and CUDA capabilities.

---

Requirements

• JetPack 6.x (latest recommended)

• NVIDIA CUDA (included with JetPack)

• Chloros+ license (required for CLI/SDK access)

Installation

# Install the JetPack 6 .deb package
sudo dpkg -i chloros-arm64-jp6.deb

# Verify installation
chloros-cli --version

# Install Python SDK (optional)
pip install chloros-sdk

# Run system diagnostics
chloros-cli selftest

For general Linux installation details, see Linux Installation.

---

Dynamic Compute Adaptation on Jetson

Chloros automatically detects your Jetson model and selects the optimal processing strategy. No manual tuning is required.

How It Works

At startup, Chloros profiles your system:

1. Detects the Jetson model via /proc/device-tree/model

2. Reads available GPU/shared memory

3. Selects a processing strategy (GPU_PARALLEL, GPU_SINGLE, or CPU_PARALLEL)

4. Sets worker count, pipeline type, and memory allocation automatically

Per-Model Behavior

Jetson Model	Strategy	Workers	Pipeline	Concurrency
Jetson Nano 8GB	GPU_SINGLE	1	tiled_gpu (memory-efficient)	Serialized
Jetson Orin Nano 8GB	GPU_SINGLE	1	tiled_gpu	Serialized
Jetson Orin NX 8GB	GPU_SINGLE	2	tiled_gpu	Serialized
Jetson Orin NX 16GB	GPU_PARALLEL	3	fused_gpu (full GPU path)	Concurrent
Jetson AGX Orin 32-64GB	GPU_PARALLEL	4	fused_gpu	Concurrent

Jetson Orin NX 16GB is the sweet spot for edge deployment — it receives the GPU_PARALLEL strategy with 3 concurrent workers, delivering real parallel GPU processing in a compact form factor.

The key difference between platforms is memory. A Jetson Nano with 8GB of shared memory must process images one at a time using a memory-efficient tiled approach, while an Orin NX with 16GB can run 3 images through the GPU simultaneously using the higher-throughput fused pipeline.

For the complete compute adaptation reference, see Dynamic Compute Adaptation.

---

Thermal Management

Jetson devices have limited thermal headroom, especially in enclosed or airborne deployments. Chloros includes automatic thermal monitoring and throttling:

Temperature	Action
< 70°C	Normal operation — full processing speed
70°C (Warning)	Reduce batch size automatically
80°C (Critical)	Aggressive throttling — lower concurrency
90°C (Shutdown)	Stop GPU processing entirely — cool down required

Ensure adequate ventilation and heat sinking for sustained processing, especially in enclosed field enclosures or airborne systems. Thermal throttling will reduce processing throughput to protect the hardware.

---

Memory Management

Jetson devices use unified memory — the GPU and CPU share the same physical RAM. This means the reported VRAM (e.g., 15.3GB on Orin NX 16GB) is not dedicated GPU memory; it's shared with the operating system and other processes.

Swap Recommendations

For large datasets or Texture Aware debayer processing, Chloros may recommend creating swap space:

# Check current memory and swap
free -h

# Create a swap file (example: 8GB)
sudo fallocate -l 8G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

# Make persistent across reboots
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

Memory estimates per image:

• Standard debayer: ~10 MB per image

• Texture Aware debayer: ~15 MB per image

Chloros automatically calculates required memory based on your dataset size and warns you if swap is recommended.

OOM (Out of Memory) Fallback

If an out-of-memory condition is detected during processing:

1. Chloros automatically reduces the GPU worker count

2. Falls back from fused_gpu to tiled_gpu pipeline (more memory-efficient)

3. Continues processing at reduced throughput rather than crashing

---

Field Deployment

Power Considerations

Jetson Model	Typical Power Draw	Notes
Jetson Nano	5-10W	USB-C or barrel jack
Jetson Orin Nano	7-15W	DC barrel jack
Jetson Orin NX	10-25W	DC barrel jack
Jetson AGX Orin	15-60W	USB-C PD or barrel jack

Plan your power budget for sustained processing — peak power draw occurs during GPU-intensive Thread 3 (Processing).

Storage Recommendations

• NVMe SSD strongly recommended for arm64 deployments

• SD cards are too slow for processing — use as boot media only

• Plan for 2-3x your raw image data size for processed output

Headless Operation via SSH

Chloros CLI is ideal for headless Jetson deployments:

# SSH into the Jetson
ssh user@jetson-hostname

# Process a dataset
chloros-cli process /data/datasets/flight001 --format tiff-32

# Monitor export progress
chloros-cli export-status

Automated Processing with systemd

Create a systemd service for automated processing:

# /etc/systemd/system/chloros-process.service
[Unit]
Description=Chloros Automated Processing
After=network.target

[Service]
Type=oneshot
User=chloros
ExecStart=/usr/bin/chloros-cli process /data/incoming --output /data/processed
StandardOutput=append:/var/log/chloros-process.log
StandardError=append:/var/log/chloros-process.log

[Install]
WantedBy=multi-user.target

Pair with a systemd timer for scheduled processing:

# /etc/systemd/system/chloros-process.timer
[Unit]
Description=Run Chloros Processing Every Hour

[Timer]
OnCalendar=hourly
Persistent=true

[Install]
WantedBy=timers.target

sudo systemctl enable chloros-process.timer
sudo systemctl start chloros-process.timer

---

Example Workflows

Basic Jetson Processing

#!/bin/bash
# Process a drone flight dataset on Jetson
chloros-cli process /data/flights/flight_042 \
    --output /data/processed/flight_042 \
    --format tiff-32 \
    --indices NDVI NDRE GNDVI

Python SDK on Jetson

from chloros_sdk import ChlorosLocal

with ChlorosLocal() as chloros:
    chloros.create_project("field_survey_042")
    chloros.import_images("/data/flights/flight_042")
    chloros.configure(
        indices=["NDVI", "NDRE", "GNDVI"],
        export_format="TIFF (32-bit, Percent)",
        reflectance_calibration=True
    )
    chloros.process(mode="parallel")

print("Processing complete!")

Batch Processing Multiple Flights

#!/bin/bash
# Process all flight datasets in a directory
for flight in /data/flights/*/; do
    name=$(basename "$flight")
    echo "Processing $name..."
    chloros-cli process "$flight" \
        --output "/data/processed/$name" \
        --format tiff-32 \
        --indices NDVI NDRE
    echo "Completed $name"
done

---

Recommended Jetson Systems for Field Use

For field and airborne deployments, consider these Jetson Orin NX 16GB carrier board options:

• Airborne/drone: Systems with vibration rating (MIL-STD), lightweight (under 300g), passive cooling

• Rugged field: IP67/IP69K waterproof enclosures with PoE GigE camera connectivity

• Minimal/budget: Developer kits with add-on enclosures

Contact MAPIR Support for specific hardware recommendations for your deployment scenario.

---

Next Steps

• Linux Installation — General Linux installation details

• Dynamic Compute Adaptation — Full compute strategy reference

• Processing Pipeline — Understanding the 4-thread pipeline

• CLI : Command Line — Full CLI reference

• API : Python SDK — Full SDK reference