> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mirurobotics.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Overview

export const Framed = ({image, background, link, alt = "Framed content", borderWidth = "24px", outerRadius = "10px", innerRadius = "6px"}) => {
  const parseShorthand = value => {
    const values = String(value).trim().split(/\s+/);
    switch (values.length) {
      case 1:
        return [values[0], values[0], values[0], values[0]];
      case 2:
        return [values[0], values[1], values[0], values[1]];
      case 3:
        return [values[0], values[1], values[2], values[1]];
      default:
        return values.slice(0, 4);
    }
  };
  const isZero = v => parseFloat(v) === 0;
  const padding = parseShorthand(borderWidth);
  const outer = parseShorthand(outerRadius);
  const cornerMasks = [];
  if (isZero(padding[0]) && isZero(padding[3])) {
    cornerMasks.push(`radial-gradient(circle at 0% 0%, transparent ${outer[0]}, black ${outer[0]})`);
  }
  if (isZero(padding[0]) && isZero(padding[1])) {
    cornerMasks.push(`radial-gradient(circle at 100% 0%, transparent ${outer[1]}, black ${outer[1]})`);
  }
  if (isZero(padding[2]) && isZero(padding[1])) {
    cornerMasks.push(`radial-gradient(circle at 100% 100%, transparent ${outer[2]}, black ${outer[2]})`);
  }
  if (isZero(padding[2]) && isZero(padding[3])) {
    cornerMasks.push(`radial-gradient(circle at 0% 100%, transparent ${outer[3]}, black ${outer[3]})`);
  }
  const backgroundMask = cornerMasks.length > 0 ? cornerMasks.join(", ") : undefined;
  const innerImage = <img src={image} alt={alt} noZoom={link ? true : false} style={{
    display: "block",
    width: "100%",
    margin: 0,
    borderRadius: 0
  }} />;
  return <div style={{
    display: "inline-block",
    position: "relative",
    borderRadius: outerRadius,
    overflow: "hidden"
  }}>
            {}
            {background && <div style={{
    position: "absolute",
    inset: 0,
    backgroundImage: `url(${background})`,
    backgroundSize: "cover",
    maskImage: backgroundMask,
    WebkitMaskImage: backgroundMask,
    maskComposite: "intersect",
    WebkitMaskComposite: "source-in"
  }} />}
            {}
            <div style={{
    position: "relative",
    padding: borderWidth
  }}>
                <div style={{
    borderRadius: innerRadius,
    overflow: "hidden",
    lineHeight: 0
  }}>
                    {link ? <a href={link}>{innerImage}</a> : innerImage}
                </div>
            </div>
        </div>;
};

<Framed image="https://assets.mirurobotics.com/docs/v04/images/getting-started/signup-page.png" background="https://assets.mirurobotics.com/docs/v04/images/getting-started/background:dark.jpeg" link="https://app.mirurobotics.com/signup" borderWidth={"8px"} />

This quick-start guide walks through deploying your first configuration with Miru. Here's what we'll cover:

<Steps>
  <Step title="Creating a release">
    We'll define our config schemas, install the [Miru CLI](/developers/cli/install), and create a release in Miru.
  </Step>

  <Step title="Provisioning a device">
    Next, we'll provision a device by installing and provisioning the [Miru Agent](/developers/agent/overview) on your target machine.
  </Step>

  <Step title="Deploying config instances">
    Finally, we'll deploy config instances and make some edits.
  </Step>
</Steps>

If you don't already have an account, navigate to the [sign-up](https://app.mirurobotics.com/signup) page and follow the instructions.

## Concepts

To begin, let's define the primary concepts in Miru.

### Config instances

A **config instance**, also known as a **config** or an **instance**, is a set of parameters used to modify the behavior of code. Config instances are stored as text files (JSON or YAML), which applications parse into a structured format for consumption.

The following YAML file defines a config instance used to control a robot’s motion.

```yaml theme={null}
max_linear_speed_mps: 1.2
max_angular_speed_radps: 1.0
obstacle_avoidance_enabled: true
navigation_mode: balanced
telemetry:
  upload_interval_sec: 60
  heartbeat_interval_sec: 10
```

### Config schemas

A **config schema** defines the structure, types, and constraints of a config instance. It serves as a contract between code and configuration, ensuring that config instances are valid before being deployed to devices.

Below are some example schema definitions in the JSON Schema and CUE schema languages.

<CodeGroup>
  ```yaml JSON Schema expandable theme={null}
  x-miru-config-type: "mobility"
  $schema: "https://json-schema.org/draft/2020-12/schema"
  type: object
  properties:
    max_linear_speed_mps:
      type: number
      minimum: 0.1
      maximum: 5.0
      default: 1.2
    max_angular_speed_radps:
      type: number
      minimum: 0.1
      maximum: 3.0
      default: 1.0
    obstacle_avoidance_enabled:
      type: boolean
      default: true
    navigation_mode:
      type: string
      enum: [conservative, balanced, aggressive]
      default: balanced
    telemetry:
      type: object
      properties:
        upload_interval_sec:
          type: integer
          minimum: 10
          maximum: 300
          default: 60
        heartbeat_interval_sec:
          type: integer
          minimum: 1
          maximum: 60
          default: 10
      required:
        - upload_interval_sec
        - heartbeat_interval_sec
  required:
    - max_linear_speed_mps
    - max_angular_speed_radps
    - obstacle_avoidance_enabled
    - navigation_mode
    - telemetry
  ```

  ```cue CUE theme={null}
  @miru(config_type="mobility")
  max_linear_speed_mps: number & >=0.1 & <=5.0 | *1.2
  max_angular_speed_radps: number & >=0.1 & <=3.0 | *1.0
  obstacle_avoidance_enabled: bool | *true
  navigation_mode: "conservative" | "balanced" | "aggressive" | *"balanced"
  telemetry:
    upload_interval_sec: integer & >=10 & <=300 | *60
    heartbeat_interval_sec: integer & >=1 & <=60 | *10
  ```
</CodeGroup>

<Tip>
  If you don't already use a schema, we recommend starting with an [empty schema](/cfg-mgmt/primitives/schemas/overview#empty-schemas) — one that treats all config instances as valid.
</Tip>

### Config types

A **config type** is a named grouping of [config schemas](/cfg-mgmt/primitives/schemas/overview) and their [config instances](/cfg-mgmt/primitives/config-instances).

Every config instance and config schema belongs to exactly one config type. Config types gives the configurations in your fleet records a stable, human-readable identity (`Mobility`, `Perception`) that survives across the schemas and instances that come and go beneath it.

For example, a `Mobility` config type houses configs related to the robot's motion while a `Perception` config type houses configs related to the robot's perception. Each config type has its own versioned schema, which its config instances must adhere to depending on the release they are deployed under.

### Devices

A **device** is a machine to which config instances are deployed. This could be an NVIDIA Jetson, Raspberry Pi, industrial PC, or any other computer running your robot's application.

### Releases

A **release** is a version of software and its compatible config schemas.

Within a fleet of robots, multiple software versions may be deployed—each release defines which config schemas are valid for that version.

For example, software release `v1.7.0` might specify the following schemas:

| **Config Type** | **Schema Version** |
| --------------- | ------------------ |
| `Mobility`      | **SCH-FmoDN**      |
| `Perception`    | **SCH-3JcLq**      |
| `Manipulation`  | **SCH-HHDRn**      |

Before deploying config instances to a device, the deployment's release (`v1.7.0`) is used to verify that all required config instances are present and that each instance complies with the release's schemas.

### Deployments

A **deployment** is a set of config instances delivered to a device for consumption by your software.

Deployments tie together **config instances**, **releases**, and **devices** to simplify configuration management and delivery.

<Note>
  If these concepts are a bit fuzzy at the moment, don't worry! Seeing these concepts in action will solidify their meaning.
</Note>