Skip to main content

Deep Dive: Linux Application Runtime

This section is a deeper look at the Particle Application Runtime for Linux, the container-based system used to run user applications on edge devices like Tachyon.

Much of this is a more detailed reflection of what’s already been introduced: Particle’s Linux runtime is based on open container technology, with support for building, pushing, and running applications directly on the edge — using either the CLI or Visual Studio Code with the Particle Workbench extension.

Run, Deploy or Port​

Whether you're:

  • Writing a new application from scratch
  • Porting an existing one from another system
  • Deploying a prebuilt container you've tuned elsewhere

...Particle gives you a clean, simple workflow for getting your applications running on edge hardware in just a few commands.

⚙️ Use either the CLI (particle app build, particle app push, etc.) or Workbench in VS Code — both are powered by the same underlying engine. Workbench offers a more visual, guided experience for development and deployment.

Built on Industry Standards​

Particle’s runtime is based on well-known open source technologies — including Docker container formats, Docker Compose, and OCI-compliant infrastructure.

This gives you:

  • A familiar development experience
  • Compatibility with off-the-shelf tools
  • Transparent runtime behavior
  • Confidence that your apps will behave the same in production as they do on your laptop

Applications can be developed and tested locally using standard tools like Docker, or run directly on-device in either headless or desktop mode.

Local Services and Application Complexity​

Developing IoT applications involves more than just your containerized app. Our runtime supports and encourages the use of local services and supporting containers, such as:

  • Message buses (e.g. MQTT, Redis)
  • Shared memory/memcache layers
  • Media pipelines (e.g. for video or image input/output)
  • LLMs and AI inference engines
  • Industrial applications like:
    • PLC interfaces
    • SCADA adapters
    • Protocol converters (Modbus, CAN, etc.)
    • Sensor fusion engines
    • Edge data loggers
    • Alerting/event generation services

You can orchestrate these services together using Docker Compose files, which Particle supports natively.

Multi-App Support and System Protections​

Your device can run multiple applications and services at once, each inside its own container.

Particle’s runtime enforces guardrails around:

  • Resource Isolation: Containers are prevented from monopolizing CPU or memory.
  • Application Limits: There are caps on the number of apps and their sizes.
  • Runaway Protection: If a container misbehaves, the runtime reports and optionally isolates it.
  • Thermal Management: The system automatically throttles workloads (and CPU frequency) under thermal load, to prevent overheating.

🧠 The system actively monitors for container collisions or unhealthy runtime states and surfaces that telemetry to developers through the CLI and Console.

Run Anywhere: Host or Device​

Developers have flexibility in how and where to develop and test containers:

💻 On Your Computer​

  • Build and run your app locally using Docker or Podman
  • Use VS Code and Workbench for development
  • Push directly to the Particle Cloud for deployment to devices

🖥️ On the Device Itself​

  • Install Visual Studio Code on a Linux-capable device
  • Sync your source code to the device
  • Build and run applications locally on-device, including with GUI output (camera previews, UI elements, etc.)

This hybrid model gives you flexibility depending on your app — whether it's compute-heavy, media-focused, or tightly integrated with local hardware.

Monitoring and Management​

Container operations are managed through:

  • The CLI — for scripting, automation, and power users
  • The Console — for a visual view of running containers, logs, and deployments

You can:

  • Build and push apps
  • List and delete running applications
  • View logs and system status
  • Run apps locally or deploy them OTA to devices

🧭 In the following pages, we’ll dive into container development, the repository, monitoring tools, and more — so you can confidently ship, run, and scale your IoT edge applications.