Kapan terakhir kali kamu coba bikin script buat robot fisik terus langsung pusing gara-gara dependency hell di ROS? Industri robotik sudah lama tertinggal dibanding ekosistem software modern yang serba cepat dan intuitif. Kehadiran **Spectacles Dimensional OS & dimensioOS: OS Dimensi untuk Smart Glasses** membuktikan kalau mengendalikan robot quadruped atau humanoid sekarang bisa segampang nge-prompt LLM dan menggeser marker hantu di kacamata AR. Ini bukan demo video CGI fiktif, melainkan sebuah ekosistem agent-native berbasis Python yang beneran jalan di hardware komersial.

Dimensional OS (DimOS) membuang arsitektur kaku khas robotik tradisional dan menggantinya dengan paradigma *vibecode*. Kamu tidak perlu lagi bertengkar dengan *build system* yang rumit hanya untuk membuat robot berjalan melintasi ruangan. Cukup gunakan Python, panggil pustaka modulnya, dan hubungkan ke kacamata Snap Spectacles untuk kontrol spasial secara *real-time*.

## Bye-Bye ROS: Mengapa Dimensional OS Berbeda?

Selama bertahun-tahun, Robot Operating System (ROS) menjadi standar *de facto* di dunia akademik dan industri. Masalahnya, ROS punya kurva pembelajaran yang terjal, konfigurasi yang *bloated*, dan integrasi AI yang sering kali terasa seperti tempelan. DimOS mengambil pendekatan yang bertolak belakang: **agent-native** dan **Python-first**.

DimOS berjalan sebagai *operating system* spasial tempat agen AI bertindak sebagai modul native. Agen ini bisa berlangganan (*subscribe*) langsung ke *stream* sensor bawaan, mulai dari perception (LiDAR, kamera), *spatial memory* (Spatio-temporal RAG dan *object permanence*), hingga *control loop* dan *motor driver*.

Dukungan hardware yang diberikan juga tidak main-main. DimOS sudah mendukung berbagai bentuk fisik robot dari produsen terkemuka.

| Tipe Robot | Model Hardware | Status Dukungan |
| :--- | :--- | :--- |
| **Quadruped** | Unitree Go2 pro/air | Stable (🟩) |
| **Quadruped** | Unitree B1 | Experimental (🟥) |
| **Humanoid** | Unitree G1 | Beta (🟨) |
| **Arm** | Xarm / AgileX Piper | Beta (🟨) |
| **Drone** | MAVLink / DJI Mavic | Alpha (🟧) |

Guna menyambungkan antar modul, DimOS menggunakan fungsi `autoconnect()` yang mengaitkan data *stream* berdasarkan nama dan tipe pesan. Transport layer di belakangnya sangat fleksibel, mendukung LCM, Shared Memory (SHM), DDS, Zenoh, hingga interop dengan ROS 2 jika kamu memang masih membutuhkannya.

```python
from dimos.core.coordination.blueprints import autoconnect
from dimos.core.transport import LCMTransport
from dimos.msgs.sensor_msgs import Image
from dimos.robot.unitree.go2.connection import go2_connection
from dimos.agents.mcp.mcp_client import McpClient
from dimos.agents.mcp.mcp_server import McpServer

# Menghubungkan stream kamera robot ke LLM agent berbasis MCP
blueprint = autoconnect(
    go2_connection(),
    McpServer.blueprint(),
    McpClient.blueprint(),
).transports({("color_image", Image): LCMTransport("/color_image", Image)})

if __name__ == "__main__":
    blueprint.build().loop()
```

## Menghubungkan AR dengan Robot Fisik via Snap Spectacles

Di sinilah letak keajaibannya. Proyek `spectacles-dimensional-os` memanfaatkan Snap Spectacles (2024 developer kit) sebagai antarmuka fisik untuk melihat apa yang "dilihat" dan "dipikirkan" oleh robot.

Sistem ini bekerja dengan membagi beban kerja secara pragmatis. Sebuah komputer Mac menjalankan DimOS yang mengurus seluruh *stack* fisik robot (koneksi WebRTC/DDS, pemetaan LiDAR, perencana rute, dan LLM). Sementara itu, modul `dimos-ar` bertindak sebagai *bridge* yang mengirimkan posisi robot, *pathing*, dan *point cloud* LiDAR melalui **WebSocket** ke aplikasi Lens di kacamata Spectacles.

### Solusi Cerdas Masalah Pose Drift: AprilTag Calibration

Salah satu masalah terbesar pada robot fisik seperti Unitree Go2 atau G1 adalah **inconsistent odometry**. Robot mengestimasi lokasinya dengan menjumlahkan seberapa jauh kakinya melangkah. Lama-kelamaan, eror kecil menumpuk. Hasilnya? Posisi robot di dunia nyata dan di tampilan AR kacamata bisa melenceng sekitar 25 cm setiap jarak tempuh 5 meter.

Untuk mengatasi ini, DimOS menggunakan sistem kalibrasi visual berbasis **AprilTag**:

1. **Unitree Go2**: Dipasangi satu AprilTag (ID 0, ukuran 70 mm) yang ditempel mendatar di bagian atas bodi robot (18 cm di depan pusat robot dan 6 cm ke atas).
2. **Unitree G1**: Dipasangi dua AprilTag (ID 0 di dada, ID 1 di punggung) agar kacamata bisa mengenali orientasi robot dari depan maupun belakang.

Saat penggunanya berjalan di sekitar robot sambil melihat AprilTag tersebut, kacamata akan mengirimkan *frame* kamera ke *bridge*. *Bridge* lalu menghitung ulang matriks transformasi antara koordinat kacamata dan koordinat robot. Begitu AprilTag terdeteksi, eror *drift* langsung dikoreksi secara otomatis.

```
[ Unitree Go2 / G1 ] <---(WebRTC / DDS)---> [ Dimensional OS (Mac) ]
                                                    |
                                             (dimos-ar Bridge)
                                                    |
                                            (WebSocket Protocol)
                                                    |
                                           [ Snap Spectacles Lens ]
```

## Antarmuka Spasial: Manual Control vs Agent Mode

Pengalaman navigasi di Snap Spectacles dibuat serba praktis. Buka telapak tangan kiri ke atas, dan *wrist menu* akan muncul di udara. Dari menu ini, kamu bisa mengatur mode tampilan LiDAR:

* **Off**: Menyembunyikan data titik sensor demi menghemat pemrosesan.
* **Obstacles Only**: Hanya menampilkan objek terdekat, sangat efisien dari sisi performa.
* **Full Point Cloud**: Menampilkan seluruh titik pemindaian 3D di sekitar robot. Namun mode ini tergolong berat dan bisa membuat kacamata panas jika dinyalakan terlalu lama.

### Manual Mode
Kamu akan melihat ikon `NavigationMarker` melayang di atas robot. Kamu tinggal menarik marker tersebut menggunakan gesture tangan ke lokasi tujuan di dalam ruangan dan memutar arah panahnya. Robot akan langsung bergerak mengikuti jalur navigasi berwarna kuning yang dirender secara *real-time* di lantai.

### Agent Mode (GPT-4o + MCP)
Cukup ucapkan kata kunci **"Robot"**, lalu berikan instruksi suara. Suara kamu diproses menjadi teks di Spectacles, lalu dikirim ke agen **GPT-4o** yang berjalan di Mac. Agen ini terhubung ke *Model Context Protocol* (MCP) dan memiliki berbagai *skill* yang bisa dipanggil secara dinamis.

| Nama Skill (MCP Tool) | Fungsi Operasional |
| :--- | :--- |
| `relative_move` | Meminta robot melangkah atau berbelok relatif dari posisinya sekarang. |
| `navigate_to_user` | Memerintahkan robot berjalan menghampiri posisi kacamata penggunanya. |
| `get_user_pose` | Mengambil data koordinat dan orientasi posisi berdiri pengguna. |
| `cancel_navigation` | Menghentikan pergerakan robot seketika (*emergency stop*). |
| `place_marker` | Menaruh marker penanda melayang di koordinat ruang tertentu. |
| `draw_line` / `clear_annotation` | Menggambar atau menghapus garis virtual di ruang fisik. |

Hebatnya, jika agen AI melakukan kesalahan navigasi, kamu bisa langsung mengeksekusi *override*. Cukup pegang marker navigasi virtual dengan tanganmu, maka kontrol otomatis dari agen akan langsung dibatalkan.

## Panduan Hands-On: Menjalankan DimOS di Mesin Lokal

Bagi para *developer*, mencoba DimOS sangatlah mudah karena mereka menyediakan CLI yang lengkap dan mode simulasi berbasis MuJoCo. Kamu bahkan tidak wajib memiliki hardware robot fisik untuk mulai bereksperimen.

### 1. Instalasi Cepat via Shell & Python
Sistem dependencies DimOS diuji secara stabil pada Ubuntu 22.04 / 24.04 dan NixOS. Untuk mengisntalnya, gunakan script instalasi interaktif:

```bash
# Install dependencies utama DimOS
curl -fsSL https://raw.githubusercontent.com/dimensionalOS/dimos/main/scripts/install.sh | bash

# Buat virtual environment berbasis Python 3.12 menggunakan uv
uv venv --python "3.12"
source .venv/bin/activate

# Install package DimOS beserta modul Unitree dan Simulation
uv pip install 'dimos[base,unitree,sim]'
```

### 2. Menjalankan Simulasi dan Replay Mode
Jika tidak ada hardware, kamu bisa memanfaatkan fitur *replay* dari sesi log yang sudah direkam atau menjalankan simulasi fisika MuJoCo:

```bash
# Replay navigasi quadruped (SLAM, costmap, & A* planning)
dimos --replay run unitree-go2

# Menjalankan humanoid Unitree G1 di simulasi MuJoCo
dimos --simulation run unitree-g1-sim

# Menjalankan agen AI dengan LLM lokal (membutuhkan Ollama)
dimos --simulation run unitree-go2-agentic-ollama
```

### 3. Manajemen CLI dan dimTELE
Untuk interaksi *runtime*, CLI `dimos` menyediakan kendali penuh atas *daemon* dan *skill* MCP:

```bash
# Jalankan blueprint di background
dimos run unitree-go2-agentic --daemon

# Kirim perintah teks langsung ke agen
dimos agent-send "explore the room"

# Panggil skill MCP secara langsung
dimos mcp call move_to --arg x=0.5 --arg relative=true
```

Jika kamu ingin mengendalikan robot dari jarak jauh tanpa harus pusing memikirkan *port forwarding* atau IP publik, gunakan **dimTELE**. Fitur *hosted teleoperation* berbasis WebRTC ini memungkinkan robot "menelepon" ke *broker server* dari balik router rumah atau jaringan seluler. Kamu tinggal membuka `teleop.dimensionalos.com` di browser atau headset Meta Quest untuk mengemudikan robot secara langsung.

## Realita Hardware dan Masa Depan Spasial AI

Dimensional OS dan integrasi Snap Spectacles menunjukkan ke mana arah perkembangan robotik. Kombinasi antara *interface* AR, *framework* Python yang modern, serta fleksibilitas agen LLM berhasil memotong kompleksitas software robotik yang selama ini terkenal kaku.

Tentu saja, masih ada batasan teknis yang perlu diperhatikan. Akumulasi eror dari odometry robot fisik masih membutuhkan intervensi kalibrasi visual AprilTag secara berkala. Pemrosesan *full point cloud* di kacamata AR juga masih berisiko memicu masalah termal jika digunakan terus-menerus. Namun, fondasi arsitektur yang mereka bangun di sini sudah sangat tepat. Ini adalah batu loncatan penting menuju era di mana manusia dan robot bisa berinteraksi secara alami di ruang fisik yang sama.

## Referensi
- https://github.com/dimensionalOS/dimos
- https://github.com/V4C38/spectacles-dimensional-os

Dimensional OS menghadirkan revolusi baru dalam pengembangan robotik dengan mengintegrasikan Snap Spectacles AR, Python native, dan agen AI tanpa kerumitan ROS.

Mengontrol Robot Pake Kacamata AR dan Python? Dimensional OS Bikin ROS Kelihatan Kuno

Reggi

Solusi praktis integrasi webmail custom ke dalam dashboard Gmail. Kelola, baca, dan kirim email domain pribadi langsung dari satu tempat tanpa ribet gonta-ganti tab.

Mengapa Kamu Masih Buka Dua Tab Terpisah? Panduan Setup Custom Webmail Langsung di Dashboard Gmail

Pelajari efisiensi merakit mesin tetas telur listrik AC otomatis dengan modal murah untuk mendongkrak hasil ternak unggas tanpa repot bolak-balik telur manual.

Otomasi Ternak Unggas: Kenapa Rakit Sendiri Mesin Penetas Telur AC Jauh Lebih Worth It Dibanding Cara Konvensional?

Pelajari bagaimana mesin tetas telur berbasis arus listrik DC bekerja menjaga suhu dan kelembapan ideal untuk mendongkrak keberhasilan penetasan telur unggas.

Mesin Tetas Telur Arus DC: Solusi Hardware Murah Buat Tingkatin Angka Penetasan Unggas

Kupas tuntas seluk-beluk mobil aki anak dengan kontrol ganda dan fitur multimedia. Pahami batas spesifikasi hardware sebelum eksekusi build sendiri.

EV Versi Mini: Membedah Mobil Listrik Aki Lengkap dengan Remote Control dan Fitur Multimedia

Pelajari cara merakit smart power strip berbasis NodeMCU dan Blynk untuk kontrol daya nirkabel serta integrasi IoT yang aman dan efisien.

Mengapa Beli Mahal Kalau Bisa Bikin Sendiri? Rancang Smart Power Strip Berbasis NodeMCU dan Blynk

Solusi tuntas mengatasi bug sistem dan software bermasalah di MacBook dengan panduan install ulang macOS lewat Internet Recovery secara aman.

#dimensionalos

Getting Lastest Post..

Populer Bulan Ini