Arm processors power technology that’s transforming the world – from smartphones to supercomputers, from medical instruments to agricultural sensors. To program these Arm-based devices, developers need robust software tools and frameworks. This article provides an overview of the key programming tools, languages, and operating systems used for Arm application development.
Arm Compilers
A compiler is a program that converts high-level source code into machine code that a processor can execute. Arm offers a range of compilers optimized for their architecture:
- Arm Compiler: Arm’s optimizing C/C++ compiler and assembler for Arm-based processors. It supports the latest Arm instructions and enables advanced optimizations. The Arm Compiler toolchain is available in both open source and commercial editions.
- Keil MDK: A complete software development environment for Arm Cortex-M microcontroller devices. MDK includes the highly optimized Arm C/C++ Compiler, assembler, linker and debugging tools.
- Arm Embedded GCC: A port of the open source GCC compiler supporting Arm architectures. It produces efficient code but has fewer advanced optimizations than the Arm Compiler.
These compilers allow developers to generate highly efficient machine code for Arm CPUs. Advanced optimizations like branch prediction, loop unrolling and vectorization help maximize performance. The compilers also support common embedded software standards such as MISRA C for writing secure and reliable code.
Programming Languages
While C and C++ are the most common languages used for Arm embedded and application development, the flexibility of Arm processors also allows using a wide range of languages:
- C/C++ are the standard systems programming languages used for Arm development. They offer low-level control and high performance.
- Rust is a systems language that offers memory safety without garbage collection. It’s well suited for embedded and concurrent applications.
- Go is a compiled language optimized for programmer productivity. Its garbage collection makes it convenient for application development.
- Java is a popular language for Android app development on Arm. It uses JIT compilation for good performance and automatic memory management.
- Python is an interpreted language widely used for automation scripts and AI/ML applications on Arm devices.
- JavaScript/TypeScript are commonly used for front-end web and mobile app development on Arm.
- Swift is Apple’s language for iOS development. It combines safety and performance for mobile apps.
- C# enables .NET application development on Arm using tools like .NET MAUI for cross-platform UIs.
The LLVM compiler framework supports compiling many of these languages to Arm machine code. Arm also provides optimized runtimes and libraries for Java, Go, JavaScript, Python and other languages.
Operating Systems
The wide applicability of Arm processors is enabled by support for many operating systems. Common operating systems used in Arm development include:
- Linux is the most popular OS for Arm servers, embedded devices and application processors. Android uses the Linux kernel.
- Windows supports Arm processors allowing PC app development using Visual Studio.
- macOS runs natively on Arm Macs powered by Apple Silicon opening up native Mac development.
- FreeRTOS is a popular real-time OS for Arm Cortex-M microcontrollers.
- Arm Mbed OS is an RTOS optimized for Arm Cortex-M devices with IoT features.
- Zephyr RTOS is an open source RTOS targeting resource constrained devices with Bluetooth/Wi-Fi connectivity.
- Android is the leading mobile operating system running on Arm application processors.
- iOS is the native OS for iPhone and iPad built upon the Arm architecture.
Arm processors enable running diverse workloads from rich native OSs down to lightweight embedded RTOSes. Arm Architecture enables a common architecture across this breadth of computing devices.
Development Boards
Development boards with Arm processors allow programming real hardware for prototyping and testing. Some popular options include:
- Raspberry Pi – Low-cost single board computers ideal for hobbyists and tinkering projects.
- NXP i.MX RT1060 EVK – Mainstream evaluation kit for NXP’s Cortex-M7 based applications processors.
- STM32 Discovery Kits – Feature-rich dev boards to showcase STMicroelectronics’ Cortex-M MCUs.
- BeagleBoard – Open source community driven boards focused on exploring Arm capabilities.
- 96Boards – Arm’s open hardware platform specification for Arm 32-bit and 64-bit developer boards.
- Nvidia Jetson Nano – Powerful AI and robotics compute module with Nvidia GPU + Arm CPU.
These development boards allow working with real Arm hardware for building and testing projects. They provide easy access to IOs for interfacing sensors, displays, radios etc. Many also have built-in debugging capabilities.
Debugging Tools
Debugging Arm software requires specialized tools that can interface with the processors. Common options include:
- Arm Keil MDK – Provides JTAG/SWD debug probe connectivity for debugging Arm Cortex devices.
- SEGGER J-Link / Ozone Debug Probes – Widely used JTAG/SWD probes for debugging Arm cores.
- OpenOCD – Open source Arm debugger supporting JTAG/SWD target connectivity.
- DS-5 Development Studio – Arm’s Eclipse based integrated development environment with multicore debugging.
- GDB – The GNU debugger can be used for application level debugging of Arm software.
- Valgrind / Memcheck – Dynamic analysis tools to debug memory errors and leaks in Arm software.
These tools allow low-level debugging via JTAG/SWD ports as well as application level debugging. They provide visibility into code execution, memory access, processor registers etc. on target Arm devices.
Performance Analysis
To optimize software performance on Arm processors, developers need profiling tools:
- Arm DStream – System-wide analysis to debug complex real-time systems issues.
- Arm MAP – Processor level profiling to identify hotspots and optimization opportunities.
- Arm Performance Reports – In-depth analysis of code efficiency with guidance for improvements.
- gprof – Traditional profiler to analyze application performance bottlenecks.
- Valgrind / Callgrind – Dynamic analysis for detailed function profiling in Arm apps.
These tools Instrument code execution to collect detailed statistics on code profiles, trace execution hotpaths, and track system resource utilization. The insights obtained help developers optimize performance bottlenecks in their Arm software.
Embedded Frameworks
Developing efficient and robust embedded software on Arm requires well-designed frameworks. Widely used embedded frameworks include:
- Arm Mbed OS – RTOS and drivers for Arm Cortex-M MCUs with connectivity, security and cloud features.
- Amazon FreeRTOS – RTOS for microcontrollers that enables remote updates and AWS cloud connectivity.
- Zephyr RTOS – Secure lightweight real-time OS targeting embedded and IoT devices.
- ARM CMSIS – Standardized APIs for accessing Arm Cortex Microcontroller peripherals.
- AdaCore Gnat – Ada runtime optimized for high integrity and safety critical Arm applications.
- Embedded.com Embedded Libraries – Comprehensive libraries for IoT connectivity, storage, graphics and more.
These frameworks allow developers to efficiently harness Arm capabilities without re-inventing low-level solutions. They reduce time to market for new Arm embedded products.
Machine Learning
Arm processors enable energy efficient deployment of Machine Learning workloads through frameworks like:
- Arm NN – Optimized neural network inference engine for Arm Cortex devices.
- TensorFlow Lite – Lightweight TensorFlow framework for mobile and embedded Arm devices.
- TensorFlow Lite Micro – TensorFlow inference engine for microcontrollers based on Arm Cortex-M CPUs.
- Amazon SageMaker Neo – Tool to optimize and deploy ML models on Arm devices.
- ONNX Runtime – High performance inference engine for ONNX models on Arm processors.
These frameworks lower the barrier to deploying AI software on Arm. They optimize neural network models for low latency, high throughput inference on Arm CPUs and NPUs. Compact 8-bit quantized models allow tiny ML applications.
Graphics and Multimedia
Arm processors deliver high performance media experiences through optimized frameworks like:
- OpenGL ES – Leading 3D graphics API designed for embedded systems based on Arm and PowerVR GPUs.
- Vulkan – Next generation low overhead 3D graphics standard for Arm’s Mali and Qualcomm Adreno GPUs.
- OpenCL – Cross-platform framework for GPU accelerated computing on Arm Mali and other platforms.
- RenderScript – Android framework to exploit heterogeneous computing with Android Runtime on Arm.
- DirectX 12 – Latest DirectX now supported on Windows on Arm taking advantage of Arm GPUs.
- VideoCore APIs – Low level multimedia APIs for the VideoCore GPU in Raspberry Pi and other Arm devices.
These APIs allow developers to harness the powerful media processing capabilities of Arm GPUs. They are optimized for high performance media applications on embedded and mobile Arm platforms.
Security
Security is a key requirement in many Arm applications. Recommended security technologies include:
- Arm TrustZone – Hardware based security to protect sensitive assets and data in Arm System-on-Chips (SoCs).
- OP-TEE Trusted OS – Secure OS implementing TrustZone functionality to isolate secure code and data.
- mbed TLS – Lightweight cryptographic and SSL/TLS library designed for embedded Arm devices.
- PSA Certified – Arm’s Platform Security Architecture framework used to build secure Arm-based chips.
- Ambiq Apollo – Complete platform security solution for IoT devices based on Arm Cortex-M processors.
- WolfSSL – Speed optimized TLS/SSL library targeted at embedded and RTOS based Arm applications.
These technologies allow mitigating security threats like code injection, data theft, malware, etc. on Arm devices. They leverage hardware and software mechanisms for defense-in-depth.
Conclusion
This article provided an overview of key tools and technologies for building software on the Arm architecture. Arm’s flexibility supports a diverse range of languages, operating systems and workloads. Optimized compilers, debugging tools and frameworks enable developers to efficiently harness the capabilities of Arm processors. With robust tooling and extensive software ecosystem support, Arm empowers developers to innovate and build solutions that are transforming the world.
