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

# Get Started with ANX Labs Dev Module

> Set up your ANX dev module, install the ANX toolchain, flash OS firmware, and run your first example application in under 15 minutes.

This guide walks you through everything you need to go from an unboxed ANX dev module to a running firmware example in under 15 minutes. You'll connect your hardware, install the ANX CLI, flash the latest OS firmware, and run the classic blinky application to confirm your setup is working end to end.

<Steps>
  <Step title="Connect Your Hardware">
    Plug your ANX dev module into your workstation using a USB-C cable. The module draws power from USB and enumerates as a serial device — no drivers are required on most operating systems.

    Once connected, confirm the device appears in your system:

    | OS      | Expected device path          |
    | ------- | ----------------------------- |
    | Linux   | `/dev/ttyUSB0`                |
    | macOS   | `/dev/cu.usbserial-*`         |
    | Windows | `COM3`, `COM4`, etc. (varies) |

    On Linux, if the device does not appear, add your user to the `dialout` group and reconnect:

    ```bash theme={null}
    sudo usermod -aG dialout $USER
    ```

    On Windows, open **Device Manager → Ports (COM & LPT)** to find the assigned COM port. On macOS, run `ls /dev/cu.*` in Terminal to list available serial devices.

    <Note>
      Use a data-capable USB-C cable. Charge-only cables will power the module but will not expose the serial interface to your workstation.
    </Note>
  </Step>

  <Step title="Install the ANX CLI">
    The ANX CLI is the primary tool for flashing firmware, running examples, and managing your device. Install it using the package manager or install script for your OS:

    <CodeGroup>
      ```bash Linux theme={null}
      curl -fsSL https://get.anx-labs.io/install.sh | bash
      ```

      ```bash macOS theme={null}
      brew install anx-labs/tap/anx
      ```

      ```powershell Windows theme={null}
      winget install ANXLabs.CLI
      ```
    </CodeGroup>

    After installation completes, open a new terminal window (or reload your shell) so that the `anx` binary is available on your `PATH`.
  </Step>

  <Step title="Verify the Installation">
    Confirm the CLI installed correctly by checking its version:

    ```bash theme={null}
    anx --version
    ```

    You should see output similar to:

    ```
    anx version 1.2.0
    ```

    If the command is not found, ensure that `~/.anx/bin` (Linux/macOS) or `%LOCALAPPDATA%\ANXLabs\bin` (Windows) is present in your `PATH` environment variable, then open a fresh terminal and try again.
  </Step>

  <Step title="Flash the Firmware">
    With the ANX dev module connected and the CLI verified, flash the latest stable ANX OS Firmware to your device:

    ```bash theme={null}
    anx flash --latest
    ```

    The CLI detects your connected device automatically, downloads the latest firmware image, and writes it to the module's flash memory. You'll see a progress indicator followed by a confirmation message:

    ```
    Detecting device...       ✓ ANX Dev Module found on /dev/ttyUSB0
    Downloading firmware...   ████████████████████ 100% (1.2 MB)
    Erasing flash...          ✓ Done
    Writing firmware...       ████████████████████ 100%
    Verifying...              ✓ Checksum OK

    Firmware flashed successfully. Module is rebooting.
    ```

    The module reboots automatically once flashing completes. The status LED will pulse blue to indicate the firmware is running and ready.

    <Warning>
      Do not disconnect the USB cable while flashing is in progress. Interrupting the write can corrupt the firmware and require a manual recovery using the BOOT button on the module.
    </Warning>
  </Step>

  <Step title="Run the Blinky Example">
    Run the built-in blinky example to verify that the firmware, CLI, and module are communicating correctly:

    ```bash theme={null}
    anx run examples/blinky
    ```

    The CLI uploads and runs the example on the module. You should see the onboard LED begin blinking at 1 Hz, and your terminal will confirm the application is running:

    ```
    Building examples/blinky...   ✓ OK
    Uploading to device...        ✓ OK
    Running examples/blinky

    [blinky] LED on
    [blinky] LED off
    [blinky] LED on
    [blinky] LED off
    ```

    Press `Ctrl+C` to stop the example. Your module is now fully set up and ready for development.
  </Step>
</Steps>

<Tip>
  Now that your hardware is running, read the [Hardware Overview](/hardware-overview) to understand the module's processor, memory, I/O interfaces, and power capabilities before diving into more complex examples.
</Tip>

## Next Steps

With your module flashed and your first example running, explore the rest of the ANX Labs platform:

<CardGroup cols={3}>
  <Card title="Dev Module" icon="microchip" href="/dev-module/overview">
    Full hardware specs, pinout reference, and electrical characteristics.
  </Card>

  <Card title="OS Firmware" icon="code" href="/firmware/overview">
    Firmware configuration, API reference, and over-the-air update guides.
  </Card>

  <Card title="Example Apps" icon="shapes" href="/examples/overview">
    Ready-to-run applications for sensors, BLE, Wi-Fi, and power management.
  </Card>
</CardGroup>