# ExecuTorch

> Source: https://aiwiki.ai/wiki/executorch
> Updated: 2026-11-18
> Fact-checked: 2026-11-18
> Categories: Developer Tools, Edge computing, Machine Learning, Open Source AI
> License: CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/) - attribute to "AI Wiki (aiwiki.ai)"
> Cite as: AI Wiki. "ExecuTorch." aiwiki.ai, 18 Nov 2026. https://aiwiki.ai/wiki/executorch
> From AI Wiki (https://aiwiki.ai), the free encyclopedia of artificial intelligence. Reuse freely with attribution.

**ExecuTorch** is an open-source runtime and toolchain from the [PyTorch](https://aiwiki.ai/wiki/pytorch) project for running trained [machine learning](https://aiwiki.ai/wiki/machine_learning) models directly on edge hardware, including phones, wearables, laptops, browsers, embedded systems and microcontrollers.[1] A developer captures a PyTorch model with `torch.export`, optimizes it ahead of time for a chosen hardware backend, serializes it to a `.pte` file and runs that file through a small C++ runtime that has bindings for C++, Python, Swift and Objective-C, Kotlin and Java, and JavaScript.[1] ExecuTorch was announced in October 2023 as the core of the "PyTorch Edge" effort and the successor to the older PyTorch Mobile stack, with Arm, Apple and Qualcomm Innovation Center as launch partners.[3][8] The project reached beta with version 0.4 in October 2024, general availability with version 1.0 in October 2025, and became a PyTorch Core project under the PyTorch Foundation in April 2026.[5][6][7] Meta uses it for on-device features in Instagram, WhatsApp, Messenger and Facebook and in its Quest headsets and smart glasses.[8][18]

## Overview

| Attribute | Detail |
|---|---|
| Developer | Meta (PyTorch Edge team) and contributors; a PyTorch Core project since April 2026[7] |
| First public release | v0.1.0 preview, 2023-10-17[10] |
| General availability | v1.0.0, released 2025-10-18 and announced 2025-10-22[11][6] |
| Latest release (as of 2026-11-18) | v1.6.0, 2026-11-12[14] |
| License | BSD-style (PyPI lists BSD-3-Clause)[20][21] |
| Core runtime language | C++17[2] |
| Model file format | `.pte` (program), `.ptd` (named tensor and delegate data)[2] |
| Python package | `executorch` on PyPI, Python 3.11 to 3.15 as of v1.6.0[21][14] |
| Repository | github.com/pytorch/executorch[1] |

<figure class="embedvideo">
<iframe src="https://www.youtube-nocookie.com/embed/toirKRTLgJA" title="ExecuTorch 1.0: General Availability Status for Mobile and Embedded...- Mergen Nachin &amp; Cemal Bilgin"></iframe>
<figcaption>"ExecuTorch 1.0: General Availability Status for Mobile and Embedded...- Mergen Nachin &amp; Cemal Bilgin", official video from PyTorch Foundation, published November 4, 2025. <a href="https://www.youtube.com/watch?v=toirKRTLgJA">Watch on YouTube</a>.</figcaption>
</figure>

## History

### Background: PyTorch Mobile

Before ExecuTorch, PyTorch's on-device path was PyTorch Mobile, which ran models serialized with TorchScript through a mobile interpreter.[2] The ExecuTorch authors describe PyTorch Mobile and TorchScript as attempts at PyTorch-native deployment that were limited by a high memory footprint and narrow hardware integration, and they list "prohibitive runtime overhead" among the problems ExecuTorch was built to address.[2] The 2023 announcement framed the change as a move "from PyTorch Mobile to ExecuTorch" within a broader PyTorch Edge program aimed at AR, VR, mobile and IoT workloads.[3] As of November 2026, the former PyTorch Mobile page at pytorch.org/mobile redirects to the ExecuTorch documentation.[22]

GitHub records the `pytorch/executorch` repository as created on 2022-02-25, more than a year before the public announcement.[23] The PyTorch Foundation later wrote that the project "began at Meta" to run PyTorch models on phones, AR/VR headsets, glasses, embedded devices and custom accelerators.[7]

### Preview, alpha and beta (2023 to 2024)

ExecuTorch was introduced publicly at PyTorch Conference 2023.[7] The PyTorch blog announced it on 2023-10-17, describing a compact runtime with a lightweight operator registry, a software development kit for profiling and debugging, and hardware "delegate" implementations contributed by partners.[3] The first versioned release, v0.1.0, which its notes call the "initial public release", was marked as a preview for testing and evaluation and not recommended for production.[10]

The alpha release, announced on 2024-04-30, concentrated on [large language models](https://aiwiki.ai/wiki/large_language_model). It added 4-bit post-training quantization with [GPTQ](https://aiwiki.ai/wiki/gptq) and dynamic-shape support in the XNNPACK CPU backend, which the team said let [Llama 2](https://aiwiki.ai/wiki/llama_2) 7B run on the iPhone 15 Pro, iPhone 15 Pro Max and Samsung Galaxy S22, S23 and S24, with early support for [Llama 3](https://aiwiki.ai/wiki/llama_3) 8B.[4] The same post reported that Meta was already using ExecuTorch for hand tracking on Meta Quest 3 and for models on Ray-Ban Meta smart glasses, had begun rolling it out in Instagram, and noted that Unity had built a custom backend that converts ExecuTorch's Edge Dialect into the format of its Sentis inference library.[4]

Beta status arrived with v0.4, released on 2024-10-18 and announced on 2024-10-24, one year after the original open-source release.[5][15] The beta post cited stable APIs with an explicit lifecycle and backward-compatibility policy, and said the portable CPU kernel library implemented more than 85% of the core ATen operators.[5] For Meta's quantized [Llama 3.2](https://aiwiki.ai/wiki/llama_3_2) 1B model it reported 50.2 tokens per second for decoding and 260 tokens per second for prefill on a OnePlus 12 using XNNPACK and Arm Kleidi kernels, and it said runtime memory for LLaVA 1.5 7B on phones had been cut from 11 GB to 5 GB.[5] Meta's Llama 3.2 announcement in September 2024 named PyTorch ExecuTorch as the on-device distribution of Llama Stack, implemented on iOS.[9]

### Version 1.0 (October 2025)

ExecuTorch 1.0 was tagged on 2025-10-18 and announced on 2025-10-22.[11][6] The release notes describe it as the official transition out of beta, with ARM64 Linux support, experimental native x86 Windows support, new multimodal runner APIs for Android, iOS and desktop (with Voxtral and Gemma 3 among supported models), LoRA inference with several `.pte` files sharing one set of foundation weights, 4-bit HQQ quantization, and experimental JavaScript support through WebAssembly.[11] The announcement promoted five backends to production-ready status: XNNPACK with Arm Kleidi for CPUs, Apple Core ML, the Qualcomm AI Engine delegate for Hexagon NPUs, Arm Ethos-U, and Vulkan GPU.[6] New backends added around 1.0 included Arm VGF, NXP eIQ Neutron, Samsung Exynos NPU and GPU, and Intel's OpenVINO.[6] Arm published its own announcement the same day describing KleidiAI, CMSIS-NN and TOSA integrations for Arm CPUs, GPUs and Ethos-U NPUs.[19]

### PyTorch Core and the 1.x series (2026)

On 2026-04-07 the PyTorch Foundation announced that ExecuTorch was becoming part of PyTorch Core.[7] The post said the move gives the project vendor-neutral governance under the Foundation's governing board, IP, trademark and branding stewardship independent of any single company, and the PyTorch hierarchical technical governance, in which core PyTorch maintainers oversee cross-cutting changes and module maintainers oversee ExecuTorch-specific ones. It stated that Meta would remain a major contributor but that "no single company will control ExecuTorch's business governance."[7]

In May 2026 a team of 39 authors at Meta or formerly at Meta (among the latter [Soumith Chintala](https://aiwiki.ai/wiki/soumith_chintala)) posted the paper "ExecuTorch -- A Unified PyTorch Solution to Run AI Models On-Device" to arXiv; it appears in the industry track of the 9th MLSys Conference (2026).[2]

Releases in 2026 widened the hardware range beyond phones and microcontrollers. Version 1.1 (January 2026) added experimental [CUDA](https://aiwiki.ai/wiki/cuda) and Metal GPU backends, Zephyr RTOS integration and CMSIS-NN kernels for Cortex-M.[12] Version 1.2 (April 2026) was aligned with PyTorch 2.11, added Voxtral Realtime streaming speech, NVIDIA NeMo Sortformer diarization, Silero VAD, Qwen3.5 and Parakeet, and made Cortex-M a dedicated backend; it also deprecated the older Apple MPS backend for later removal.[13] The 1.3 series shipped first as a Maven-only 1.3.0, so 1.3.1 (May 2026) was its first broadly published build, adding export support for models including Qwen3.5 MoE and Gemma 4 31B on the CUDA, Metal and MLX paths.[25] Version 1.4 (August 2026) added Vulkan support for Linux and Windows desktop GPUs and widened Cortex-M support across more CPU variants.[26] Version 1.5 (September 2026) bundled a C++ SDK into the Python wheels and added ROCm support for [AMD](https://aiwiki.ai/wiki/amd) GPUs to the AOTInductor-based CUDA backend.[24] Version 1.6 (November 2026) promoted the NXP Neutron backend to production-ready, added a [TensorRT](https://aiwiki.ai/wiki/tensorrt) backend in beta, a Python runtime that runs `.pte` files without installing PyTorch, and support for Python 3.15 and PyTorch 2.15; the same notes list the MediaTek backend as temporarily unsupported pending a NeuroPilot converter for Python 3.11 and later.[14]

### Release timeline

| Version | Date | Milestone |
|---|---|---|
| v0.1.0 | 2023-10-17 | First public release, preview only[10] |
| v0.2.0 | 2024-04-29 | Llama 2 7B and Llama 3 8B support; alpha announced the next day[15][4] |
| v0.4.0 | 2024-10-18 | Beta (announced 2024-10-24)[15][5] |
| v1.0.0 | 2025-10-18 | General availability (announced 2025-10-22)[11][6] |
| v1.1.0 | 2026-01-27 | Experimental CUDA and Metal backends[12] |
| v1.2.0 | 2026-04-01 | Aligned with PyTorch 2.11; Cortex-M backend[13] |
| v1.3.1 | 2026-05-29 | First broadly published 1.3 build (1.3.0 was Maven-only)[25] |
| v1.4.0 | 2026-08-07 | Vulkan on Linux and Windows desktop GPUs[26] |
| v1.5.0 | 2026-09-16 | C++ SDK in wheels; ROCm support[24] |
| v1.6.0 | 2026-11-12 | NXP Neutron production-ready; TensorRT beta[14] |

## Design

ExecuTorch has two main parts: an ahead-of-time (AOT) export stack that runs in Python on a development machine, and a runtime stack that runs on the target device.[2] Graph transformations such as quantization, subgraph delegation and memory planning happen ahead of time so that the device runtime only has to execute a pre-optimized program.[2]

### Export and intermediate representations

Export starts with `torch.export`, the graph-capture mechanism built on the tracing technology introduced in PyTorch 2.0 (also used by [torch.compile](https://aiwiki.ai/wiki/torch_compile)).[2] It turns Python model code into a static graph called Export IR, a Torch FX graph with guarantees about shape soundness, the absence of Python semantics, available tensor metadata, and provenance records that map nodes back to the original module hierarchy and Python call stack.[2]

ExecuTorch then lowers the graph to its Edge Dialect, which adds three constraints: graphs are fully functional with no mutation or aliasing, they use a restricted set of fewer than 300 "Core ATen" operators, and data types and memory layouts are made explicit.[2] The paper notes that, unlike an [ONNX](https://aiwiki.ai/wiki/onnx) export, these graphs stay executable in PyTorch, so developers can check numerical behavior before deployment; the authors call this property "experimentation parity."[2]

### Quantization

[Quantization](https://aiwiki.ai/wiki/quantization) builds on the TorchAO library. Two workflows exist: PyTorch 2 Export quantization, which annotates the exported graph through backend-specific quantizers for both post-training quantization and [quantization-aware training](https://aiwiki.ai/wiki/quantization_aware_training), and eager-mode quantization for dynamic or weight-only quantization.[2] Each backend declares what it can execute, so the quantization chosen in PyTorch matches what runs on the device.[2]

### Backend delegation

Hardware acceleration works through delegates. A partitioner finds subgraphs made of operators a backend supports; the backend's AOT compiler turns each subgraph into a "delegate blob," and the backend's runtime library executes that blob on the target processor.[2] Operators the delegate does not support fall back to portable CPU kernels, and several partitioners can be listed in priority order.[17] Because lowering is done for a specific backend, the documentation advises producing a separate `.pte` file for each target, for example one for Core ML on iOS and one for an Arm CPU on Android.[17]

### File formats and memory planning

The `.pte` format stores an execution plan for each model method (for example `forward`) as a flat list of instructions, `KernelCall` for operators and `DelegateCall` for delegated subgraphs, plus aligned data segments that can be loaded, freed or memory-mapped independently.[2] A companion `.ptd` format stores named tensors and delegate data, so several programs can share weights (for example [LoRA](https://aiwiki.ai/wiki/lora) adapters over one base model) and on-device training can write new checkpoints.[2] Memory planning is the last AOT step: ExecuTorch analyzes tensor sizes and lifetimes and assigns them to fixed-size arenas, using a greedy best-fit algorithm by default.[2]

### Runtime

The core runtime targets C++17 and avoids dynamic memory allocation, synchronization primitives, exceptions and allocating STL types, so that it can run on servers, phones and bare-metal systems.[2] All memory is supplied by the application through a `MemoryManager`; a Platform Abstraction Layer lets integrators override logging, timing and panic handling; and a `DataLoader` interface supports file I/O or memory-mapped loading.[2] Two CPU kernel libraries ship with it: a dependency-free portable library implementing Core ATen operators and an optimized library using SIMD and math libraries such as SLEEF and OpenBLAS.[2] Selective build links only the kernels a model needs; the paper gives the full portable library as about 2.3 MiB and says selective build can bring binary size from mebibytes down to kibibytes.[2]

The paper compared ExecuTorch with the TorchScript-based PyTorch Mobile interpreter on a minimal model (one multiply and one add), measured in CPU cycles:[2]

| Phase | PyTorch Mobile | ExecuTorch | Speedup |
|---|---|---|---|
| Deserialization | 510 | 97 | 5.3x |
| Initialization | 312,631 | 8,350 | 37.4x |
| Framework overhead per run | 324,399 | 75 | 4,325x |
| Total per inference | 654,009 | 9,272 | 70.5x |

### Developer tools

Two artifacts link device behavior back to the PyTorch model. ETRecord is produced during export and holds the Edge Dialect graph with debug metadata; ETDump is produced at run time and records operator latencies, memory lifetimes, delegate and kernel calls, and optionally intermediate tensor values.[2] An Inspector API reads both, so developers can find slow operators or compare intermediate outputs with a reference model.[2]

## Hardware backends

The documentation lists the following backends as of November 2026. Maturity varies: the 1.0 announcement named XNNPACK, Core ML, Qualcomm, Arm Ethos-U and Vulkan as production-ready, v1.6 added NXP, and several others are labeled experimental or beta.[17][6][14]

| Backend | Platforms | Hardware |
|---|---|---|
| XNNPACK | All | CPU (general purpose and fallback) |
| [Core ML](https://aiwiki.ai/wiki/core_ml) | iOS, macOS | NPU, GPU, CPU |
| [MLX](https://aiwiki.ai/wiki/mlx) | macOS; iOS experimental | Apple silicon GPU |
| Core AI | iOS, macOS | Apple devices on OS 27, experimental |
| Vulkan | Android; Linux and Windows experimental | GPU |
| WebGPU | Browser, Linux, macOS | GPU, experimental |
| [Qualcomm](https://aiwiki.ai/wiki/qualcomm) AI Engine Direct | Android | NPU (Hexagon) |
| [MediaTek](https://aiwiki.ai/wiki/mediatek) | Android | NPU |
| [Samsung](https://aiwiki.ai/wiki/samsung) Exynos | Android | CPU, GPU, NPU |
| Arm VGF | Android | GPU |
| Arm Ethos-U | Embedded | NPU |
| Arm Cortex-M | Embedded | CPU (microcontrollers) |
| NXP eIQ Neutron | Embedded | NPU |
| Cadence | Embedded | DSP |
| [OpenVINO](https://aiwiki.ai/wiki/openvino) | Embedded | CPU, GPU, NPU on Intel SoCs |
| CUDA | Linux, Windows | NVIDIA GPU |
| TensorRT | Linux, Windows | NVIDIA GPU |

The XNNPACK backend is built on Google's XNNPACK library and uses Arm's KleidiAI micro-kernels to extend hardware coverage; the paper says the ExecuTorch and Google teams collaborate on it.[2] The Vulkan backend runs GLSL compute shaders on mobile GPUs, and the Ethos-U backend converts subgraphs to the TOSA representation, which Arm's Vela compiler then compiles for the NPU.[2] The Core ML backend can target the CPU, GPU and [Apple Neural Engine](https://aiwiki.ai/wiki/apple_neural_engine).[2]

## Language models and multimodal models

LLMs can be exported through ExecuTorch's own modular transformer-decoder definition, which covers models such as Llama 3.2 and [Qwen3](https://aiwiki.ai/wiki/qwen_3), or from the Hugging Face [Transformers](https://aiwiki.ai/wiki/transformers_library) library through Optimum ExecuTorch.[2] The paper states that over 80% of the models on Hugging Face's text-generation leaderboard can be exported this way, and in the 1.0 announcement [Hugging Face](https://aiwiki.ai/wiki/hugging_face)'s Lysandre Debut said more than 80% of the most downloaded edge-friendly LLMs on the Hub ran on ExecuTorch out of the box.[2][6] To fit phones, ExecuTorch uses [KV cache](https://aiwiki.ai/wiki/kv_cache) quantization, [flash attention](https://aiwiki.ai/wiki/flash_attention), sliding-window attention that tracks cache positions instead of shifting the cache, and 4-bit group-wise weight quantization; the Qualcomm and Core ML backends also support [speculative decoding](https://aiwiki.ai/wiki/speculative_decoding).[2] Multimodal models are split at export into a text embedding, a text decoder and a modality encoder, which a C++ runner stitches back together; examples include [Voxtral](https://aiwiki.ai/wiki/voxtral) and [Gemma 3](https://aiwiki.ai/wiki/gemma_3) 4B.[2]

As of November 2026, the repository's examples cover quantized text models with tool calling, an experimental OpenAI-compatible local server, speech recognition and synthesis ([Parakeet](https://aiwiki.ai/wiki/parakeet), Voxtral Realtime, Voxtral TTS), speaker diarization, [Gemma 4](https://aiwiki.ai/wiki/gemma_4) multimodal models and [YOLO](https://aiwiki.ai/wiki/yolo) vision models.[1] The README cautions that these are starting points rather than a compatibility list, and that a model's deployability depends on `torch.export` capture and on operator and backend coverage.[1]

## Microcontrollers

The paper demonstrates an MNIST digit classifier on a Raspberry Pi Pico 2 (Arm Cortex-M33, 520 KiB SRAM, 4 MiB flash).[2] Selective build cut total code size from 1,322 KiB to 253 KiB for FP32 inference with portable kernels, and from 1,248 KiB to 203 KiB for int8 inference with Arm's CMSIS-NN kernels; the ExecuTorch runtime itself took 13 to 26 KiB of flash.[2] Int8 quantization and operator fusion reduced the memory-planned arena from 101.2 KiB to 3.8 KiB, for about 11 KiB of total RAM, and ran inference 16.46 times faster than FP32 (3.5 ms against 57.6 ms).[2]

## Performance

The MLSys paper benchmarked ExecuTorch against llama.cpp, ONNX Runtime, LiteRT and Core ML on a Samsung Galaxy S25 Ultra (Snapdragon 8 Elite), a Google Pixel 9 Pro XL (Tensor G4) and an iPhone 15 Pro, using the latest framework versions as of 2026-03-31.[2] The comparison was run by the ExecuTorch team. Its main findings, as the authors report them:[2]

- On CPU, the XNNPACK delegate performed strongly against ONNX Runtime and LiteRT for both LLMs and vision models. On the Galaxy S25 Ultra, [llama.cpp](https://aiwiki.ai/wiki/llama_cpp) had higher decode throughput for Qwen3 0.6B and [Phi-4](https://aiwiki.ai/wiki/phi_4) Mini, which the authors attribute to a more efficient single-token attention implementation.
- On GPU, the Vulkan delegate ran all three tested LLMs with no CPU fallback. It trailed llama.cpp in prefill on the Galaxy S25 Ultra but tended to generate tokens faster; on the Pixel 9 Pro XL it was well ahead in prefill, which the authors relate to llama.cpp having optimized shaders only for Adreno GPUs.
- On the Qualcomm NPU, ExecuTorch's QNN delegate reached about 2,813 to 2,977 prefill tokens per second for Llama 3.2 1B, against about 2,278 to 2,392 for Qualcomm's own QAIRT runtime, while QAIRT had higher decode throughput (about 52 against 46.5 tokens per second).
- On the iPhone 15 Pro, the Core ML delegate matched or slightly outperformed native Core ML on four vision models.

The paper also notes that ExecuTorch's model files tended to be larger than those of other frameworks, partly because the XNNPACK delegate did not yet support tied embeddings.[2]

## Compatibility policy

ExecuTorch publishes a runtime compatibility policy for `.pte` files. A file built with stable APIs is guaranteed to load and run on a runtime from at least the next non-patch (major or minor) release; no forward-compatibility guarantee is made.[16] The policy states that minor releases follow the PyTorch release cadence of every three months, so a `.pte` file is supported for at least six months.[16] Custom operators outside Core ATen carry no explicit guarantee, and each backend must keep its delegated payloads loadable for at least the same range.[16]

## Adoption

### Meta

In July 2025 Meta's engineering blog described ExecuTorch features serving "billions of people" across its apps.[8] Examples included Instagram's Cutouts sticker feature, migrated to run SqueezeSAM (a lightweight [Segment Anything](https://aiwiki.ai/wiki/segment_anything_model_and_dataset_sam_and_sa-1b) variant) on ExecuTorch; WhatsApp bandwidth-estimation models for video calls, where Meta reported shorter load and inference times and added fuzz testing; a Messenger language-identification model moved on-device to support end-to-end encryption; and Facebook's SceneX model, used to suggest background music for Stories.[8] According to the project's success-stories page, Meta Reality Labs uses ExecuTorch on Meta Quest 3 and 3S and on Ray-Ban Meta, Oakley Meta Vanguard and [Meta Ray-Ban Display](https://aiwiki.ai/wiki/meta_ray_ban_display) glasses for hand and controller tracking, live translation, visual captions and on-device OCR.[18]

### Other organizations

The 1.0 announcement included statements from Hugging Face, Unsloth, [Liquid AI](https://aiwiki.ai/wiki/liquid_ai) (which said it uses ExecuTorch for its LFM2 models) and [Mistral AI](https://aiwiki.ai/wiki/mistral_ai) (which said it runs Voxtral on it).[6] The project's success-stories page, as of November 2026, lists [LM Studio](https://aiwiki.ai/wiki/lmstudio) voice transcription with NVIDIA Parakeet TDT on macOS and Windows as a production deployment, along with integrations by [Unsloth](https://aiwiki.ai/wiki/unsloth), Software Mansion (React Native ExecuTorch and the Private Mind assistant app), Ultralytics (YOLO26 export), Digica, NimbleEdge, Arm, Alif, Arduino, Intel OpenVINO and NVIDIA FLARE, which uses ExecuTorch for local training in [federated learning](https://aiwiki.ai/wiki/federated_learning).[18]

## Limitations

The ExecuTorch authors list several open problems.[2] Because the toolchain depends on `torch.export`, models with data-dependent control flow (such as beam search), input-dependent shapes (such as dynamic LSTMs or Mask R-CNN) or custom C++ and CUDA kernels may need rewriting, for instance with `torch.cond` or custom operators. Ahead-of-time compilation for a specific accelerator means Android developers facing Qualcomm, MediaTek and Samsung NPUs may need to ship or download several hardware-specific model files, which the paper concedes is more complex than runtime-retargetable systems such as ONNX Runtime or LiteRT. Hardware-accelerated sparse kernels are listed as future work.[2] The documentation likewise warns that a `.pte` built for one hardware delegate "is not a universal model file."[1]

## See also

- [On-device AI](https://aiwiki.ai/wiki/on_device_ai)
- [Edge computing](https://aiwiki.ai/wiki/edge_computing)
- [PyTorch](https://aiwiki.ai/wiki/pytorch)
- [llama.cpp](https://aiwiki.ai/wiki/llama_cpp)
- [Core ML](https://aiwiki.ai/wiki/core_ml)
- [TensorFlow Lite](https://aiwiki.ai/wiki/tensorflow_lite)
- [ONNX](https://aiwiki.ai/wiki/onnx)
- [Small language model](https://aiwiki.ai/wiki/small_language_model)
- [Model deployment](https://aiwiki.ai/wiki/model_deployment)

## References

1. PyTorch. "ExecuTorch" (README, main branch). GitHub, pytorch/executorch, accessed 2026-11-18. https://github.com/pytorch/executorch
2. Nachin, M., Desai, D., Jia, S. S., Lai, C., Liu, M., Szwejbka, J., et al. "ExecuTorch -- A Unified PyTorch Solution to Run AI Models On-Device". arXiv:2605.08195; Proceedings of the 9th MLSys Conference (Industry Track), 2026. https://arxiv.org/abs/2605.08195
3. PyTorch Edge Team. "PyTorch Edge: Enabling On-Device Inference Across Mobile and Edge Devices with ExecuTorch". PyTorch Blog, 2023-10-17. https://pytorch.org/blog/pytorch-edge-enabling-on-device-inference-across-mobile-and-edge-devices-with-executorch/
4. PyTorch Foundation. "ExecuTorch Alpha: Taking LLMs and AI to the Edge with Our Community and Partners". PyTorch Blog, 2024-04-30. https://pytorch.org/blog/executorch-alpha/
5. PyTorch Foundation. "ExecuTorch Beta: On-Device AI and LLMs, Stability, and Acceleration with Partners". PyTorch Blog, 2024-10-24. https://pytorch.org/blog/executorch-beta/
6. PyTorch Team at Meta. "Introducing ExecuTorch 1.0: Powering the next generation of edge AI". PyTorch Blog, 2025-10-22. https://pytorch.org/blog/introducing-executorch-1-0/
7. PyTorch Foundation. "ExecuTorch Becomes a Part of PyTorch Core to Expand On-Device Inference Capabilities". PyTorch Blog, 2026-04-07. https://pytorch.org/blog/executorch-becomes-part-of-pytorch-core/
8. PyTorch Edge Team in collaboration with Family of Apps. "Accelerating on-device ML on Meta's family of apps with ExecuTorch". Engineering at Meta, 2025-07-28. https://engineering.fb.com/2025/07/28/android/executorch-on-device-ml-meta-family-of-apps/
9. Meta. "Llama 3.2: Revolutionizing edge AI and vision with open, customizable models". Meta AI Blog, 2024-09-25. https://ai.meta.com/blog/llama-3-2-connect-2024-vision-edge-mobile-devices/
10. PyTorch. "v0.1.0" (release notes). GitHub, pytorch/executorch, 2023-10-17. https://github.com/pytorch/executorch/releases/tag/v0.1.0
11. PyTorch. "v1.0.0" (release notes). GitHub, pytorch/executorch, 2025-10-18. https://github.com/pytorch/executorch/releases/tag/v1.0.0
12. PyTorch. "ExecuTorch 1.1 Release Notes" (v1.1.0). GitHub, pytorch/executorch, 2026-01-27. https://github.com/pytorch/executorch/releases/tag/v1.1.0
13. PyTorch. "v1.2.0" (release notes). GitHub, pytorch/executorch, 2026-04-01. https://github.com/pytorch/executorch/releases/tag/v1.2.0
14. PyTorch. "v1.6.0" (release notes). GitHub, pytorch/executorch, 2026-11-12. https://github.com/pytorch/executorch/releases/tag/v1.6.0
15. PyTorch. "Releases". GitHub, pytorch/executorch, accessed 2026-11-18. https://github.com/pytorch/executorch/releases
16. PyTorch. "Runtime Compatibility Policy". GitHub, pytorch/executorch (runtime/COMPATIBILITY.md), accessed 2026-11-18. https://github.com/pytorch/executorch/blob/main/runtime/COMPATIBILITY.md
17. PyTorch. "Backend Overview". ExecuTorch main documentation, accessed 2026-11-18. https://docs.pytorch.org/executorch/main/backends-overview.html
18. PyTorch. "Success Stories". ExecuTorch main documentation, accessed 2026-11-18. https://docs.pytorch.org/executorch/main/success-stories.html
19. Roy, Sharbani. "Redefining the Edge AI Developer Experience on Arm with New ExecuTorch 1.0 GA Release". Arm Newsroom, 2025-10-22. https://newsroom.arm.com/news/executorch-1-0-ga-release-edge-ai
20. Meta Platforms and contributors. "LICENSE" (BSD License for ExecuTorch software). GitHub, pytorch/executorch, accessed 2026-11-18. https://github.com/pytorch/executorch/blob/main/LICENSE
21. Python Package Index. "executorch 1.6.0". PyPI, accessed 2026-11-18. https://pypi.org/project/executorch/
22. PyTorch. "PyTorch Mobile" (pytorch.org/mobile/home, redirects to the ExecuTorch documentation), accessed 2026-11-18. https://pytorch.org/mobile/home/
23. GitHub. "pytorch/executorch" (repository metadata, created_at). GitHub REST API, accessed 2026-11-18. https://api.github.com/repos/pytorch/executorch
24. PyTorch. "v1.5.0" (release notes). GitHub, pytorch/executorch, 2026-09-16. https://github.com/pytorch/executorch/releases/tag/v1.5.0
25. PyTorch. "ExecuTorch v1.3.1 Release Notes" (v1.3.1). GitHub, pytorch/executorch, 2026-05-29. https://github.com/pytorch/executorch/releases/tag/v1.3.1
26. PyTorch. "v1.4.0" (release notes). GitHub, pytorch/executorch, 2026-08-07. https://github.com/pytorch/executorch/releases/tag/v1.4.0

