Citation and evidence

ExecuTorch

19 min full readUpdated 26 references

This article's verification

Report a problem with this article

Edit article
More

Cite this article

ExecuTorch is an open-source runtime and toolchain from the PyTorch project for running trained 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

AttributeDetail
DeveloperMeta (PyTorch Edge team) and contributors; a PyTorch Core project since April 2026[7]
First public releasev0.1.0 preview, 2023-10-17[10]
General availabilityv1.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]
LicenseBSD-style (PyPI lists BSD-3-Clause)[20][21]
Core runtime languageC++17[2]
Model file format.pte (program), .ptd (named tensor and delegate data)[2]
Python packageexecutorch on PyPI, Python 3.11 to 3.15 as of v1.6.0[21][14]
Repositorygithub.com/pytorch/executorch[1]

Expanded article table

"ExecuTorch 1.0: General Availability Status for Mobile and Embedded...- Mergen Nachin & Cemal Bilgin", official video from PyTorch Foundation, published November 4, 2025. Watch on YouTube.

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. It added 4-bit post-training quantization with GPTQ and dynamic-shape support in the XNNPACK CPU backend, which the team said let 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 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 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) 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 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 GPUs to the AOTInductor-based CUDA backend.[24] Version 1.6 (November 2026) promoted the NXP Neutron backend to production-ready, added a 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

VersionDateMilestone
v0.1.02023-10-17First public release, preview only[10]
v0.2.02024-04-29Llama 2 7B and Llama 3 8B support; alpha announced the next day[15][4]
v0.4.02024-10-18Beta (announced 2024-10-24)[15][5]
v1.0.02025-10-18General availability (announced 2025-10-22)[11][6]
v1.1.02026-01-27Experimental CUDA and Metal backends[12]
v1.2.02026-04-01Aligned with PyTorch 2.11; Cortex-M backend[13]
v1.3.12026-05-29First broadly published 1.3 build (1.3.0 was Maven-only)[25]
v1.4.02026-08-07Vulkan on Linux and Windows desktop GPUs[26]
v1.5.02026-09-16C++ SDK in wheels; ROCm support[24]
v1.6.02026-11-12NXP Neutron production-ready; TensorRT beta[14]

Expanded article table

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).[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 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 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, 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 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]

PhasePyTorch MobileExecuTorchSpeedup
Deserialization510975.3x
Initialization312,6318,35037.4x
Framework overhead per run324,399754,325x
Total per inference654,0099,27270.5x

Expanded article table

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]

BackendPlatformsHardware
XNNPACKAllCPU (general purpose and fallback)
Core MLiOS, macOSNPU, GPU, CPU
MLXmacOS; iOS experimentalApple silicon GPU
Core AIiOS, macOSApple devices on OS 27, experimental
VulkanAndroid; Linux and Windows experimentalGPU
WebGPUBrowser, Linux, macOSGPU, experimental
Qualcomm AI Engine DirectAndroidNPU (Hexagon)
MediaTekAndroidNPU
Samsung ExynosAndroidCPU, GPU, NPU
Arm VGFAndroidGPU
Arm Ethos-UEmbeddedNPU
Arm Cortex-MEmbeddedCPU (microcontrollers)
NXP eIQ NeutronEmbeddedNPU
CadenceEmbeddedDSP
OpenVINOEmbeddedCPU, GPU, NPU on Intel SoCs
CUDALinux, WindowsNVIDIA GPU
TensorRTLinux, WindowsNVIDIA GPU

Expanded article table

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.[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, or from the Hugging Face Transformers 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'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 quantization, 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.[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 and 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, Voxtral Realtime, Voxtral TTS), speaker diarization, Gemma 4 multimodal models and 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 had higher decode throughput for Qwen3 0.6B and 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 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 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 (which said it uses ExecuTorch for its LFM2 models) and Mistral AI (which said it runs Voxtral on it).[6] The project's success-stories page, as of November 2026, lists LM Studio voice transcription with NVIDIA Parakeet TDT on macOS and Windows as a production deployment, along with integrations by 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.[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]

Continue reading

More from See also

More to read

Topics:Developer ToolsEdge computingMachine LearningOpen Source AI

References

  1. ^1 ^2 ^3 ^4 ^5 ^6PyTorch. "ExecuTorch" (README, main branch). GitHub, pytorch/executorch, accessed 2026-11-18. github.com/...executorch
  2. ^1 ^2 ^3 ^4 ^5 ^6 ^7 ^8 ^9 ^10 ^11 ^12 ^13 ^14 ^15 ^16 ^17 ^18 ^19 ^20 ^21 ^22 ^23 ^24 ^25 ^26 ^27 ^28 ^29 ^30 ^31 ^32 ^33 ^34 ^35 ^36 ^37 ^38 ^39Nachin, 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. arxiv.org/...2605.08195
  3. ^1 ^2 ^3PyTorch Edge Team. "PyTorch Edge: Enabling On-Device Inference Across Mobile and Edge Devices with ExecuTorch". PyTorch Blog, 2023-10-17. pytorch.org/...le-and-edge-devices-with-executorch
  4. ^1 ^2 ^3PyTorch Foundation. "ExecuTorch Alpha: Taking LLMs and AI to the Edge with Our Community and Partners". PyTorch Blog, 2024-04-30. pytorch.org/...executorch-alpha
  5. ^1 ^2 ^3 ^4 ^5PyTorch Foundation. "ExecuTorch Beta: On-Device AI and LLMs, Stability, and Acceleration with Partners". PyTorch Blog, 2024-10-24. pytorch.org/...executorch-beta
  6. ^1 ^2 ^3 ^4 ^5 ^6 ^7 ^8 ^9PyTorch Team at Meta. "Introducing ExecuTorch 1.0: Powering the next generation of edge AI". PyTorch Blog, 2025-10-22. pytorch.org/...introducing-executorch-1-0
  7. ^1 ^2 ^3 ^4 ^5 ^6PyTorch Foundation. "ExecuTorch Becomes a Part of PyTorch Core to Expand On-Device Inference Capabilities". PyTorch Blog, 2026-04-07. pytorch.org/...utorch-becomes-part-of-pytorch-core
  8. ^1 ^2 ^3 ^4PyTorch 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. engineering.fb.com/...evice-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. ai.meta.com/...ect-2024-vision-edge-mobile-devices
  10. ^1 ^2 ^3PyTorch. "v0.1.0" (release notes). GitHub, pytorch/executorch, 2023-10-17. github.com/...v0.1.0
  11. ^1 ^2 ^3 ^4PyTorch. "v1.0.0" (release notes). GitHub, pytorch/executorch, 2025-10-18. github.com/...v1.0.0
  12. ^1 ^2PyTorch. "ExecuTorch 1.1 Release Notes" (v1.1.0). GitHub, pytorch/executorch, 2026-01-27. github.com/...v1.1.0
  13. ^1 ^2PyTorch. "v1.2.0" (release notes). GitHub, pytorch/executorch, 2026-04-01. github.com/...v1.2.0
  14. ^1 ^2 ^3 ^4 ^5PyTorch. "v1.6.0" (release notes). GitHub, pytorch/executorch, 2026-11-12. github.com/...v1.6.0
  15. ^1 ^2 ^3PyTorch. "Releases". GitHub, pytorch/executorch, accessed 2026-11-18. github.com/...releases
  16. ^1 ^2 ^3PyTorch. "Runtime Compatibility Policy". GitHub, pytorch/executorch (runtime/COMPATIBILITY.md), accessed 2026-11-18. github.com/...COMPATIBILITY.md
  17. ^1 ^2 ^3PyTorch. "Backend Overview". ExecuTorch main documentation, accessed 2026-11-18. docs.pytorch.org/...backends-overview
  18. ^1 ^2 ^3PyTorch. "Success Stories". ExecuTorch main documentation, accessed 2026-11-18. docs.pytorch.org/...success-stories
  19. ^Roy, Sharbani. "Redefining the Edge AI Developer Experience on Arm with New ExecuTorch 1.0 GA Release". Arm Newsroom, 2025-10-22. newsroom.arm.com/...cutorch-1-0-ga-release-edge-ai
  20. ^Meta Platforms and contributors. "LICENSE" (BSD License for ExecuTorch software). GitHub, pytorch/executorch, accessed 2026-11-18. github.com/...LICENSE
  21. ^1 ^2Python Package Index. "executorch 1.6.0". PyPI, accessed 2026-11-18. pypi.org/...executorch
  22. ^PyTorch. "PyTorch Mobile" (pytorch.org/mobile/home, redirects to the ExecuTorch documentation), accessed 2026-11-18. pytorch.org/...home
  23. ^GitHub. "pytorch/executorch" (repository metadata, created_at). GitHub REST API, accessed 2026-11-18. api.github.com/...executorch
  24. ^1 ^2PyTorch. "v1.5.0" (release notes). GitHub, pytorch/executorch, 2026-09-16. github.com/...v1.5.0
  25. ^1 ^2PyTorch. "ExecuTorch v1.3.1 Release Notes" (v1.3.1). GitHub, pytorch/executorch, 2026-05-29. github.com/...v1.3.1
  26. ^1 ^2PyTorch. "v1.4.0" (release notes). GitHub, pytorch/executorch, 2026-08-07. github.com/...v1.4.0

Improve this article

Add missing citations, update stale details, or write a clearer explanation. Anyone can edit: changes go live when you publish, and every edit is checked by an editor.

2 revisions · v2 · 3,790 words · full history

Fact-checks are independent of edits: a reviewer re-verifies the article against its sources and stamps the date. How we verify

Research and drafting on this wiki are AI-assisted, under named human editorial standards. How AI is used here

Reviewer note: Independent fact-check before publication on November 18, 2026: 112 claims checked against 26 cited and independent sources; 0 material and 5 minor corrections applied before publication.

Cite this page: AI Wiki. "ExecuTorch." aiwiki.ai, updated 18 Nov 2026, fact-checked 18 Nov 2026. CC BY 4.0. https://aiwiki.ai/wiki/executorch

Edit article