# 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                          |

{% hint style="info" %}
**Legacy Jetson models** (TX2, TX1, Xavier NX) may not be supported. Performance will vary based on available GPU memory and CUDA capabilities.
{% endhint %}

***

## Requirements

* **JetPack 6.x** (latest recommended)
* **NVIDIA CUDA** (included with JetPack)
* **Chloros+ license** (required for CLI/SDK access)

## Installation

```bash
# 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](/chloros/linux-and-edge-computing/linux-installation.md).

***

## 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  |

{% hint style="success" %}
**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.
{% endhint %}

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](/chloros/processing-architecture/dynamic-compute-adaptation.md).

***

## 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 |

{% hint style="warning" %}
**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.
{% endhint %}

***

## 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:

```bash
# 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:

```bash
# 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:

```ini
# /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:

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

[Timer]
OnCalendar=hourly
Persistent=true

[Install]
WantedBy=timers.target
```

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

***

## Example Workflows

### Basic Jetson Processing

```bash
#!/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

```python
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

```bash
#!/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](https://www.mapir.camera/community/contact) for specific hardware recommendations for your deployment scenario.

***

## Next Steps

* [Linux Installation](/chloros/linux-and-edge-computing/linux-installation.md) — General Linux installation details
* [Dynamic Compute Adaptation](/chloros/processing-architecture/dynamic-compute-adaptation.md) — Full compute strategy reference
* [Processing Pipeline](/chloros/processing-architecture/processing-pipeline.md) — Understanding the 4-thread pipeline
* [CLI : Command Line](/chloros/cli.md) — Full CLI reference
* [API : Python SDK](/chloros/api-python-sdk.md) — Full SDK reference


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://mapir.gitbook.io/chloros/linux-and-edge-computing/nvidia-jetson-guide.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.