Enable Developer Mode

Developer Mode (also called "dev mode") enables you to sideload apps, debug components, and access your Fire TV device through the developer shell and VDA (Vega Device Adapter) over the network or USB interface. You can test apps, access secure shells, manage packages, and access the file system. Activating Developer Mode requires authentication with your Amazon Developer Account and reboots your device. All Vega Fire TV devices use the same Developer Mode enablement process.

Estimated time to complete: 5–10 minutes

Prerequisites

Before you begin, make sure you have:

• Amazon Developer Account (required for authentication) — Sign up if you don't have one
• Vega CLI installed on your development machine — verify with vega --version. See Install the Vega SDK if not installed
• Latest SDK Manager — run vega update to get the latest version. See Vega SDK Manager
• Fire TV device running Vega OS, connected to the same network as your computer. For a full list of supported devices, see Fire TV device specifications.

Authenticate Developer Mode on Fire TV

Step 1: Access Developer Options

1. On your Fire TV device, navigate to Settings > My Fire TV > About.

2. Select your device name (for example, Fire TV Stick HD, Fire TV Stick 4K Select, or Fire TV Streaming Media Player).

3. Press the center button on your remote seven times.

   A message appears confirming that Developer Options is enabled.

4. Return to Settings > My Fire TV > Developer Options.

5. Select Developer Mode (currently shows as "Disabled").

   An "Enable Developer Mode" dialog appears:

   "To enable Developer Mode, you will need an Amazon Developer Account, and your device will reboot during this process."

6. Select Continue to proceed (or Cancel to abort).

Step 2: Retrieve the authentication code

After selecting Continue, the Fire TV screen displays:

* Heading: "ENABLE DEVELOPER MODE"
* Your device name (for example, "My Fire TV")
* Authentication code: 6-digit numeric code (for example, `791744`) prominently displayed
* Status: "Code ready"
* Instructions: "On your computer enter the code shown on the screen"

Step 3: Authenticate with Vega CLI

On your development machine:

1. Open your terminal or command line.

2. Run the authentication command:

   Copy code Copied to clipboard.

   vega devmode login
   

   The CLI displays:

   DevTools authentication
   Opening browser automatically to: https://amazon.com/us/code?cbl-code=XXXXXX
   Enter the code in your web browser: [CODE]
   Follow the on-screen instructions to complete authentication
   Waiting for authentication to complete...
   

   The system automatically opens your default web browser to the Amazon authentication page. If the browser doesn't open automatically, manually navigate to the URL shown in the terminal.

   Note: If the browser doesn't open or authentication times out, see Authentication issues.

Step 4: Authorize Vega CLI access

In your web browser, the Amazon OAuth consent screen appears:

1. The screen displays "Vega Authentication Test would like access to:"

   Under Profile, it shows: "Your basic profile information" and your name.

2. Review the requested permissions.

3. Select Allow to authorize Vega Authentication Test (or Cancel to deny).

   After selecting Allow, you see a confirmation page with a green checkmark icon and the message "Device connected to your account." You can close this page.

Step 5: Confirm login and enable the device

1. Return to your terminal.

   The CLI displays:

   Login successful! You are now authenticated with Amazon Developer Services.
   

2. Enable the device using the 6-digit code displayed on your Fire TV screen in Step 2:

   vega devmode enable-device --code <6-digit code>
   

   The CLI proceeds to vendor selection (see Step 6), or displays ✓ Device enabled successfully if your account has only one vendor.

   Note: If the code is rejected or you see an error, see Authentication issues.

Step 6: Select a vendor

A vendor is a developer account for managing and publishing content through Amazon's developer services. Your VendorID links you to your content, permissions, and resources in the Developer Portal.

The CLI shows available vendors. Enter the number corresponding to your vendor when prompted.

   Select a vendor:
   1. Amazon (XXXXXXXXXX)
   2. Amazon (XXXXXXXXXX)

The CLI displays: ✓ Device enabled successfully

Step 7: Device reboot

Your Fire TV screen displays:

• "Developer Mode Enabled"
• "Your device will reboot in 4 seconds…"

The device automatically reboots. During reboot, you see "Your Fire TV is Powering Off" followed by the Fire TV logo on a black background. The reboot process takes approximately 30–60 seconds.

Step 8: Verify Developer Mode is enabled

After your device finishes rebooting and returns to the home screen:

1. On your Fire TV device, navigate to Settings > My Fire TV > Developer Options.

2. Verify that Developer Mode status shows as Enabled.

3. In your terminal, verify device connectivity:

   Copy code Copied to clipboard.

   vega device list
   

   Example output:

   Found the following device:
   [Serial Number] : [Device Number]
   

   Developer shell and VDA access are now active.

Developer Mode states

Developer Mode operates in enable, authenticating, and disable states.

Enable state

The enable state activates full developer features including vsh shell access, package management through vpm, and component debugging capabilities.

Authenticating state

The authenticating state indicates the system is validating developer mode access during enablement.

Disable state

The disable state restricts access to standard user features.

Development tools

Developer Mode provides access to essential tools for package deployment, component management, and file operations. Use them in the correct context with proper permissions.

Vega CLI

Use the Vega command line interface (CLI) commands to install, uninstall, and manage packages on your device. The following package operations are available:

# Installation (takes the package file path)
vega device install-app --packagePath my-package.vpkg

# List packages
vega device installed-packages

# Package info
vega device run-cmd --command 'vpm info <package-id>'

# Uninstall (takes the component ID, not the package file)
vega device uninstall-app --appName <component-id>

You can only sideload non-Amazon packages (packages without the com.amazon prefix).

Component management

Use the component management commands through the vega device to launch, list, and terminate your app components. The key commands are:

# Launch
vega device launch-app --appName <component-id>

# List components
vega device running-apps

# Terminate
vega device terminate-app --appName <component-id>

File operations

Use file operations to transfer files between your development machine and device. The default shell only allows access to the /tmp directory, while component shells can access their specific /tmp/scratch/<package-id> directories. Always verify your file permissions after transfer, and remove temporary files when they're no longer needed to maintain device storage. Remember that file paths are case-sensitive.

When deleting files, remember to:

1. Only delete files that were pushed to /tmp from the default development shell.

2. Delete the files in /tmp/scratch/<package-id> within the specific component shell by:

   • Entering the component shell using: vega exec vda shell -t component-id com.myorg.myapp.main
   • Navigating to the /scratch directory, which is a bind mount of /tmp/scratch/<package-id> inside the component shell:

    sh(com.myorg.myapp.main):/$ cd scratch
    sh(com.myorg.myapp.main):/scratch$ rm -rf <filename>
   

   Default shell push

    # Push to default shell
    vega device copy-to --source <src> --destination /tmp/
   
    # To view the file
    vega device shell
    sh(com.amazon.dev.shell):/$ ls -al /tmp
   

   Component shell push

   
    vega device copy-to --source <src> --destination /tmp/scratch/<package-id>/
   
    Example:
    (hostmachine)% vega device copy-to --source myfile_cloud.sh --destination /tmp/scratch/com.myorg.myapp   
   
    # Find the list of components
    vega device installed-apps
   
    Example output: 
    com.myorg.myapp.main         
    com.myorg.otad.main          
    com.myorg.dev.shell.service  
   
    # Find the list of packages installed on device
    vega device installed-packages
   
    Example output:
    com.myorg.myapp
    com.myorg.test.lifecycleobserver
    com.myorg.TESSERACT.TEST
    com.myorg.sm-sample.client
    com.myorg.samplepkg
    com.myorg.security.manager.unprivileged-test
    com.myorg.nmunprivileged.task
    com.myorg.messaging.mr33.okidl.ac
   
    # Launch Component shell
    (hostmachine)% vega exec vda shell -t component-id com.myorg.myapp.main 
   
    # View the pushed file
    sh(com.myorg.myapp):/$ ls -al scratch/
   
    Example output:
    total 4
    drwxr-xr-x  2 app_user app_user  60 2024-07-16 03:03 .
    drwxr-xr-x 19 app_user app_user 400 2024-07-16 03:03 ..
    -rwxrwxrwx  1 app_user 30086    650 2024-07-16 03:03 myfile_cloud.sh
   

   Pull from device

    # Pull from device
    vega device copy-from -o <device-path> -s <local-path>
   

Best practices

When using Developer Mode, make the following practices part of your regular development workflow to prevent unintended system modification:

• Sideload only apps with non-Amazon package IDs (verify your package ID doesn't begin with com.amazon).
• Use the minimum access level needed for your task.
• Follow the principle of least privilege.
• Be mindful that your actions can affect device stability and security.

Troubleshooting and support

When issues arise during development, start by identifying which area is affected (authentication, shell access, package management, component launch, or file operations). Causes of common issues include incorrect permissions or device state restrictions.

If the solutions described in the following sections don't resolve your issue, collect relevant logs using loggingctl log before seeking support.

Authentication issues

Common development issues

Debugging tools

Use loggingctl log to collect system logs and monitor component status. Each debugging tool has specific access levels based on your device state.

Related topics

• Connect to a Device over TCP/IP
• Run Your App
• Vega CLI Command Reference
• Use Loggingctl to Manage System Logs

Last updated: Jul 15, 2026