ARM support#
Open3D provides experimental support for 64-bit ARM architecture (arm64
or aarch64
) on Linux and macOS (Apple Silicon). Starting from Open3D 0.14,
we provide pre-compiled ARM64 wheels for Linux and macOS. Install the wheel by:
pip install open3d
python -c "import open3d; print(open3d.__version__)"
# Test the legacy visualizer
python -c "import open3d as o3d; c = o3d.geometry.TriangleMesh.create_box(); o3d.visualization.draw_geometries([c])"
# Test the new GUI visualizer
python -c "import open3d as o3d; c = o3d.geometry.TriangleMesh.create_box(); o3d.visualization.draw(c)"
Linux (OpenGL) |
Linux (OpenGL ES) |
macOS |
Windows on ARM |
|
---|---|---|---|---|
|
Yes |
Yes |
Yes |
No |
Compile from source |
Yes |
Yes |
Yes |
No |
Visualizer and GUI |
Yes |
No |
Yes |
No |
Non-GUI features |
Yes |
Yes |
Yes |
No |
Special build flags |
Not needed |
|
Not needed |
N/A |
Example device |
Nvidia Jetson |
Raspberry Pi 4 |
M1 MacBook |
Surface Pro X |
Additional notes:
On Linux, check the output of
uname -p
and it should showaarch64
. On macOS, check the output ofuname -m
and it should showarm64
.Full OpenGL (not OpenGL ES) is needed for Open3D GUI. Open3D GUI is supported on Nvidia Jetson platforms and on Apple ARM64 devices.
If the full OpenGL is not available (e.g. on Raspberry Pi devices), the Open3D GUI code will compile but it won’t run. In this case, we recommend setting
-DBUILD_GUI=OFF
during thecmake
configuration step.For Windows on ARM devices, Open3D might work with the x86 emulation layer, but it is not official supported.
Open3D installed via
pip install open3d
will not contain CUDA support on ARM64 platforms. To use CUDA, you need to compile Open3D with CUDA manually for Nvidia Jetson boards.
Compiling Open3D on ARM64 Linux#
Building Open3D Python Wheel with Docker#
This is recommended for Python users. By using Docker, the only dependency to install is the Docker engine itself. This is especially useful since ARM64 Linux has many variants and it could be difficult to configure all dependencies manually.
To build Open3D Python wheel with Docker, you can run one of the following commands:
cd docker
./docker_build.sh openblas-arm64-py38 # Python 3.8
./docker_build.sh openblas-arm64-py39 # Python 3.9
./docker_build.sh openblas-arm64-py310 # Python 3.10
./docker_build.sh openblas-arm64-py311 # Python 3.11
After running docker_build.sh
, you shall see a .whl
file generated the
current directly on the host. Then simply install the .whl
file by:
# Optional: activate your virtualenv
conda activate your-virtual-env
# Install and test
pip install open3d-*.whl
python -c "import open3d; print(open3d.__version__)"
python -c "import open3d as o3d; c = o3d.geometry.TriangleMesh.create_box(); o3d.visualization.draw_geometries([c])"
python -c "import open3d as o3d; c = o3d.geometry.TriangleMesh.create_box(); o3d.visualization.draw(c)"
The ./docker_build.sh
script works on both Linux and macOS ARM64 hosts. You
can even cross-compile an ARM64 wheel on an x86-64 host. Install Docker and
Qemu:
sudo apt-get --yes install qemu binfmt-support qemu-user-static
and follow the same steps as above.
Building Open3D directly#
You may run into issues building Open3D directly on your ARM64 machine due to dependency conflicts or version incompatibilities. In general, we recommend building from a clean OS and only install the required dependencies by Open3D. It has been reported by users that some globally installed packages (e.g. TBB, Parallel STL, BLAS, LAPACK) may cause compatibility issues if they are not the same version as the one used by Open3D.
If you only need the Python wheel, consider using the Docker build method or
install Open3D via pip install open3d
directly.
Install dependencies#
# Install dependencies
./util/install_deps_ubuntu.sh
# Optional: ccache is recommended to speed up subsequent builds
sudo apt-get install -y ccache
# Check cmake version, you should have 3.19+
cmake --version
If the Open3D build system complains about CMake xxx or higher is required
,
refer to one of the following options:
Download the pre-compiled
aarch64
CMake from CMake releases, and setupPATH
accordingly.Install with
pip
(run inside a Python virtual environment):pip install cmake
Build#
# Optional: activate your virtualenv
conda activate your-virtual-env
# Configure
# Set -DBUILD_CUDA_MODULE=ON if CUDA is available (e.g. on Nvidia Jetson)
# Set -DBUILD_GUI=ON if full OpenGL is available (e.g. on Nvidia Jetson)
cd Open3D && mkdir build && cd build
cmake -DBUILD_CUDA_MODULE=OFF -DBUILD_GUI=OFF ..
# Build
make -j$(nproc)
make install-pip-package -j$(nproc)
# Test C++ viewer app (only available when -DBUILD_GUI=ON)
./bin/Open3D/Open3D
# Test Python visualization (only available when -DBUILD_GUI=ON)
python -c "import open3d; print(open3d.__version__)"
python -c "import open3d as o3d; c = o3d.geometry.TriangleMesh.create_box(); o3d.visualization.draw_geometries([c])"
python -c "import open3d as o3d; c = o3d.geometry.TriangleMesh.create_box(); o3d.visualization.draw(c)"
Compiling Open3D on ARM64 macOS#
# Dependencies
brew install gfortran
# Optional: ccache is recommended to speed up subsequent builds
sudo apt-get install -y ccache
# Optional: activate your virtualenv
conda activate your-virtual-env
# Configure and choose build options
cd Open3D && mkdir build && cd build
cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_TENSORFLOW_OPS=ON -DBUILD_PYTORCH_OPS=ON -DBUNDLE_OPEN3D_ML=ON ..
# Build
make pip-package -j8 # Build Python wheel
make package -j8 # Build macOS devel binary package
make Open3DViewer -j8 # Build Open3D viewer app
# Test C++ viewer app
./bin/Open3D/Open3D
# Test Python visualization
python -c "import open3d; print(open3d.__version__)"
python -c "import open3d as o3d; c = o3d.geometry.TriangleMesh.create_box(); o3d.visualization.draw_geometries([c])"
python -c "import open3d as o3d; c = o3d.geometry.TriangleMesh.create_box(); o3d.visualization.draw(c)"