> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wuji.tech/llms.txt
> Use this file to discover all available pages before exploring further.
# Release notes
> Firmware, SDK and toolchain updates across the Wuji line
## October 2026
**Release Highlights**
* **Compatibility and migration**: Wuji Description moves to Hand 2.1 and Hand 2.2 ROS 2 packages. Update resource paths, dependencies, and launch configurations.
* **Runtime and operations**: Wuji SDK and Wuji CLI Linux artifacts support Ubuntu 20.04 LTS and later on x86\_64 and arm64. The Python SDK now supports Python 3.8 and later. Wuji CLI checks installed agent skills for expiration and warns when they are out of date. It also improves device connections, data subscriptions, and firmware upgrades.
* **Status and diagnostics**: The Wuji SDK for Wuji Hand 2 reads `kp` and `kd` for all 20 joints after connection. Communication diagnostics and firmware upgrade errors now provide more useful results. Starting with firmware v2.10.0, an upgrade stops early when a selected joint is offline and shows the device rejection reason.
**Breaking Changes**
**Wuji Description Model Migration**
* **Wuji Description**: The Beta 1 and Beta 2 packages, their `_with_mount` variants, and the full-hand STEP assemblies are removed. Use the Hand 2.1 and Hand 2.2 models rooted at the arm flange mount. Update `colcon --packages-select`, `package://` URIs, dependencies, and launch configurations to `wuji_hand2_1_description` or `wuji_hand2_2_description`.
**New Features**
**Runtime and Version Support**
* **Wuji SDK and Wuji CLI**: Python SDK, C SDK, and CLI Linux artifacts support Ubuntu 20.04 LTS (glibc 2.31) and later on x86\_64 and arm64. The Python SDK now supports Python 3.8 and later.
* **Wuji CLI**: Added links to agent skills and documentation in `wuji --help`, making Wuji CLI guidance easier for agents to find. Wuji CLI checks installed agent skills for expiration and warns on every command when a skill is out of date. Running `wuji update` also updates the matching skills.
**Joint Parameter Readback**
* **Wuji Hand 2**: After a connection is established, the Wuji SDK for Wuji Hand 2 reads back `kp` and `kd` for all 20 joints once and writes them to the SDK log as one line in the form `param readback sn= path=mit_params thumb/S1 kp=… kd=… …`. An offline joint is logged as `offline`. If the readback fails, the SDK logs a warning and the connection remains active.
**CLI Device Operations**
* **Wuji CLI**: Wuji CLI now records commands, exit codes, durations, and errors. View them with `wuji logs list`, or select them with `--source cli` when exporting logs.
**Wuji Description Models and Resources**
1. Added the Hand 2.1 model at `hand2/hand2_1/body/` as the standalone ROS 2 package `wuji_hand2_1_description`, with left- and right-hand models and URDF, MuJoCo MJCF, and Isaac Sim USD assets.
2. Added the Hand 2.2 model at `hand2/hand2_2/body/` as the standalone ROS 2 package `wuji_hand2_2_description`.
3. Added palm mounting-interface STEP assemblies for each hand under the corresponding `attachment/` directory. These files are outside the ROS 2 package root.
**Changed**
**Firmware Parameters**
* **Wuji Hand 2 Firmware**: For new or reset joint configurations, this release updates the default MIT impedance control `kd` gain to 0.1 and uses `kp` = 5.0. Firmware upgrades preserve previously saved joint parameters.
**Improvements and Fixes**
22 changes in 5 areas.
**Device Connections and Action Examples**
1. **Wuji SDK**: Connecting to a device the SDK found on the network, or that you connect to by address, no longer fails when another program on the same machine, such as a DDS or ROS 2 stack, holds UDP port 7446. The SDK connects without peer discovery and logs a warning that other SDK processes cannot find and share that device on their own. A device reachable only through another SDK process still needs that port.
2. **Wuji Hand 2**: Python [`2.publish.py`](https://github.com/wuji-technology/wuji-sdk/blob/main/examples/python/wuji_hand_2/2.publish.py) and C [`1_control_motion.c`](https://github.com/wuji-technology/wuji-sdk/blob/main/examples/c/wuji_hand_2/1_control_motion.c) now wait until one diagnostics update reports all 20 joints as Enabled before commanding the hand. Previously, an update covering only online joints counted as the whole hand being ready, so an example could start commanding a hand with joints still disabled.
3. **Wuji Hand 2**: Python [`opposition.py`](https://github.com/wuji-technology/wuji-sdk/blob/main/examples/python/wuji_hand_2/6_opposition/opposition.py) and [`7.mit_sweep.py`](https://github.com/wuji-technology/wuji-sdk/blob/main/examples/python/wuji_hand_2/7.mit_sweep.py), together with C [`opposition.c`](https://github.com/wuji-technology/wuji-sdk/blob/main/examples/c/wuji_hand_2/6_opposition/opposition.c) and [`7_mit_sweep.c`](https://github.com/wuji-technology/wuji-sdk/blob/main/examples/c/wuji_hand_2/7_mit_sweep.c), now scan Wuji Hand 2 devices, list their serial numbers, and connect to the selected device. When multiple hands are found, Enter or closed standard input selects the first device. Previously, the examples could connect to the wrong device type or fail when multiple devices were found.
4. **Wuji Hand 2**: The real-time teleoperation examples ([`1.teleop_real.py`](https://github.com/wuji-technology/wuji-sdk/blob/main/examples/python/retargeting/1.teleop_real.py) and [`1_teleop_real.c`](https://github.com/wuji-technology/wuji-sdk/blob/main/examples/c/retargeting/1_teleop_real.c)) no longer make the hand jump at startup. They require all 20 joints to be online and enabled, read the current hand pose, and transition to the glove pose over about one second while reading glove data on every frame.
5. **Wuji Glove**: Right-hand devices now use the configured IP address.
6. **Wuji Glove**: Left- and right-hand detection now handles inconsistent side-detection signals correctly.
**Data Reception and Subscriptions**
1. **Wuji SDK**: Subscriptions now continue delivering new data after the SDK briefly falls behind. Previously, an internal buffer overflow could silently stop the subscription.
2. **Wuji Glove**: Device data, including `emf_poses`, continues without a one-second pause, dropped frames, or `lagged` warnings when other programs write heavily to the same disk.
3. **Wuji Hand 2**: The `joint_states` and `joint_diagnostics` subscriptions no longer drop frames or log `Virtual subscription '...' lagged N messages` when the host is busy.
4. **Wuji Glove**: Every point near the little-finger base in `tactile_point_cloud` now reports its actual pressure value. Previously, three points near the base reported `-1`, and the corresponding three tactile cells were missing. The point count stays unchanged.
5. **Wuji Hand 2**: For devices running firmware v2.6.0 or earlier that accept SDK connections on port 7447, a stream-rate request with no response now causes Python `Subscription.set_rate()` to raise `WujiException` with `Operation timeout - device not responding`, and C `wuji_sub_set_rate()` to return `WUJI_STATUS_ERR_TIMEOUT`. Previously, Python reported a `WujiException` starting with `Internal error:`, and C returned `WUJI_STATUS_ERR_INTERNAL`.
6. **Wuji Glove**: The EMF stream resumes without a restart after a firmware upgrade fails or is rejected.
7. **Wuji Glove**: Timestamped sensor subscriptions no longer use the device's first power-on time in their first few frames.
8. **Wuji Glove**: Invalid or rejected requests from another host to the data port no longer redirect subscription data to that host or cause frame loss for the original client.
**Communication Diagnostics**
1. **Wuji Hand 2**: The `sdk_dropped` field in the `joint_diagnostics` communication summary now includes frames dropped by the subscription forwarder, covering the forwarding stage that was previously omitted.
2. **Wuji Hand 2**: `joint_diagnostics.comm.e2e_lost` no longer counts frames skipped by `set_rate()` as lost, so lowering the stream rate does not increase the lost-frame count.
**Firmware Upgrades**
* **Wuji Hand 2**: Starting with firmware v2.10.0, the SDK firmware upgrade stops before sending data when a selected joint is offline and lists the offline joints. If the hand rejects the upgrade target and returns a reason, the upgrade fails and shows that reason. Previously, the upgrade reported only a generic error, and firmware v2.6.0 and earlier could report a rejected upgrade as successful.
**CLI Upgrades and Visualization**
1. **Wuji CLI**: `wuji upgrade` shows progress during longer upgrades and displays the installed firmware version afterward.
2. **Wuji CLI**: When `wuji upgrade` runs with `--json` or `--jsonl` without `--yes`, it returns the correct error code.
3. **Wuji CLI**: When a device rejects a raw `.bin` firmware file, `wuji upgrade` no longer reports success.
4. **Wuji CLI**: Fixed `wuji update --skills` hanging while updating agent skills.
5. **Wuji CLI**: Improved the initial scale of the Wuji Glove tactile display in `wuji viz` and fixed the Wuji Glove TX model.
**Product Versions and Acquisition**
| Product or Software | Version | Acquisition |
| - | - | - |
| Wuji Hand 2 Firmware | v2.12.0 | `wuji upgrade` |
| Wuji Glove Firmware | v1.0.3 | `wuji upgrade` |
| Wuji SDK | v2026.10.12 | Python: `pip install --upgrade wuji-sdk`
C: Download from [GitHub Releases](https://github.com/wuji-technology/wuji-sdk/releases) |
| Wuji CLI | v2026.10.12 | `wuji update` |
| Wuji Description | v2026.10.12 | Download from [GitHub Releases](https://github.com/wuji-technology/wuji-description/releases) |
## September 2026
Breaking: SDK connection ports are now configurable, with 50001 as the default instead of 7447. Apps that connect directly to 7447 must switch to 50001.
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Firmware | v2.10.0 | Update via Wuji CLI |
| Wuji SDK | v2026.9.22 | `pip install --upgrade wuji-sdk` |
**Highlights**
* The joint controller adds built-in feed-forward compensation, enabled by default. It requires Wuji Hand 2 firmware v2.10.0 and Wuji SDK v2026.9.22 or later, and applies only to units shipped from October 2026 onward
* Python SDK public operations now raise `WujiException` or one of its subclasses for failures inside the SDK
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji SDK | v2026.9.22 | `pip install --upgrade wuji-sdk` |
**Highlights**
* Python SDK public operations now raise `WujiException` or one of its subclasses for failures inside the SDK. Argument-type and overflow errors raised by the Python interpreter before the SDK call keep their built-in exception types
* Fixed mixed source-event and host-receive timestamps in MCAP recordings
* Fixed multi-device access, cross-application access, and calls through handles after a device disconnects
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Firmware | v1.0.2 | Update via Wuji CLI |
**Highlights**
* The EMF stream now recovers automatically after a failed or rejected firmware upgrade. No restart is required
* Fixed timestamp, right-hand IP address, and left/right detection issues
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji CLI | v2026.9.22 | `wuji update` or the install script |
**Highlights**
* `wuji viz` supports live Wuji Glove visualization
* `wuji update --check` shows the latest release notes and syncs the matching agent skills
Breaking: Starting with firmware v2.7.0, the hand accepts SDK connections on port 50001 instead of port 7447. Applications that reach the hand through SDK device discovery are unaffected. Anything that connects to port 7447 directly must switch to 50001, and firewall rules need updating.
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Firmware | v2.7.1 | Update via Wuji CLI |
| Wuji SDK | v2026.9.14 | `pip install --upgrade wuji-sdk` |
**Highlights**
Breaking changes:
* The hand accepts SDK connections on port 50001 instead of port 7447. Applications that reach the hand through SDK device discovery are unaffected. Anything that connects to port 7447 directly must switch to 50001, and firewall rules that only allow 7447 need updating.
Fixed:
* Fixed some known issues.
## August 2026
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji SDK | v2026.8.31 | `pip install --upgrade wuji-sdk` |
**Highlights**
**General**
Changed:
* The examples now release the device on normal exit paths via `manager.disconnect_all()` in a `finally` block. A connected device stays owned by `SdkManager` until you call `disconnect()` or `disconnect_all()`, or the process exits. Dropping its handle doesn't disconnect it, so long-running programs should disconnect explicitly.
Fixed:
* Reading an SDK parameter that the device defines but that has never been written now raises `Parameter not set` instead of `Path not found`, which previously made a valid-but-unset parameter look like a nonexistent path. `Path not found` is now reserved for paths that don't exist. The C SDK returns `WUJI_STATUS_ERR_NOT_FOUND` for both cases as before. The `wuji_last_error()` message distinguishes them.
* Previewing or importing a user data file now stops up front when the file names a user the SDK can't accept, and existing data stays untouched. The error message names the rejected user. Previously, preview could accept such a file and import could fail with an internal error.
* Connecting to an address without a port, such as `192.168.1.110` instead of `192.168.1.110:7447`, now says a port is required instead of reporting that direct USB path connection is unsupported.
**Devices**
**Wuji Hand 2**
Added:
* Added `wuji_hand_2_decode_joint_status` to decode Wuji Hand 2 joint status words into the four-state `ext_state`, an `enabled` convenience flag, and position, velocity, and current limit flags. Applications no longer need to parse status-word bits.
* Added blocking Python `hand.export_flash_logs()` and C `wuji_hand_2_export_flash_logs()` to export device Flash history logs as JSONL. They write to `~/.wuji/logs/` by default and add a numeric suffix if a file name already exists. Firmware without saved Flash logs reports the export as unsupported. Firmware v2.6.0 and later supports simultaneous exports. When multiple programs export from the same device, the export either completes or reports that the device is busy, and the output directory contains only complete results. Earlier firmware can't detect simultaneous exports, so export one at a time.
Changed:
* An active `joint_diagnostics` subscription now writes a readable SDK log when a joint error appears, changes, or clears. The log includes the hexadecimal code, name, description, cause, suggested action, and clear policy. A held error doesn't repeat. Python `JointDiagnosticsEntry` output now shows `0x2102(Overcurrent)`, keeps zero as `0x0000`, and shows unknown codes as `0xFFFF(Unknown)`.
* Updated fingertip tactile examples.
* Updated fingertip sensor resultant-force application-point and orientation examples.
Fixed:
* Creating a joint handle with an index outside `0..=19` now raises `ValueError` immediately. Previously, out-of-range inputs produced a handle whose metadata could raise `PanicException` or expose the invalid index.
* `describe_error()` returns a `dict`. Read it by key, as in `info["severity"]`. Type hints now name all eight keys. Previously, the documentation described an object with attributes, so `info.severity` raised `AttributeError`.
* Fixed some known issues.
**Wuji Glove**
Added:
* Added `wuji_glove_get_tactile_binary_sensitivity` to the C SDK. It reads the contact sensitivity currently in effect for the connected Wuji Glove and pairs with the existing setter. It returns the default value of `1.0` until a sensitivity is set and clamps stored values to the runtime range of `0.5`–`3.0`.
Changed:
* Updated hand model calibration terminology.
Fixed:
* Fused IMU orientation and wrist transforms now stay stable when device timestamps switch to synchronized time after connection. Previously, this switch could cause an orientation jump.
**Submodules**
**Retargeting**
Changed:
* Pinch-gesture retargeting now provides improved thumb-to-fingertip contact in both the Python and C SDKs.
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Firmware | v2.6.0 | Update via Wuji Studio |
| Wuji SDK | v2026.8.31 | `pip install --upgrade wuji-sdk` |
**Highlights**
Added:
* Added `0x2115` to the error catalog for motor phase-current imbalance. The current firmware observes this condition without raising an error or stopping the joint.
* Fingertip sensor metadata now reports the total-force contact point and axis directions. Applications can use the information to calculate force and torque at the fingertip. Existing applications that do not use the new information continue to work unchanged.
Changed:
* A corrupted encoder frame now raises a warning immediately. Persistent corruption stops the affected joint.
* Updated fingertip sensor mounting information.
* Updated the Wuji SDK fingertip sensor examples for resultant-force application points and orientation.
* Improved system performance.
Fixed:
* Fixed an issue that could cause the device to stop responding when reading Flash memory.
* Fixed joints falsely reporting overcurrent and stopping during thumb-to-finger pinching.
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Firmware | v0.12.0 | Update via Wuji Studio |
**Highlights**
**Firmware**
* Fixed some known issues.
Breaking: Hand model calibration now uses `wuji calib hand-model`. The removed `wuji calib ik` command has no compatibility alias. Events under `--json` and `--jsonl` now use `schema_version: 2` and `calibration: "hand_model"`.
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji CLI | v2026.8.31 | `wuji update` or the install script |
**Highlights**
Added:
* Added `wuji viz` live visualization for viewing Wuji Hand 2 poses and fingertip tactile data.
Changed:
* Hand model calibration now uses `wuji calib hand-model`. The removed `wuji calib ik` command has no compatibility alias.
* `wuji calib hand-model` now provides clearer guidance, pose feedback, and result presentation.
* `wuji user` now provides a clearer, more consistent terminal experience for managing profiles and moving calibration data.
* `wuji calib hand-model` events under `--json` and `--jsonl` now use `schema_version: 2` and `calibration: "hand_model"`. `wuji user import` uses `legacy_hand_model_ignored` and `default_user_hand_model_disabled` to identify why components were skipped.
* `wuji upgrade --file` now validates firmware files locally. Invalid files do not reach the device.
* The one-click install script now installs agent skills to the user-global location for use across projects.
Fixed:
* Firmware downloads on Windows now use the user profile directory instead of the Unix-only `HOME` variable. Calibration export failure paths use stable `/` separators across platforms.
* Fixed some known issues.
* `wuji doctor` no longer fails devices without a diagnostic recipe. A device with no matching diagnostic recipe, such as Wuji Hand 2, is now reported as skipped instead of failed, and the command exits with code `0`. Genuine connection or collection failures still report as failed and exit with code `1`.
* `wuji logs list` and `wuji logs export` now support log directory names containing non-UTF-8 characters.
Important: This release contains a Wuji Glove breaking change — the EMF pose rate divider APIs are removed (Python and C). Use `set_rate` on an `emf_poses` subscription instead.
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji SDK | v2026.8.17 | `pip install --upgrade wuji-sdk` |
**Highlights**
**General**
Added:
* Added `Subscription.set_rate(frequency_hz)` to lower a subscribed stream's device push rate at runtime, in samples per second. Upgrade the device to firmware that supports stream rate control before using this method (Wuji Glove v0.11.4 or later, Wuji Hand 2 v2.3.0 or later). Pass 0 to restore the device default. The call returns the rate the device applies, which may be quantized. Supported on `emf_poses`, `tactile`, `tactile_zones`, and `imu_raw/*` (Wuji Glove) and on `joint_states`, `joint_diagnostics`, `imu`, and `fingertip/*/data` (Wuji Hand 2). Derived streams—including `hand_joint_angles`, `hand_skeleton`, `tip_poses`, and `imu_data/*`—follow their source rate and reject `set_rate`. The setting affects every subscriber of the stream and resets to the device default when the last subscription to the stream is closed or the device reconnects. Examples: `examples/python/wuji_glove/6.set_stream_rate.py` and `examples/c/wuji_glove/1_set_stream_rate.c` for the Wuji Glove, and `examples/python/wuji_hand_2/4.set_stream_rate.py` and `examples/c/wuji_hand_2/4_set_stream_rate.c` for the Wuji Hand 2.
* C SDK: Added `wuji_sub_set_rate(sub, frequency_hz, out_actual_hz)` on any subscription handle, matching the Python `Subscription.set_rate` semantics. Streams that do not support rate control return `WUJI_STATUS_ERR_UNSUPPORTED (-8)` without sending a rate-control request to the device.
Changed:
* `device.get()` / `manager.get()` now raise `WujiException` for a nonexistent parameter path. Previously they silently returned `None`.
Fixed:
* C SDK: Calling an operation that a resource does not permit, such as reading a write-only resource or subscribing to a publish-only topic, now returns `WUJI_STATUS_ERR_UNSUPPORTED` instead of `WUJI_STATUS_ERR_INTERNAL`.
* Python and C SDKs: After a device disconnects or is taken over by another host, Python `recv()` and `recv_async()` now raise `WujiException` immediately, and C subscription callbacks terminate without delivering buffered frames. Previously, Python could return buffered frames or `None`, and C callbacks could deliver buffered frames before terminating.
**Devices**
**Wuji Hand 2**
Changed:
* Printing a `JointDiagnosticsEntry` now shows `error_code_current` in hexadecimal (`0x2103`) instead of decimal (`8451`), matching how error codes are written in the documentation. `error_code().get()` still returns an integer — format it as `f"0x{code:04X}"` if you print it directly.
* On device firmware v2.4.0 and later, fingertip per-point force arrives normalized to the sensor's full scale — normal axis 0 to 1, tangential axes -1 to 1, clamped beyond that. Firmware before v2.4.0 keeps reporting each point in newtons. The aggregate force and the temperature reading are in newtons and Celsius on both. Read `scale` and `unit` from `info.format` rather than assuming either convention, and re-fetch the info after a firmware upgrade so your decoder picks up the new scale.
**Wuji Glove**
Breaking changes:
* Removed the EMF pose rate divider—Python `glove.emf_poses_rate_divider()`, C `wuji_glove_get_emf_poses_rate_divider` / `wuji_glove_set_emf_poses_rate_divider`, and the matching examples. Upgrade the device firmware to v0.11.4 or later, then use `set_rate` on an `emf_poses` subscription. The setting resets when the last subscription closes or the device reconnects. Lowering `emf_poses` also lowers the EMF input rate used for hand tracking.
**Wuji Hand**
Fixed:
* Direct hand methods (`read_joint_state()`, `enable()`/`disable()`, `clear_all_faults()`, effort-limit and diagnostics accessors, opening a realtime controller) now fail with a disconnect error after `disconnect()` instead of continuing to operate the device. Python raises `WujiException`. C returns `WUJI_STATUS_ERR_DISCONNECTED`.
* Disconnecting now releases the USB device even when a joint-state subscription is still open. The same process can reconnect immediately without first closing the subscription or deleting the hand object.
**Submodules**
**Retargeting**
Changed:
* The live teleoperation examples (`examples/python/retargeting/1.teleop_real.py` and `examples/c/retargeting/1_teleop_real.c`) now list the SDK users at startup and let you pick which one to teleoperate under, instead of always switching to the default user. Press Enter to keep the user you are already on, pick the default user to run on the built-in hand URDF, or pick a named user to teleoperate on that user's calibrated hand model — a named user that has not been calibrated yet also runs on the built-in URDF. The previously selected user is still restored on exit.
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Firmware | v2.4.0 | Update via Wuji Studio |
| Wuji SDK | v2026.8.17 | `pip install --upgrade wuji-sdk` |
| Wuji Studio | v2026.8.17 | [Download](https://github.com/wuji-technology/wuji-studio/releases/tag/v2026.8.17) |
| Wuji Retargeting | v2026.8.17 | [Download](https://github.com/wuji-technology/wuji-retargeting/releases/tag/v2026.8.17) |
| Wuji Description | v2026.8.14 | [Download](https://github.com/wuji-technology/wuji-description/releases/tag/v2026.8.14) |
**Highlights**
**Firmware**
Added:
* Added adjustable push rate for subscribed data streams: the host can now ask the device to send a stream more slowly, saving bandwidth and downstream processing on the host. The device applies a rate it supports and reports back the rate in effect. Adjustable streams are the real-time joint stream, the five fingertip tactile streams, and the IMU stream. Rates reset to full speed when the last subscriber of a stream goes away, and when the host disconnects or reconnects. Requires Wuji SDK v2026.8.17 or later.
Changed:
* Changed fingertip per-point force reporting from absolute force readings to normalized values, so readings are directly comparable across fingers and sensor types without knowing each sensor's force range.
* Each sensing point reports its normal axis from 0 to 1 and its two tangential axes from -1 to 1, measured against a full-scale reference. Anything beyond full scale is clamped to the limit.
* The three-axis resultant force and the temperature reading are unchanged.
* The sensor metadata still describes the scale and the unit that apply to every reading, so applications that decode from the metadata pick up the new range automatically.
Fixed:
* Fixed fingertip force readings not responding below 2 N.
* Fixed fingertips not returning to a clean zero reading after contact is released.
* Improved reading consistency across the sensors on the thumb fingertip.
**Wuji SDK**
Added:
* Added `Subscription.set_rate(frequency_hz)` to lower a subscribed stream's device push rate at runtime, in samples per second. Upgrade the device to firmware that supports stream rate control before using this method (Wuji Glove v0.11.4 or later, Wuji Hand 2 v2.3.0 or later). Pass 0 to restore the device default. The call returns the rate the device applies, which may be quantized. Supported on `emf_poses`, `tactile`, `tactile_zones`, and `imu_raw/*` (Wuji Glove) and on `joint_states`, `joint_diagnostics`, `imu`, and `fingertip/*/data` (Wuji Hand 2). Derived streams—including `hand_joint_angles`, `hand_skeleton`, `tip_poses`, and `imu_data/*`—follow their source rate and reject `set_rate`. The setting affects every subscriber of the stream and resets to the device default when the last subscription to the stream is closed or the device reconnects. Examples: `examples/python/wuji_glove/6.set_stream_rate.py` and `examples/c/wuji_glove/1_set_stream_rate.c` for the Wuji Glove, and `examples/python/wuji_hand_2/4.set_stream_rate.py` and `examples/c/wuji_hand_2/4_set_stream_rate.c` for the Wuji Hand 2.
* C SDK: Added `wuji_sub_set_rate(sub, frequency_hz, out_actual_hz)` on any subscription handle, matching the Python `Subscription.set_rate` semantics. Streams that do not support rate control return `WUJI_STATUS_ERR_UNSUPPORTED (-8)` without sending a rate-control request to the device.
Changed:
* Printing a `JointDiagnosticsEntry` now shows `error_code_current` in hexadecimal (`0x2103`) instead of decimal (`8451`), matching how error codes are written in the documentation. `error_code().get()` still returns an integer — format it as `f"0x{code:04X}"` if you print it directly.
* On device firmware v2.4.0 and later, fingertip per-point force arrives normalized to the sensor's full scale — normal axis 0 to 1, tangential axes -1 to 1, clamped beyond that. Firmware before v2.4.0 keeps reporting each point in newtons. The aggregate force and the temperature reading are in newtons and Celsius on both. Read `scale` and `unit` from `info.format` rather than assuming either convention, and re-fetch the info after a firmware upgrade so your decoder picks up the new scale.
* `device.get()` / `manager.get()` now raise `WujiException` for a nonexistent parameter path. Previously they silently returned `None`.
Fixed:
* C SDK: Calling an operation that a resource does not permit, such as reading a write-only resource or subscribing to a publish-only topic, now returns `WUJI_STATUS_ERR_UNSUPPORTED` instead of `WUJI_STATUS_ERR_INTERNAL`.
* Python and C SDKs: After a device disconnects or is taken over by another host, Python `recv()` and `recv_async()` now raise `WujiException` immediately, and C subscription callbacks terminate without delivering buffered frames. Previously, Python could return buffered frames or `None`, and C callbacks could deliver buffered frames before terminating.
**Wuji Studio**
Fixed:
* Fixed device connection issues.
* Fixed an issue where incorrect firmware appeared in the firmware list during updates.
**Wuji Retargeting**
Changed:
* The live teleoperation examples (`examples/python/retargeting/1.teleop_real.py` and `examples/c/retargeting/1_teleop_real.c`) now list the SDK users at startup and let you pick which one to teleoperate under, instead of always switching to the default user. Press Enter to keep the user you are already on, pick the default user to run on the built-in hand URDF, or pick a named user to teleoperate on that user's calibrated hand model — a named user that has not been calibrated yet also runs on the built-in URDF. The previously selected user is still restored on exit.
* Updated the `wuji-description` hand model submodule to `v2026.8.3` and pointed the Wuji Hand 2 example configs (`adaptive_analytical_wuji_glove_wuji_hand_2_{left,right}.yaml`) at the new `hand2/hand2_beta1/body/` asset layout. Retuned `mediapipe_rotation` for the updated model orientation (left `x = 180`, right `y = 180`, both `z = -90`). No change to IK or simulation behavior.
**Wuji Description**
Added:
* Added the Wuji Hand 2 (Beta 2) delivery — Beta 1 plus one tactile-sensor pad link per fingertip, shipped for both hands as a no-mount robot model rooted at `{l,r}_wrist`.
* Tactile-sensor pads: each pad (`{p}_{finger}_tip_sensor_frame`) is fixed-welded onto the distal segment via `{p}_{finger}_tip_sensor_frame_fixed` and shown light blue against the silver body. Each pad carries its measured mass — 6.3 g for the thumb pad and 3.0 g for each of the other four fingertip pads — and the distal-segment masses were re-measured to match, dropping to 10.9 g for the thumb distal and 5.0 g for each other-finger distal.
* Coordinate contract: unchanged from Beta 1 and verified — the same 20 revolute joints with identical integer unit axes, and zero-position fingertip spacing matched left/right within 0.56 mm. The five fingertip query sites (`{l,r}_{finger}_tip`) carry over from Beta 1 unchanged and remain available as MJCF `` elements in display group 3.
* Formats: URDF (plus `package://wuji_hand2_beta2_description` ROS variants), MuJoCo MJCF, layered Isaac Sim USD, and anatomically named STL meshes (31 per hand), plus a with-mount full-hand STEP CAD assembly per hand (`hand2/hand2_beta2/body/step/wuji-hand2-description-{left,right}_beta2_with_mount_step.STEP`) for mechanical integration. These STEP files are byte-identical to the Beta 1 assemblies and don't yet include the fingertip tactile-sensor pads, so use them for envelope and mounting-interface work and take the models under `body/` as the reference for the pads.
* Added revision-aware model naming for the Wuji Hand 2 (Beta 2): robot/model names are `wujihand2-beta2-{side}` for the no-mount model and `wujihand2-beta2-{side}-mount` for the with-mount model, the USD entry point is `wujihand2_beta2.usd` with `wujihand2_beta2_{base,physics,robot,sensor}.usd` sublayers, and the USD root prim is `wujihand2_beta2_{side}` — no more name collisions with Beta 1 assets.
* Added the standalone ROS2 package `wuji_hand2_beta2_description` rooted at `hand2/hand2_beta2/body/` (`CMakeLists.txt` + `package.xml`), with the Beta 2 `{left,right}-ros.urdf` resolving meshes via `package://wuji_hand2_beta2_description/meshes/...`. The distinct package name (compared with Beta 1's `wuji_hand2_description`) lets both revisions coexist in one workspace, since their mesh sets differ.
* Added palm mounting-interface CAD and dimensioned drawings for the Wuji Hand 2, one pair of files per hand under `hand2/hand2_beta1/attachment/` and `hand2/hand2_beta2/attachment/`.
* STEP assembly (`wuji-hand2-description-{left,right}-mount_beta{1,2}_step.STEP`): the palm shell together with its wire harness, not the full hand.
* A3 drawing (`wuji-hand2-description-{left,right}-mount_beta{1,2}.pdf`): a single page dimensioning the threaded holes a custom arm-side adapter bolts into — one M3×0.5 fine-pitch 6H hole (thread depth > 5.5 mm, ⌀4 (0/+0.05) counterbore 2.35 ±0.03 deep) and two M4×0.5 fine-pitch 6H holes (thread depth > 4 mm, ⌀7 (0/+0.06) counterbore 1 mm deep), located by the 28.00 (0/−0.05) and 5.15 (+0.15/−0.05) reference dimensions.
* Scope: use these when machining a custom arm-flange adapter or fixture. The models under `body/` stay the reference for simulation.
* Files: the left and right files are mirror images of each other, and the Beta 1 and Beta 2 files are byte-identical because the palm mounting interface did not change between the two revisions. `attachment/` sits outside the ROS2 package root at `body/`, so `colcon` doesn't install it.
* Added the with-mount variant of the Wuji Hand 2 for both revisions, which adds the arm-flange mount link (`{l,r}_mount`, 69 g) as the model root with the wrist shell fixed-welded onto it via `{l,r}_wrist_fixed`.
* Which to load: the with-mount model bolts the hand onto an arm, and the no-mount model applies when the wrist is the attachment point. Joint names, axes, limits, and actuators are identical between the variants, so one installed package per revision serves both and either can be loaded at any time.
* Layout: both variants ship side by side inside each revision's `body/` directory, told apart by a `_with_mount` filename suffix — `urdf/{left,right}_with_mount.urdf`, `urdf/{left,right}_with_mount-ros.urdf`, `mjcf/{left,right}_with_mount.xml`, and `usd/{left,right}_with_mount/`.
* Beta 2 (`hand2/hand2_beta2/body/`): the ROS URDFs resolve via `package://wuji_hand2_beta2_description/meshes/...`, the same prefix the no-mount models use. The two variants share the 31 hand meshes in `meshes/{left,right}/` byte for byte, and the with-mount variant adds only `{l,r}_mount.STL`, bringing that directory to 32 meshes per hand.
* Beta 1 (`hand2/hand2_beta1/body/`): the ROS URDFs resolve via `package://wuji_hand2_description/meshes/...`, the same prefix the no-mount models use, and the USD entry filename stays `wujihand2.usd` — only the containing directory differs. In the MJCF the wrist shell (`{l,r}_wrist`) is its own body under `{l,r}_mount` rather than fused into it, so the wrist flange frame stays addressable. All 26 hand meshes in `meshes/{left,right}/` are shared byte for byte and the with-mount variant adds only `{l,r}_mount.STL`, bringing each directory to 27. The two variants stay kinematically equivalent: with the fixed mount offset taken out, fingertip poses agree to within 0.006 mm.
Changed:
* Changed the Wuji Hand 2 (Beta 1) right hand to a new mechanical CAD export. Kinematics and dynamics are unchanged, and the left hand is byte-identical to the previous release.
* Motion and mass: the same 20 revolute joints with identical integer unit axes, zero-position fingertip sites moving at most 0.0022 mm, body origins at most 0.0018 mm, and per-body and total mass identical to the digit (0.6207 kg for the no-mount model).
* Thumb frames: the no-mount export now models `r_thumb_middle` in the same frame as the with-mount export — `r_thumb_mcp` and `r_thumb_ip` both carry zero roll, where the previous export applied +6.3186° on the first and took it back off on the second. Both variants share `r_thumb_middle.STL` byte for byte, and `meshes/right/` stays symmetric with `meshes/left/`.
* Meshes: `r_thumb_middle.STL` is the only right-hand mesh this export changes. Every other mesh, including all distal and tip meshes, is byte-identical to the previous release, so MJCF collision geometry and rendering are untouched.
* Changed the Wuji Hand 2 (Beta 2) MJCF body tree so that each fingertip tactile-sensor pad is its own body (`{p}_{finger}_tip_sensor_frame`) instead of being fused into the distal segment.
* Why: MuJoCo's URDF compiler merges zero-DOF welded links by default, which left the pads with no body of their own — no place to attach a `force`/`torque` sensor, no body-level pose query, and a body list that disagreed with the URDF and USD.
* Masses: each pad now carries its own mass and inertia (thumb 6.3 g, other fingers 3.0 g) and the distal segments carry only theirs (thumb 10.9 g, others 5.0 g). The pads' collision geometry is unchanged and still participates in contact exactly as before.
* Sites: the empty `{p}_{finger}_tip` frame links stay merged and remain available as MJCF `` elements, which is the idiomatic MuJoCo form for a queryable frame.
* Kinematics and dynamics: unchanged — total mass, fingertip site poses, whole-hand center of mass, composite inertia, and contact counts all match the previous models to within floating-point noise. The same applies to the with-mount variant, where the wrist shell (`{l,r}_wrist`) is likewise its own body under `{l,r}_mount` rather than fused into it, so the wrist flange frame is addressable.
Important: This release contains a Wuji SDK breaking change — the EMF pose rate divider APIs are removed (Python and C). Use `set_rate` on an `emf_poses` subscription instead.
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Firmware | v0.11.4 | Update via Wuji Studio |
| Wuji SDK | v2026.8.17 | `pip install --upgrade wuji-sdk` |
**Highlights**
**Firmware**
Added:
* Added adjustable push rate for subscribed data streams: the host can now ask the device to send a stream more slowly, saving bandwidth and downstream processing on the host. The device applies a rate it supports and reports back the rate in effect. Adjustable streams are the tactile frame, the tactile zones, the EMF tracking stream, and the six IMU streams. Rates reset to full speed when the stream is no longer in use or the device reconnects. Requires Wuji SDK v2026.8.17 or later.
Fixed:
* Fixed Palm IMU frame sequence numbers skipping values on a healthy link. `FrameHeader.seq` now increases exactly by one for every published frame, so a gap in the sequence again means real frame loss. Previously the counter could report a 0.35% phantom frame loss.
**Wuji SDK**
Breaking changes:
* Removed the EMF pose rate divider—Python `glove.emf_poses_rate_divider()`, C `wuji_glove_get_emf_poses_rate_divider` / `wuji_glove_set_emf_poses_rate_divider`, and the matching examples. Upgrade the device firmware to v0.11.4 or later, then use `set_rate` on an `emf_poses` subscription. The setting resets when the last subscription closes or the device reconnects. Lowering `emf_poses` also lowers the EMF input rate used for hand tracking.
Added:
* Added `Subscription.set_rate(frequency_hz)` to lower a subscribed stream's device push rate at runtime, in samples per second. Upgrade the device to firmware that supports stream rate control before using this method (Wuji Glove v0.11.4 or later, Wuji Hand 2 v2.3.0 or later). Pass 0 to restore the device default. The call returns the rate the device applies, which may be quantized. Supported on `emf_poses`, `tactile`, `tactile_zones`, and `imu_raw/*` (Wuji Glove) and on `joint_states`, `joint_diagnostics`, `imu`, and `fingertip/*/data` (Wuji Hand 2). Derived streams—including `hand_joint_angles`, `hand_skeleton`, `tip_poses`, and `imu_data/*`—follow their source rate and reject `set_rate`. The setting affects every subscriber of the stream and resets to the device default when the last subscription to the stream is closed or the device reconnects. Examples: `examples/python/wuji_glove/6.set_stream_rate.py` and `examples/c/wuji_glove/1_set_stream_rate.c` for the Wuji Glove, and `examples/python/wuji_hand_2/4.set_stream_rate.py` and `examples/c/wuji_hand_2/4_set_stream_rate.c` for the Wuji Hand 2.
* C SDK: Added `wuji_sub_set_rate(sub, frequency_hz, out_actual_hz)` on any subscription handle, matching the Python `Subscription.set_rate` semantics. Streams that do not support rate control return `WUJI_STATUS_ERR_UNSUPPORTED (-8)` without sending a rate-control request to the device.
Changed:
* `device.get()` / `manager.get()` now raise `WujiException` for a nonexistent parameter path. Previously they silently returned `None`.
Fixed:
* C SDK: Calling an operation that a resource does not permit, such as reading a write-only resource or subscribing to a publish-only topic, now returns `WUJI_STATUS_ERR_UNSUPPORTED` instead of `WUJI_STATUS_ERR_INTERNAL`.
* Python and C SDKs: After a device disconnects or is taken over by another host, Python `recv()` and `recv_async()` now raise `WujiException` immediately, and C subscription callbacks terminate without delivering buffered frames. Previously, Python could return buffered frames or `None`, and C callbacks could deliver buffered frames before terminating.
Breaking: under `--json`, `wuji doctor` output is reorganized into `env` / `device` layers, replacing the flat `system` / `devices` layout. Scripts reading the old field names need migration.
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji CLI | v2026.8.17 | `wuji update` or the install script |
**Highlights**
Added:
* Host environment diagnostics: `wuji doctor` now checks host software versions, system info, and network interfaces before scanning for devices, and reports address-conflict issues found during the scan. BREAKING: under `--json`, the output is now organized by diagnosis layer — `env` (host environment checks) and `device` (device discovery listed as a generic entry without `sn`, plus per-device results) — replacing the old flat `system` / `devices` layout. Running with no device attached is now a normal exit (0 unless a host check fails) instead of an error.
* Wuji logs dump: new subcommand collecting device-side diagnostic snapshots for Wuji Hand 2 devices — scans all devices by default or targets one via `--sn`/`--address`/`--handedness`. It captures identity, fault/status, bus voltage and temperature, communication diagnostics, and Flash KV history as `__device.json` + `__flash.jsonl`. Field failures land in the snapshot's `failures` list without aborting. The exit code is non-zero if any device failed.
* Device snapshots in support bundles: `wuji logs export` now includes these device diagnostic snapshots and flash logs in the support bundle by default (under `devices/`), with no extra flag needed.
* Hand model calibration recordings in support bundles: `wuji logs export` now automatically includes hand model calibration runs from `~/.wuji/calibration/recordings/` that intersect the selected local-date range, including the manifest, the full recording, and the completed step recordings.
* Script-friendly JSON fields: Added `missing_model_files` to `wuji user show --json` and a `detail` field on skipped component rows (reason: `incomplete_model`, `not_in_bundle`, or `not_declared_in_manifest`).
Changed:
* Structured JSON errors: Under `--json` / `--jsonl`, most command errors now print structured JSON to stderr, keeping stdout clean for scripts.
* Colored error labels: Errors in human mode print a red `error:` label (rustc style), matching the existing `warning:` label.
Fixed:
* Unknown resource paths: `wuji get` with an unknown resource path now errors clearly instead of silently returning success without a value.
* Incomplete tactile models reported: `wuji user export`, `import`, `import --preview`, and `show` now list an incomplete tactile model (missing `contact.safetensors`, `contact.npz`, or `contact.json`) as skipped, naming the device SN and missing files, instead of dropping it silently. Exporting only a partial model no longer claims there is no calibration data — the error names the device and files and points to `wuji calib tactile`.
* `--json` always reports `current_user`: `wuji user create` / `switch` / `rename` / `delete` under `--json` now always report the resulting `current_user` (`rename` also reports `previous_name`), so scripts don't need a follow-up `user list`.
Important: This release contains a C SDK breaking change (joint diagnostics struct ABI change). C applications using these structs must be recompiled against the new header.
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji SDK | v2026.8.3 | `pip install --upgrade wuji-sdk` |
**Highlights**
**General**
Changed:
* C SDK: The Linux x86\_64 and aarch64 (gnu) tarballs now ship one library file, `libwuji_sdk_c.so`. Wuji Hand support no longer needs the `libwujihandcpp.so` that earlier tarballs bundled beside it, and `libstdc++.so.6` and `libusb-1.0.so.0` are no longer runtime dependencies. The C API and link line are unchanged, so existing applications keep working without a rebuild. If you deployed `libwujihandcpp.so` from an earlier tarball, you can delete it — the SDK doesn't load it anymore.
Fixed:
* Device scanning no longer hangs indefinitely in the rare case where a network peer disappears during discovery. The network discovery step is now time-bounded, so scanning always returns within a few seconds with the devices found so far. Covers both the Python SDK and the C SDK.
* Network device discovery now works on Linux hosts with multiple network interfaces or IP addresses when the host's primary IP address is not on the device's subnet — previously scanning on such hosts could permanently find no devices. Covers both the Python SDK and the C SDK.
**Device**
**Wuji Hand 2**
New capabilities:
* The `joint_diagnostics` stream now carries built-in communication health — each joint reports its bus response rate and timeout count, and every frame includes a summary with end-to-end (Ethernet) stream loss, request retry/timeout counters, and the fingertip tactile online bitmap. The SDK maintains all of it automatically in the background, so no polling is required.
Breaking changes (C SDK):
* The joint diagnostics structs gained new fields, so their C ABI changed. Applications that use `WujiJointDiagnosticsEntry` or `WujiJointDiagnosticsFrame` must be recompiled against the new header before linking the new library — linking new against old will read and write past the end of the old structs. Existing fields keep their meaning and order, and no source changes are needed. The added fields carry the per-joint bus communication quality and the frame-level communication summary described above.
Fixed:
* The SDK no longer binds a fixed local network port when connecting a hand. The local port is now assigned automatically by the operating system, so the SDK will not conflict with ports used by your own applications.
* Setting `effort_limit` to a value the device rejects (e.g. above the current ceiling) now raises a `ValueError` instead of a generic error. The device keeps its previous limit.
**Wuji Glove**
New capabilities:
* Added guided tactile calibration — record prompted hand motions to train a per-glove contact model for real-time contact detection (`tactile_binary`). Python: `glove.calibrate_tactile()` / `glove.calibrate_tactile_blocking()`. C: blocking guided flow with pose-prompt callbacks.
Models load automatically. Training requires a `model-export` build — see the [motion guide](/en/docs/wuji-studio/tactile-calibration).
* C SDK: Added `wuji_glove_set_tactile_binary_sensitivity` for standalone `tactile_binary` observation tools. It changes the SDK-local contact sensitivity for the connected glove and rejects non-finite or non-positive values.
* C SDK: Added the runnable user-management example `examples/c/wuji_glove/3_user_management.c` for inspecting the current SDK user, creating or updating named users, and switching users before calibration.
* Added `tactile_residual` observation examples — the continuous signed signal behind `tactile_binary`, where you set your own contact threshold instead of using a built-in one. Python: `glove.tactile_residual()`, C: `wuji_glove_subscribe_tactile_residual` typed callback. Calibrate the glove first.
Changed:
* The C hand model calibration example is now `examples/c/wuji_glove/4_user_calibration.c` (renamed from `3_user_calibration.c`) and calibrates the SDK user you are already on instead of creating or switching one — use the new `3_user_management.c` example first if you need to create or switch users. It also gained a `--blocking` mode, which runs calibration to completion without the cooperative Ctrl+C cancellation the default asynchronous path offers.
Fixed:
* EMF finger poses now use the selected hand URDF to reject unreachable mirrored positions, reducing incorrect position reversals caused by transient interference.
**Wuji Hand**
Changed:
* `RealtimeController` can now be shared across Python threads — for example a writer thread streaming targets while a reader thread polls actual positions — without any locking. Previously, touching the controller from a second thread raised an error.
Fixed:
* Physically unplugging the tactile glove at runtime is now detected. `is_tactile_attached()` returns `false`, the tactile status stream reports `NotPresent` (state 0) typically within 200 ms, and other tactile reads return a clear "tactile not present" error — previously they all kept reporting a healthy, attached glove indefinitely and only the frame age hinted at the loss. The hand itself is unaffected and keeps working. Re-attaching the glove still requires reconnecting the hand. Applies to both the Python SDK and the C SDK (`wuji_hand_is_tactile_attached`).
* C SDK: Wuji Hand tactile-glove calls no longer crash the process when the glove is missing or faulty — they return an error status instead (details via `wuji_last_error()`).
* Connecting to a hand that isn't ready no longer crashes your application — it now fails with a catchable error that names any joint that didn't respond. Covers both the Python SDK and the C SDK.
Important: This release contains a C SDK breaking change (joint diagnostics struct ABI change). C applications using these structs must be recompiled against the new header.
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Firmware | v2.2.3 | Update via Wuji Studio |
| Wuji SDK | v2026.8.3 | `pip install --upgrade wuji-sdk` |
| Wuji Studio | v2026.8.3 | [Click to download](https://github.com/wuji-technology/wuji-studio/releases/tag/v2026.8.3) |
| Wuji Retargeting | v2026.8.3 | [Click to download](https://github.com/wuji-technology/wuji-retargeting/releases/tag/v2026.8.3) |
**Highlights**
**Firmware**
New capabilities:
* Added a status light on the hand's back logo that shows the device state at a glance — powering up, ready, running, updating firmware, and warning or fault conditions. See the [status light guide](/en/docs/wuji-hand/latest/product-introduction#back-of-hand-status-light)
* Added warning code `0x0015`: abnormal motor parameters
Fixed:
* Fixed some known issues
**Wuji SDK**
New capabilities:
* The `joint_diagnostics` stream now carries built-in communication health — each joint reports its bus response rate and timeout count, and every frame includes a summary with end-to-end (Ethernet) stream loss, request retry/timeout counters, and the fingertip tactile online bitmap. The SDK maintains all of it automatically in the background, so no polling is required.
Breaking changes (C SDK):
* The joint diagnostics structs gained new fields, so their C ABI changed. Applications that use `WujiJointDiagnosticsEntry` or `WujiJointDiagnosticsFrame` must be recompiled against the new header before linking the new library — linking new against old will read and write past the end of the old structs. Existing fields keep their meaning and order, and no source changes are needed. The added fields carry the per-joint bus communication quality and the frame-level communication summary described above.
Changed:
* C SDK: The Linux x86\_64 and aarch64 (gnu) tarballs now ship one library file, `libwuji_sdk_c.so`. Wuji Hand support no longer needs the `libwujihandcpp.so` that earlier tarballs bundled beside it, and `libstdc++.so.6` and `libusb-1.0.so.0` are no longer runtime dependencies. The C API and link line are unchanged, so existing applications keep working without a rebuild. If you deployed `libwujihandcpp.so` from an earlier tarball, you can delete it — the SDK doesn't load it anymore.
Fixed:
* The SDK no longer binds a fixed local network port when connecting a hand. The local port is now assigned automatically by the operating system, so the SDK will not conflict with ports used by your own applications.
* Device scanning no longer hangs indefinitely in the rare case where a network peer disappears during discovery. The network discovery step is now time-bounded, so scanning always returns within a few seconds with the devices found so far. Covers both the Python SDK and the C SDK.
* Network device discovery now works on Linux hosts with multiple network interfaces or IP addresses when the host's primary IP address is not on the device's subnet — previously scanning on such hosts could permanently find no devices. Covers both the Python SDK and the C SDK.
* Setting `effort_limit` to a value the device rejects (e.g. above the current ceiling) now raises a `ValueError` instead of a generic error. The device keeps its previous limit.
**Wuji Studio**
Fixed:
* **Firmware upgrade**: Fixed successful upgrades occasionally being reported as failed.
* **Device connection**: Connecting a Wuji Hand 2 no longer falsely reports "read-only mode".
**Wuji Retargeting**
Changed:
* Retuned the `mediapipe_rotation` bias in the Wuji Glove example configs (`adaptive_analytical_wuji_glove_{left,right}.yaml` and `adaptive_analytical_wuji_glove_wuji_hand_2_{left,right}.yaml`) for the new per-serial calibration. The manual `wrist_offset_cm` / `thumb_offset_cm` stay disabled because the SDK applies a per-serial calibrated URDF.
Fixed:
* Fixed `teleop_real.py` crashing at startup with `AttributeError` on the Wuji Hand 2 (network) backend after the Wuji SDK 2026.7.1 resource-API redesign. Control behavior is unchanged. Requires Wuji SDK ≥ 2026.7.1 and matching firmware.
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji SDK | v2026.8.3 | `pip install --upgrade wuji-sdk` |
| Wuji Description | v2026.8.3 | [Click to download](https://github.com/wuji-technology/wuji-description/releases/tag/v2026.8.3) |
**Highlights**
**Wuji SDK**
New capabilities:
* Added guided tactile calibration — record prompted hand motions to train a per-glove contact model for real-time contact detection (`tactile_binary`). Python: `glove.calibrate_tactile()` / `glove.calibrate_tactile_blocking()`. C: blocking guided flow with pose-prompt callbacks.
Models load automatically. Training requires a `model-export` build — see the [motion guide](/en/docs/wuji-studio/tactile-calibration).
* C SDK: Added `wuji_glove_set_tactile_binary_sensitivity` for standalone `tactile_binary` observation tools. It changes the SDK-local contact sensitivity for the connected glove and rejects non-finite or non-positive values.
* C SDK: Added the runnable user-management example `examples/c/wuji_glove/3_user_management.c` for inspecting the current SDK user, creating or updating named users, and switching users before calibration.
* Added `tactile_residual` observation examples — the continuous signed signal behind `tactile_binary`, where you set your own contact threshold instead of using a built-in one. Python: `glove.tactile_residual()`, C: `wuji_glove_subscribe_tactile_residual` typed callback. Calibrate the glove first.
Changed:
* The C hand model calibration example is now `examples/c/wuji_glove/4_user_calibration.c` (renamed from `3_user_calibration.c`) and calibrates the SDK user you are already on instead of creating or switching one — use the new `3_user_management.c` example first if you need to create or switch users. It also gained a `--blocking` mode, which runs calibration to completion without the cooperative Ctrl+C cancellation the default asynchronous path offers.
Fixed:
* EMF finger poses now use the selected hand URDF to reject unreachable mirrored positions, reducing incorrect position reversals caused by transient interference.
* Device scanning no longer hangs indefinitely in the rare case where a network peer disappears during discovery. The network discovery step is now time-bounded, so scanning always returns within a few seconds with the devices found so far. Covers both the Python SDK and the C SDK.
* Network device discovery now works on Linux hosts with multiple network interfaces or IP addresses when the host's primary IP address is not on the device's subnet — previously scanning on such hosts could permanently find no devices. Covers both the Python SDK and the C SDK.
**Wuji Description**
* Added `glove/attachment/Pico-controller-attachment.STEP`, a STEP AP214 CAD assembly for mounting a PICO 4 Ultra controller on the Wuji Glove. It joins the existing Wuji Glove mounting interface and PICO tracker adapter in the same directory.
Important: Device type display names are now lowercase snake\_case (`wuji upgrade --type` values change accordingly). Update scripts that string-match the old output.
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji CLI | v2026.8.3 | `wuji update` or the install script |
**Highlights**
New capabilities:
* **Wuji Hand 2 support**: `wuji upgrade` supports firmware upgrades on Wuji Hand 2 with tactile sensors.
* **Tactile calibration**: `wuji calib tactile` collects, trains, verifies, and installs a contact model for Wuji Glove, with a `--non-interactive` mode for hands-off runs.
* **Hand model calibration**: `wuji calib hand-model` (shipped as `wuji calib ik`, since renamed) guides device selection, live pose, and reference images, then saves and hot-reloads the completed model for the active profile. It builds a hand model that matches your physical hand, so pinches, four-finger bends, and other gestures produce expected output on your Wuji Glove.
* **User profiles**: `wuji user` manages calibration profiles for Wuji Glove, creating, describing, switching, listing, showing, renaming, and deleting profiles, and importing or exporting their IK and tactile calibration data. Results are stored per profile and per hand, so gloves on the same hand share one result under the same profile.
* **Logging**: `wuji logs` provides a command group (`path`, `list`, `export`) for log directory discovery, file listing, and support-bundle export. It collects host-side logs (from the SDK, Studio, and similar tools) into a bundle you can send with your device SN to [support@wuji.tech](mailto:support@wuji.tech).
* **Agent skills**: new agent skills were added to cover each of the commands above — profile management, calibration, and logs.
Breaking changes:
* Unified device type display names to lowercase snake\_case. `wuji upgrade --type` now requires snake\_case values (e.g. `wuji_glove` instead of `"Wuji Glove"`). Affects `ping`'s Device Type column, `doctor` report headers, `upgrade --check` output, help examples, and all documentation.
## July 2026
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji Description | v2026.7.23 | [Download](https://github.com/wuji-technology/wuji-description/releases/tag/v2026.7.23) |
**Highlights**
**Wuji Description**
* Added the Wuji Hand 2 (Beta 1) delivery, the first revision recalibrated under the new coordinate-system rules, with the coordinate conventions fixed from this revision on—integer unit joint axes, anatomical link/joint naming (for example `r_thumb_cmc_flex`), the `{l,r}_wrist` root link, and the actuator naming scheme (`{l,r}_{THJ|FFJ|MFJ|RFJ|LFJ}{0-3}`, J0 = flexion … J3 = DIP)—later revisions stay compatible and only update physical parameters and geometry details, and each hand has 20 actuated revolute joints (5 fingers × 4 joints).
* Added Wuji Hand 2 (Beta 1) left- and right-hand models: URDF with relative mesh paths plus a ROS variant using `package://wuji_hand2_description` paths, MuJoCo MJCF with collision geometry as the convex hull of each link mesh, layered Isaac Sim USD assets whose drive gains hold the pose on bare Play, and anatomically named STL meshes—the kp/kv drive gains are carried over from the Wuji Hand platform calibration and will be updated once system identification on Wuji Hand 2 hardware is complete.
* Added five fingertip query sites per hand (`{l,r}_{finger}_tip`, display group 3) for grasp-point queries and fingertip trajectory evaluation.
* Added full-hand STEP CAD assemblies (left and right) for mechanical integration and fixture design.
* Added the standalone ROS2 package `wuji_hand2_description`, so the Wuji Hand 2 (Beta 1) ROS URDFs resolve their meshes independently of the Wuji Hand `wuji_description` package.
* Changed the Wuji Hand 2 (Beta 1) collision policy: every link now participates in collision with only 10 assembly-overlap pairs excluded (each finger's proximal and proximal\_abd against the wrist), inter-finger and fingertip–palm contacts stay live, display layers are group 1 visual (silver), group 2 collision (translucent light purple), and group 3 fingertip sites, and the fingertip soft pads ship with the package but are not yet attached as collision geometry—fingertip contact is carried by the distal-segment geometry, so the contact point sits slightly off the real finger pad.
* Removed the previous Wuji Hand 2 (Beta) model revision rooted at `{l,r}_base_link`, along with its structural STEP assemblies and arm-flange adapter mount—it is superseded by the recalibrated Wuji Hand 2 (Beta 1) revision.
Important: The retargeting interface moved to the package top level (breaking change, Python) — the `wuji_sdk.retargeting` submodule is removed. Update caller imports to the new form.
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji SDK | v2026.7.21 | `pip install --upgrade wuji-sdk` |
**Highlights**
**Device**
**Wuji Hand 2**
New capabilities:
* First official release of fingertip tactile sensing: subscribe to self-describing per-finger sensor streams (`FingertipSensorInfo` metadata describes how to decode each `FingertipSensorData` frame — see the `3.fingertip_typed.py` example), recalibrate all five fingertips to a fresh zero baseline with `hand.tactile_calibrate()` (Python) / `wuji_hand_2_tactile_calibrate(dev)` (C) while keeping the sensor surfaces unloaded, and query each sensor's model and calibration state with `hand.tactile_status(finger)` to confirm a recalibration has finished
Fixed:
* Firmware upgrade failures now report the detailed error (specific reason, error code, and any failed nodes) instead of a generic "Unknown error"
**Submodules**
**Retargeting**
New capabilities:
* Added the hand retargeting API (`wuji_retarget_session_create` / `_step` / `_reset` / `_free`) that maps 21 hand keypoints (MediaPipe order) to 20 joint angles in firmware order, matching the Python `RetargetSession`, with degenerate or invalid keypoint frames returning the new `WUJI_STATUS_ERR_ALGORITHM` status and details from `wuji_last_error()`
Breaking changes (Python):
* `RetargetSession` and `HandModel` now live at the package top level and the `wuji_sdk.retargeting` submodule is removed (breaking change, Python) — update imports to `from wuji_sdk import RetargetSession, HandModel`
Changed:
* `RetargetSession` now works out of the box without the `[retarget]` extra and with lower per-step latency — `numpy` is still used for keypoint/qpos arrays
* Refined retargeting output with improved thumb articulation — joint angles for identical inputs may differ from previous releases
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Firmware | v2.1.0 | Update via Wuji Studio |
| Wuji SDK | v2026.7.21 | `pip install --upgrade wuji-sdk` |
**Highlights**
**Firmware**
New capabilities:
* Per-finger tactile data streams with the frame layout defined by self-describing sensor metadata — the host fetches the metadata first, then decodes the stream against it
* Query tactile sensor status (model and calibration status)
* Recalibrate the fingertip tactile sensors at runtime, resetting all five fingertips to a fresh zero baseline (triggered through the SDK's `tactile_calibrate`)
Changed:
* An enabled joint that loses communication with the main controller now stops the motor and reports a fault instead of continuing on the last received command, and re-enabling requires an explicit host command
* Improved encoder health monitoring: high-speed operation no longer triggers spurious encoder warnings, and genuine encoder link degradation is detected earlier and more reliably
Fixed:
* Fixed real-time stream timestamps gradually drifting from host time and failing to realign after reconnecting the SDK while the device stays powered on
**Wuji SDK**
New capabilities:
* First official release of fingertip tactile sensing: subscribe to self-describing per-finger sensor streams (`FingertipSensorInfo` metadata describes how to decode each `FingertipSensorData` frame — see the `3.fingertip_typed.py` example), recalibrate all five fingertips to a fresh zero baseline with `hand.tactile_calibrate()` (Python) / `wuji_hand_2_tactile_calibrate(dev)` (C) while keeping the sensor surfaces unloaded, and query each sensor's model and calibration state with `hand.tactile_status(finger)` to confirm a recalibration has finished
Fixed:
* Firmware upgrade failures now report the detailed error (specific reason, error code, and any failed nodes) instead of a generic "Unknown error"
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji CLI | v2026.7.15 | `wuji update` or the install script |
**Highlights**
* Fixed the install script exiting before it installed the agent skills
Important: The Wuji Hand Python interface is aligned with the Wuji Hand 2 resource-style API (breaking change), and Wuji Glove hand calibration now belongs to the SDK user and hand side. Upgrade the SDK and update caller code to the new interface. Wuji Glove users should recalibrate.
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji SDK | v2026.7.14 | `pip install --upgrade wuji-sdk` |
**Highlights**
**General**
New capabilities:
* Export, preview, and import your Wuji user data as a portable `.zip` bundle. `SdkManager.export_user_data(user_id, out_path)` writes everything a user owns — calibration hand models plus the tactile model and its latest complete calibration run — into one file. `preview_user_data(zip_path)` validates a bundle and reports its contents without importing it. `import_user_data(zip_path)` restores a bundle to the user who created it (creating that user if it doesn't exist) and overwrites that user's existing data, without changing the current user
* `scan()` now reports each device's type: `DiscoveredDevice.device_type` is a `DeviceType` enum (`WujiGlove` / `WujiHand2` / `WujiHand`), so you can tell what a device is before connecting. `Unknown` means the type was not available at scan time
* C SDK: scan results now carry the device type. `WujiDiscovered.device_id` is a `WujiDeviceType` enum (`WUJI_DEVICE_TYPE_WUJI_GLOVE` / `_WUJI_HAND_2` / `_WUJI_HAND` / `_UNKNOWN`) and `model` carries the readable type string, so you can tell what a device is before connecting
* C SDK: added SDK user management and Wuji Glove hand model calibration APIs matching the Python SDK. C applications can create and switch SDK users, run calibration with structured feedback, cancel asynchronous calibration sessions, and receive the per-user calibrated URDF path. The calibration example provides the same in-place terminal dashboard and throttled API log mode as the Python example
* C SDK: added user data import/export and preview, mirroring the Python API. `wuji_user_data_export` / `wuji_user_data_import` move a user's data as a portable `.zip` bundle, and `wuji_user_data_preview` validates and lists a bundle's contents without writing to disk. All three return a `WujiStatus` — call `wuji_last_error()` for the message on failure. `WUJI_STATUS_ERR_NOT_FOUND` means the bundle file doesn't exist, and `WUJI_STATUS_ERR_INVALID_DATA` means the bundle is present but fails validation (corrupt zip, bad manifest, checksum mismatch, or unsafe path)
Breaking changes (C SDK):
* `WujiConnectOptions` changed layout to match Python `ConnectOptions` for bridge and background time-sync settings. Rebuild C applications against the updated `wuji_sdk.h`. Use `wuji_connect_options_default()` before overriding fields when passing non-NULL options to `wuji_connect`, or pass `opts_or_null = NULL` to keep default connection behavior
* Removed the unused `wuji_glove_subscribe_tactile_zones_cache()`
Fixed:
* Fixed an issue where connecting multiple devices in the same process (for example a Wuji Glove and a Wuji Hand 2) could fail depending on the connection order
* Fixed a crash on exit. If a device disconnected while a callback subscription was still running and the process then exited, the app could crash with a fatal Python error or segmentation fault. Background subscription threads now stop cleanly before the interpreter shuts down
**Device**
**Wuji Hand**
New capabilities:
* The Wuji SDK real-time controller now exposes `get_actual_effort()` (per-joint effort in amps, read from the same non-blocking upstream cache as `get_actual_position()`) in the Python SDK, and the C SDK exposes the matching `wuji_hand_realtime_controller_get_actual_effort`. This API belongs to wuji-sdk, not wujihandcpp
* Added Wuji Hand support to the C SDK. Connect by USB serial number (`wuji_hand_connect_sn`), then read joint positions, per-joint diagnostics (bus voltage / temperature / error code), firmware soft limits, handedness, and whether a tactile glove is attached. Control with `enable` / `disable` / `clear_all_faults`, set and read the effort limit, stream commands through a joint-command publisher (a list of 20 `JointCommand` structs — `position` / `velocity` / `effort` per joint, the same shape as Wuji Hand 2, so command code is portable between the two), and run a low-pass-filtered real-time position controller. Subscription streams for joint state and tactile pressure are also available. Supported on **Linux x86\_64 / aarch64 (gnu) only**. On Android these functions are present but return `WUJI_STATUS_ERR_UNSUPPORTED`. Worked examples are under `examples/c/wuji_hand/`
Breaking changes (Python):
* The joint-command publisher now takes an array of structs. `JointCommandPublisher.send(...)` changed from three parallel lists `send(positions, velocities, efforts)` to a single list of per-joint commands `send(joints)`, where each entry is a `JointCommand(position, velocity, effort)` — pass exactly 20. The old `publish(...)` alias was removed. This matches Wuji Hand 2 exactly
* The joint-command publisher is now opened via `hand.joint_command().publish()`. The resource accessor was renamed from `.publisher()` to `.publish()`, and the shortcut method `hand.joint_command_publisher()` was removed. The returned `JointCommandPublisher` (`send(...)` / `close()`) is unchanged
* Tactile-glove classes now carry a `TactileGlove` prefix so they cannot be confused with the Wuji Glove's generic tactile streams: `TactileStatus` → `TactileGloveStatus`, `TactileDiagnostics` → `TactileGloveDiagnostics`, `TactileDeviceInfo` → `TactileGloveDeviceInfo`, and the sub-module handle `WujiTactile` → `WujiTactileGlove`. Accessors and wire formats are unchanged — update type references and `isinstance` checks to the new class names
* The joint-state stream is now `hand.joint_states()` (was `hand.joint_state()`), and the frame class is `HandJointStates` (was `HandJointState`), matching Wuji Hand 2 and the ROS `/joint_states` convention
**Wuji Hand 2**
* `disconnect()` now fully releases the hand — after disconnecting, the hand is immediately available to any other application or machine, exactly as if your application had exited. Previously the hand could remain held by the application until it exited
* Fixed a bug where applications that repeatedly connect and disconnect could see each new connection take longer than the last. Connections now stay consistently fast, no matter how long the application has been running
**Wuji Glove**
Breaking changes:
* Hand calibration now belongs to the SDK user and hand side instead of an individual glove. Swapping to another glove of the same side no longer requires recalibration. Calibration recorded by older SDK versions is not loaded anymore — recalibrate under your user profile
* The `hand_profile` calibration option is deprecated and ignored (passing it emits a `DeprecationWarning`). The calibration result was simplified to `handedness` plus a single `calibrated_urdf` path. The `calibration.hand_profile` and `calibration.hand_model_paths.*` parameters were removed: setting them now fails, and values left by older versions are ignored
* The tactile contact model is now located automatically from the current SDK user and device serial number, the same convention as the calibrated hand model, and stored under the SDK's own tactile directory. The `algorithms.tactile_binary.model_dir` parameter was removed: setting it now fails, and values left by older versions are ignored. Integrations that set this parameter should stop setting it, as the model is resolved automatically once you select the SDK user
* Calibration bundles use a new format with user-level hand models and per-glove tactile data. Importing bundles from older SDK versions keeps the tactile data but skips the old hand calibration (it is no longer loaded — recalibrate under your user profile). Bundles exported by this version require an up-to-date SDK to import
Fixed:
* The Default profile uses Wuji's built-in URDF, and calibration recorded earlier does not apply. To calibrate, create and switch to your own user profile first
**Submodules**
**Retargeting**
* Optimized wheel packaging — download and installed size are significantly smaller. No functional change
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Firmware | v2.0.0 | Update via Wuji Studio |
| Wuji SDK | v2026.7.14 | `pip install --upgrade wuji-sdk` |
| Wuji Studio | v2026.7.14 | [Click to download](https://github.com/wuji-technology/wuji-studio/releases/tag/v2026.7.14) |
| Wuji Description | v2026.7.14 | [Click to download](https://github.com/wuji-technology/wuji-description/releases/tag/v2026.7.14) |
**Highlights**
**Firmware**
Breaking changes:
* This firmware targets Beta 2 hardware. Beta 1 hardware will not receive this update — the firmware list only offers packages that match your device hardware
Fixed:
* Fixed other known issues and improved overall stability
**Wuji SDK**
* `disconnect()` now fully releases the hand: after disconnecting, the hand is immediately available to any other application or machine, exactly as if your application had exited. Previously the hand could remain held by the application until it exited
* Fixed a bug where applications that repeatedly connect and disconnect could see each new connection take longer than the last. Connections now stay consistently fast, no matter how long the application has been running
**Wuji Studio**
* Devices in the firmware upgrade view are now grouped by their actual product type, so Wuji Hand devices no longer appear under the "Wuji Glove" group. Unrecognized devices are listed under a new "Other Devices" group
**Wuji Description**
* Fixed the ROS `package://` mesh paths for the Wuji Hand 2 (Beta 1) URDF: the `wuji_description` package now installs the model assets into its share directory, and mesh paths are model-scoped, so the model loads correctly under ROS
Important: Wuji Glove hand calibration now belongs to the SDK user and hand side (breaking change). Upgrade the firmware and the SDK together, then calibrate the left and right hands again under your user profile.
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Firmware | v0.11.2 | Update via Wuji Studio |
| Wuji SDK | v2026.7.14 | `pip install --upgrade wuji-sdk` |
| Wuji Studio | v2026.7.14 | [Click to download](https://github.com/wuji-technology/wuji-studio/releases/tag/v2026.7.14) |
| Wuji Description | v2026.7.14 | [Click to download](https://github.com/wuji-technology/wuji-description/releases/tag/v2026.7.14) |
**Highlights**
**Firmware**
* Aligned the tactile point cloud to 526 active taxels. The firmware still scans the raw 24×32 sensor array and drops the dead column, publishing 24×31 (744-value) tactile frames, and the point-cloud active mask excludes eight more hardware-masked taxels on top of that. Update the Wuji SDK to a matching version so point-cloud decoding uses the same 526-taxel mapping
**Wuji SDK**
Breaking changes:
* Calibration results (the URDF hand model) now belong to the SDK user and hand side instead of an individual glove, so swapping to another glove of the same side no longer requires recalibration. Calibration recorded by older SDK versions is not loaded anymore — recalibrate under your user profile
* The `hand_profile` calibration option is deprecated and ignored (passing it emits a `DeprecationWarning`). The calibration result was simplified to `handedness` plus a single `calibrated_urdf` path, and the `calibration.hand_profile` and `calibration.hand_model_paths.*` parameters were removed: setting them now fails, and values left by older versions are ignored
* The tactile contact model is now located automatically from the current SDK user and device serial number, the same convention as the calibrated hand model, and stored under the SDK's own tactile directory. The `algorithms.tactile_binary.model_dir` parameter was removed: setting it now fails. Integrations that set this parameter should stop setting it, as the model is resolved automatically once you select the SDK user
* Calibration bundles use a new format with user-level hand models and per-glove tactile data. Importing bundles from older SDK versions keeps the tactile data but skips the hand calibration inside (recalibrate), and bundles exported by this version require an up-to-date SDK to import
New capabilities (C SDK):
* Added SDK user management and Wuji Glove hand model calibration APIs matching the Python SDK: C applications can create and switch SDK users, run calibration with structured feedback, cancel asynchronous calibration sessions, and receive the per-user calibrated URDF path. The calibration example provides the same in-place terminal dashboard and throttled API log mode as the Python example
* Added user data import/export and preview, mirroring the Python API: `wuji_user_data_export` / `wuji_user_data_import` move a user's data as a portable `.zip` bundle, and `wuji_user_data_preview` validates and lists a bundle's contents without writing to disk. All three return a `WujiStatus` — call `wuji_last_error()` for the message on failure. `WUJI_STATUS_ERR_NOT_FOUND` means the bundle file doesn't exist, and `WUJI_STATUS_ERR_INVALID_DATA` means the bundle is present but fails validation (corrupt zip, bad manifest, checksum mismatch, or unsafe path)
* Added device type at scan time: `WujiDiscovered.device_id` is now a `WujiDeviceType` enum (`WUJI_DEVICE_TYPE_WUJI_GLOVE` / `_WUJI_HAND_2` / `_WUJI_HAND` / `_UNKNOWN`) and `WujiDiscovered.model` carries the readable type string, so you can tell what a device is before connecting
Breaking changes (C SDK):
* `WujiConnectOptions` changed layout to match Python `ConnectOptions` for bridge and background time-sync settings. Rebuild C applications against the updated `wuji_sdk.h`, and call `wuji_connect_options_default()` before overriding fields when passing non-NULL options, or pass `opts_or_null = NULL` to keep default connection behavior
* Removed the unused API `wuji_glove_subscribe_tactile_zones_cache()`
Fixed:
* The Default profile uses Wuji's built-in URDF, and calibration recorded earlier does not apply. To calibrate, create and switch to your own user profile first
**Wuji Studio**
Breaking changes:
* The calibration file format changed. Calibration files created before this release are incompatible with the new format and are not migrated, so calibrate the left and right hands again after upgrading
New capabilities:
* User data import and export: export your calibration hand models, tactile models, and captured runs to a portable `.zip` from the user avatar menu, and import one back. Import previews the archive, shows its owner, and warns that it overwrites matching data before you confirm. Data is restored to the archive's owner profile, which is created if it doesn't exist, and you can switch to that profile afterward. Desktop app only
Changed:
* Calibration results are now saved per Wuji Studio user and hand, and Wuji Gloves for the same hand share that user's result
* **Hand Profile** is renamed to **Hand Model Source**, and the legacy Wuji Hand 2 and Wuji Hand profiles are deprecated. Existing layouts now show **SDK Managed**, which uses the matching calibrated model, or the SDK default model when not calibrated, and **Custom URDF** remains available
Fixed:
* Fixed cases where a compatible Wuji Glove could appear unsupported or show the wrong calibration status. When the status cannot be checked, Studio now offers a retry
* Studio now blocks incompatible legacy tactile recordings during playback and shows a clear warning, avoiding incorrect tactile rendering
* Playing back tactile recordings in the older format (before v2026.6.18) shows an incompatibility warning as a message notification in the bottom-right corner
* Fixed tactile matrix panels still rendering the old 24×32 preset layout after an in-place upgrade. The layout now migrates on startup, and custom column counts are preserved
**Wuji Description**
* Added Wuji Glove mounting attachments: `Wuji-glove-attachment.STEP` (the Wuji Glove mounting interface) and `Pico-tracker-attachment.STEP` (a Pico tracker adapter), both STEP AP214 assemblies for mechanical integration
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji CLI | v2026.7.14 | `wuji update` or the install script |
**Highlights**
First release of Wuji CLI: the official command-line tool for Wuji devices — connect devices, upgrade firmware in batches, and automate with scripts, all without a GUI, plus one-command diagnostics with `wuji doctor`.
* Device management: scan and list devices over USB / UDP with `wuji devices`, and probe device connectivity with `wuji ping`, covering all discovered devices by default or targeting one by SN, IP, or handedness
* Parameter read/write: `wuji get` and `wuji set` read and write device parameters with typed JSON output
* Resource discovery: list a device's readable/writable parameters and subscribable topics with `wuji resources`
* Data subscription: subscribe to a topic's real-time data with `wuji sub `, and control the frame count with `--count`
* Health diagnostics: `wuji doctor` checks device health, including EMF disconnection detection and tactile dead-pixel / bad-column detection. Wuji Glove only for now, with more diagnostics and device types to come
* Firmware upgrade: upgrade device firmware from the official catalog with `wuji upgrade`. Check which devices have updates with `--check`, upgrade one or all devices, install a specific version with `--to`, flash a local package with `--file`, and browse available versions with `--list`. Downloads are sha256-verified and cached, flashing asks for confirmation (skip with `--yes`), and a per-device report is printed
* Self-update: `wuji update` downloads, verifies, and installs the latest release in place (`--check` to check only)
* Shell completions: generate completion scripts for bash, zsh, fish, powershell, and elvish with `wuji completions`
* Output formatting: most commands support `--json` / `--jsonl` output modes and device selection by `--sn`, `--address`, or `--handedness`
* Colored output: consistent semantic colors for statuses, warnings, and values, with `NO_COLOR` support and a plain-text fallback on non-TTY output
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji SDK | v2026.7.2 | `pip install --upgrade wuji-sdk` |
**Key Updates**
**Device**
**Wuji Hand**
* Fixed reconnecting within the same process: after `disconnect()`, calling `connect()` again for the same hand failed and previously required exiting the process to recover. The handle is no longer usable after `disconnect()`. Create a new connection to reconnect
**Submodules**
**Retargeting**
* Fixed the live teleoperation example (`examples/python/retargeting/1.teleop_real.py`) that failed to run: `manager.connect()` defaults to `enable_bridge=True` (Zenoh Bridge enabled), so the glove → retarget → hand loop did not work when the example used the default connection options. The example now connects with `ConnectOptions(enable_bridge=False)`, bypassing the Bridge for a direct connection
Important: The Wuji Hand 2 interface is redesigned into a unified resource-style API (breaking change). Upgrade the device firmware and SDK together, and update caller code to the new interface.
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji SDK | v2026.7.1 | `pip install --upgrade wuji-sdk` |
**Key Updates**
**C SDK**
* Added Wuji Hand 2 support, mirroring the Python resource-style API: `joint_states` / `joint_diagnostics` subscription streams, `mit_params` / `effort_limit` configuration, control actions (enable / disable / clear\_fault / emergency\_stop / user origin), and a joint-command publisher. Whole-hand reads cover 20 joints with a per-joint online bitmap so offline joints are distinguishable, and string getters use a two-call size query (pass a `NULL` buffer to get the required length, then call again to fill it)
* New `wuji_glove_get_emf_poses_rate_divider` / `wuji_glove_set_emf_poses_rate_divider` lower the Wuji Glove EMF output rate (divider N ≥ 1, output rate = input rate / N, for example N=4 → 30 Hz). Every derived stream (hand\_joint\_angles / tip\_poses / hand\_skeleton / tactile\_point\_cloud) drops to the same rate, reducing IK CPU load. Applied at runtime and preserved across reconnects
* New `wuji_glove_sync_time` triggers a single time-sync round-trip with a Wuji Glove, filling `WujiTimeSyncResult` with the clock offset, round-trip time, and measurement timestamp in microseconds, matching Python `glove.sync_time()`
* New `wuji_glove_get_hand_model_path` / `wuji_glove_set_hand_model_path` (and Python `glove.hand_model_path().get()/set(path)`) select a custom hand URDF for Wuji Glove online IK. Python subscription examples now expose `--hand-model-path`
**Device**
**Wuji Hand 2**
Breaking changes:
* Interface redesigned into a unified resource-style API. Every feature is accessed via `.get()` / `.set()` / `.subscribe()` / `.publish()`, with the same methods for whole-hand and per-joint use
* Control actions `enable()` / `disable()` / `clear_fault()` / `set_origin()` / `clear_origin()` accept a length-20 mask for subset operations. `emergency_stop()` always acts on the whole hand
* Feedback as subscription streams: `hand.joint_states()` and `hand.joint_diagnostics()`, with feedback frames carrying a `FrameHeader` (seq / timestamp\_us / frame\_id `l_wrist` / `r_wrist`), containing only online joints
* Real-time control moved to a publish model: `hand.joint_command().publish().send(joints)` takes 20 `JointCommand` entries (each with position / velocity / effort). The previous `send(positions, velocities, efforts)` three-list form is retired
* Configuration resources `mit_params` (kp/kd) and `effort_limit` (A) reject NaN / inf / negative writes
* Control mode is no longer set from Python. The device runs MIT control by default
New capability:
`describe_error(code)` translates a status / error code into a human-readable description.
**Wuji Glove**
Breaking changes:
* Updated `tactile_point_cloud` to the 526-taxel active point-cloud contract — use a matching firmware version to keep point-cloud frames consistently at 526 points
* The default SDK user now always uses the built-in default hand URDF for IK-derived streams (`hand_skeleton`, `hand_joint_angles`, `tip_poses`) and ignores stored calibration URDF paths. Calling `calibrate` as the default user fails fast with error code `0x4108`. Create or switch to a named SDK user before calibration so generated URDFs are scoped to that user
Default model refresh:
Finger-segment lengths and joint origins are updated to the latest calibration. Default hand-tracking output (`hand_skeleton`, `hand_joint_angles`, `tip_poses`) is more accurate when no user calibration profile is loaded. Joint and link layout unchanged.
**Submodules**
**Retargeting**
Ships with wuji-sdk, mapping hand keypoints to Wuji Hand / Wuji Hand 2 joint angles. Install with `pip install wuji-sdk[retarget]` (Linux x86\_64 / aarch64 only). The standalone Wuji Retargeting repo is no longer updated.
* Maps 21 MediaPipe-format hand keypoints to Wuji Hand joint angles. `wuji_sdk.retargeting.RetargetSession.for_hand(HandModel.WujiHand2, side=Handedness.Right)` builds a session in one line. `session.step(keypoints)` returns a 20-value joint command ready to send to the device with no extra reordering
* Includes a Wuji Glove → retargeting → Wuji Hand / Wuji Hand 2 live teleoperation example at `examples/python/retargeting/1.teleop_real.py`
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Firmware | v0.11.1 | Update via Wuji Studio |
**Key Updates**
**Firmware**
* Fixed intermittent hand-pose jumps: IMU FIFO packets are validated before fusion, so invalid samples no longer corrupt the pose estimate
* Fixed IMU initialization not respecting the factory configuration. Palm-IMU devices no longer probe disabled slots or report partial initialization
## June 2026
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji SDK | v2026.6.18 | `pip install --upgrade wuji-sdk` |
**Key Updates**
**Wuji Glove**
* Tactile data layout updates to 744 values in 24×31 (was 768, 24×32), shrinking `tactile`, `tactile_residual`, `tactile_binary` frames and the per-zone layout, with invalid taxels still reported as `-1.0`
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji SDK | v2026.6.18 | `pip install --upgrade wuji-sdk` |
| Wuji Studio | v2026.6.18 | [Click to download](https://github.com/wuji-technology/wuji-studio/releases/tag/v2026.6.18) |
| Firmware | v0.11.0 | Update via Wuji Studio |
**Key Updates**
**Wuji SDK**
* Tactile data layout updates to 744 values in 24×31 (was 768, 24×32), shrinking `tactile`, `tactile_residual`, `tactile_binary` frames and the per-zone layout, with invalid taxels still reported as `-1.0`
**Wuji Studio**
* Tactile matrix and per-zone matrix panels now display the new 24×31 (744) layout
* MCAP playback now rejects legacy 24×32 (768) or corrupted tactile recordings with a warning instead of rendering them at the wrong dimensions
**Firmware**
* Tactile output now uses the new 24×31 matrix format, requires matching Wuji Studio and SDK versions, older 768-point firmware is incompatible
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji SDK | v2026.6.16 | `pip install --upgrade wuji-sdk` |
**Key Updates**
**General**
* Added a prebuilt C SDK (`libwuji_sdk_c.so` + `wuji_sdk.h`), currently scoped to Wuji Glove only, covering device connection, cross-device coordinate transforms (`tf` / `tf_static`), and stream subscriptions (tactile, tactile zones, EMF poses, hand joint angles, hand skeleton, tactile point cloud), for `x86_64-linux-gnu` / `aarch64-linux-gnu` / `aarch64-android`.
* Added local SDK user profiles via `SdkManager.create_user(display_name)` and `switch_user()` — each profile keeps its own calibration data per device, and switching profiles reloads calibration on connected devices immediately.
**Wuji Glove**
* Added `glove.tactile_residual()` publishing 768 continuous contact-residual values at the same rate as `tactile` (positive = pressed, \~0 = no contact, `-1.0` = invalid), mirroring `TactileFrame` shape so existing tactile-grid visualizers work unchanged. Apply your own thresholding instead of the built-in `tactile_binary` output.
* Hand pose solving now runs in parallel, reducing compute time behind `hand_joint_angles` and derived hand-tracking data, output values and schemas unchanged.
* Added Python-side hand model calibration via `glove.calibrate()` with per-pose progress callbacks (`on_feedback`), select `hand_profile` for Wuji Hand or Wuji Hand 2, or leave it unset to generate URDFs for both profiles from a single capture, switchable later for live hand tracking.
* Added `glove.emf_poses_rate_divider()` to lower EMF pose output rate (default 1, set N to publish at input\_rate/N, e.g. N=4 → 120Hz down to \~30Hz). All EMF-derived streams (`emf_poses` / `hand_joint_angles` / `tip_poses` / `hand_skeleton` / `tactile_point_cloud`) drop to the same rate to reduce IK compute, while IMU (`imu_*`, `tf`) and raw tactile streams (`tactile` / `tactile_zones` / `tactile_residual` / `tactile_binary`) keep original rate. Runtime-effective, persists across reconnects.
**Wuji Hand**
* Added the `wuji_sdk.WujiHand` class — Wuji Hand is now usable directly through `wuji-sdk` (alongside the existing `wujihandpy`), with USB auto-discovery and connection, motor enable/disable, per-joint effort limits, real-time 20-joint position subscription and command publishing with `LowPass` smoothing, and an optional plug-in tactile glove stream.
* The `WujiHand` API surface mirrors Wuji Hand 2 (`scan` / `connect` / `joint_state` / `joint_command`), so code patterns largely interoperate between the two generations.
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji SDK | v2026.6.16 | `pip install --upgrade wuji-sdk` |
| Wuji Studio | v2026.6.15 | [Click to download](https://github.com/wuji-technology/wuji-studio/releases/tag/v2026.6.15) |
| Wuji Description | v2026.6.12 | [Click to download](https://github.com/wuji-technology/wuji-description/releases/tag/v2026.6.12) |
**Key Updates**
**Wuji SDK**
* Added `glove.tactile_residual()` publishing 768 continuous contact-residual values at the same rate as `tactile` (positive = pressed, \~0 = no contact, `-1.0` = invalid), mirroring `TactileFrame` shape so existing tactile-grid visualizers work unchanged. Apply your own thresholding instead of the built-in `tactile_binary` output.
* Added a prebuilt **C SDK** (`libwuji_sdk_c.so` + `wuji_sdk.h`) covering device connection, cross-device coordinate transforms (`tf` / `tf_static`), and stream subscriptions (tactile, tactile zones, EMF poses, hand joint angles, hand skeleton, tactile point cloud), for `x86_64-linux-gnu` / `aarch64-linux-gnu` / `aarch64-android`.
* Hand pose solving now runs in parallel, reducing compute time behind `hand_joint_angles` and derived hand-tracking data, output values and schemas unchanged.
* Added Python calibration API `glove.calibrate()` / `calibrate_blocking()` with timeout, constraint-skip, and `on_feedback` callback. See [Calibration](/en/docs/wuji-glove/sdk-data-reference/calibration) for details.
* Real-time IK supports hand-profile selection via `calibration.hand_profile` (`"wujihand"` / `"wujihand2"`), calibration without this parameter generates both URDFs for runtime switching without recalibration.
* Added local user isolation API (`SdkManager.create_user` etc.) so operators sharing the same device don't overwrite each other, with automatic parameter reload on user switch — no reconnect required.
* Added `glove.emf_poses_rate_divider()` to lower EMF pose output rate (default 1, set N to publish at input\_rate/N, e.g. N=4 → 120Hz down to \~30Hz). All EMF-derived streams (`emf_poses` / `hand_joint_angles` / `tip_poses` / `hand_skeleton` / `tactile_point_cloud`) drop to the same rate to reduce IK compute, while IMU (`imu_*`, `tf`) and raw tactile streams (`tactile` / `tactile_zones` / `tactile_residual` / `tactile_binary`) keep original rate. Runtime-effective.
**Wuji Studio**
* Added the Device Tools **Modify Device Port** command to change a device's data port (the device reboots to apply).
* Added the `wujistudio.recording` extension API so authorized extensions can start, inspect, and stop Studio-managed recordings (with optional source/topic selection).
* 3D panel Hand Skeleton supports hand profile switching (`wujihand` / `wujihand2` / Custom URDF), with Custom URDF letting SDK-side IK use a local URDF file.
* Calibration now creates a debug recording of the current device at start for later troubleshooting.
* **Modify Device IP** restricts the new address to private subnets, others are rejected.
* `wujistudio.devices.subscribeTopic` now requires the `robotics.topics.read` permission, extensions must declare it under `permissions` in `wujistudio.extension.json`.
* Updated the bundled device SDK integration for user-scoped calibration and SDK-managed hand profile selection.
* Fixed 3D panel point-cloud colors appearing scrambled and washed-out or semi-transparent. Point-cloud colors now render correctly and match the selected color map.
* Fixed device logs not resuming after the device passively reconnects (for example, after a firmware-upgrade restart).
**Wuji Description**
* First release of the Wuji Glove URDF model with 21 joints including a wrist electromagnetic transmitter and fingertip receiver coils for hand motion tracking.
* Added STL meshes for the transmitter and receiver coils, plus the transmitter top-cover STEP and assembled PDF.
* Removed the standalone attachment STEP, all Wuji Glove model assets now live under `glove/body/`.
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji SDK | v2026.6.2 | `pip install --upgrade wuji-sdk` |
**Key Updates**
* **Wuji Glove**: Added the binary contact tactile stream `glove.tactile_binary()`, published at the same rate as `tactile()` with 768 contact states (`1.0` in contact, `0.0` no contact, `-1.0` invalid taxel). It mirrors the `TactileFrame` shape, so existing tactile-grid visualizers work without changes.
* Added handedness-based connection `SdkManager.connect(handedness=Handedness.Left | Handedness.Right, ...)` to connect to the left or right side of a bimanual device directly.
## May 2026
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji SDK | v0.10.0 | `pip install --upgrade wuji-sdk` |
**Key Updates**
* Added `device.export_flash_logs(out_dir)` to dump historical device logs to JSONL files
* Added per-channel recording health via `QualityMetrics.channels` — frame rate, drop rate, jitter, `is_online`, and `last_downtime_ms` for each recorded topic
* **Wuji Glove**: `hand_joint_angles` and `tip_poses` now derive from the URDF kinematic chain. Output schemas are unchanged, but numerical values may differ from previous versions
* **Wuji Glove**: Removed `glove.tactile_raw()` — subscribe to `glove.tactile()` (calibrated tactile frames) instead
* **Wuji Glove**: Removed `glove.factory_reset()`
* Fixed devices not reliably publishing offline status when `disconnect_all()` is called from non-async contexts
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji SDK | v0.10.0 | `pip install --upgrade wuji-sdk` |
| Wuji Studio | v2026.5.18 | [Click to download](https://github.com/wuji-technology/wuji-studio/releases/tag/v2026.5.18) |
**Key Updates**
**Wuji SDK**
* `hand_joint_angles` and `tip_poses` now derive from the URDF kinematic chain. Output schemas are unchanged, but numerical values may differ from previous versions.
* Removed `glove.tactile_raw()` — subscribe to `glove.tactile()` (calibrated tactile frames) instead.
* Removed `glove.factory_reset()`.
* Added `device.export_flash_logs(out_dir)` to dump historical device logs to JSONL files.
* Added per-channel recording health via `QualityMetrics.channels`: frame rate, drop rate, jitter, `is_online`, and `last_downtime_ms` for each recorded topic.
**Wuji Studio**
* Added Extensions view: browse installed extensions and install or uninstall local extensions in one place.
* Preinstalled first-party extensions for calibration, teleoperation, and device tools, ready to use out of the box.
* Fixed layout presets, saved layouts, and user preferences being blank after a fresh install on Linux.
* Fixed URDF local file loading failing on Windows in the 3D panel.
* Fixed URDF meshes not tracking `/joint_states` in real time.
## April 2026
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Firmware | v0.10.1 | Update via Wuji Studio |
**Key Updates**
* Fixed some known issues.
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Firmware | v0.10.0 | Update via Wuji Studio |
| Wuji Studio | v0.10.0 | [Click to download](https://github.com/wuji-technology/wuji-studio/releases/tag/v0.10.0) |
**Key Updates**
**Firmware**
* Fixed periodic tactile data dropouts, improving sampling stability.
**Wuji Studio**
* Auto-checks for Studio and device firmware updates, surfacing new versions in a toast and the notification center, with one-click navigation to the download page or upgrade view.
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji SDK | v0.9.0 | `pip install --upgrade wuji-sdk` |
**Key Updates**
* Fixed some known issues
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Firmware | v0.9.0 | Update via Wuji Studio |
| Wuji SDK | v0.9.0 | `pip install --upgrade wuji-sdk` |
| Wuji Studio | v0.9.0 | [Click to download](https://github.com/wuji-technology/wuji-studio/releases/tag/v0.9.0) |
**Key Updates**
* Fixed some known issues.
## March 2026
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Firmware | v0.8.0 | Update via Wuji Studio |
| Wuji SDK | v0.8.0 | `pip install --upgrade wuji-sdk` |
| Wuji Studio | v0.8.0 | [Click to download](https://github.com/wuji-technology/wuji-studio/releases/tag/v0.8.0) |
**Key Updates**
* Fixed some known issues.
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji SDK | v0.8.0 | `pip install --upgrade wuji-sdk` |
**Key Updates**
* Wuji SDK and Wuji Studio support sharing the same device
* Improved log availability and reliability during startup and runtime
* Improved upgrade stability and reduced false upgrade failure reports
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Firmware | v0.7.0 | Update via Wuji Studio |
| Wuji SDK | v0.8.0 | `pip install --upgrade wuji-sdk` |
| Wuji Studio | v0.8.0 | [Click to download](https://github.com/wuji-technology/wuji-studio/releases/tag/v0.8.0) |
**Key Updates**
* Improved log availability and reliability during startup and operation.
* Improved upgrade stability and reduced false upgrade failure reports.
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji SDK | v0.7.0 | `pip install --upgrade wuji-sdk` |
**Key Updates**
* Added cross-device merged subscription to receive aggregated data from all connected devices at once
* Added data recording with multi-channel capture, pause/resume, episode switching, and real-time quality monitoring
* Fixed an occasional crash in callback mode
* Fixed an issue where subscribing to multiple data streams simultaneously could result in missing data
* Fixed an issue where some Wuji Glove IMU data streams could not be subscribed
## February 2026
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji SDK | v0.6.0 | `pip install --upgrade wuji-sdk` |
**Key Updates**
* Added `get()` / `set()` APIs for reading and writing device configuration parameters
* Added `save_params()` to persist parameter changes to device flash
* Added SDK/Device logging support, use `set_log_level()` to control log level
* Added 6-sensor IMU data: `imu_palm()`, `imu_thumb()`, `imu_index()`, `imu_middle()`, `imu_ring()`, `imu_pinky()`
* Added coordinate transform APIs: `tf_static().subscribe()` and `tf().subscribe()`
* Added hand tracking data: `tip_poses()` (fingertip poses), `hand_joint_angles()` (21 DoF joint angles), `hand_skeleton()` (21 hand keypoints)
* Added tactile point cloud data: `tactile_point_cloud()` for 3D tactile visualization
* Positioning quality metric `EmfPose.confidence` — indicates EMF pose estimation reliability (0.0 to 1.0)
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Firmware | v0.6.0 | Update via Wuji Studio |
| Wuji SDK | v0.6.0 | `pip install --upgrade wuji-sdk` |
| Wuji Studio | v0.6.0 | [Click to download](https://github.com/wuji-technology/wuji-studio/releases/tag/v0.6.0) |
**Key Updates**
**Wuji Studio**
* Added hand skeleton and fingertip pose visualization with per-finger confidence coloring, joint axis display, and opacity settings.
* Added 3D panel tactile point cloud pressure coloring with standard colormaps (plasma, viridis, etc.) and transfer functions.
* Added device log panel to bottom bar with source and level filtering.
* Added LAYOUT panel to the visualization interface for one-click default panel restoration.
* **Raw Messages panel**
* Topic list now uses a tree structure, supporting hierarchical browsing of Topics and Schema fields.
* Added IMU data display support.
* Firmware upgrade page shows cumulative update log and displays a warning on downgrade.
* Added color vision accessibility settings, supporting three common color vision types.
* 3D view default configuration adapted to TF tree changes.
**Wuji SDK**
* Renamed the `EmfPose` `error` field to `confidence`.
* Added IMU orientation data and the `ImuData` API (palm, thumb, index, middle, ring, pinky).
* Added `tf`/`tf_static` coordinate transform APIs with `waist` as the base frame, supporting user-defined wrist offset.
* Added hand tracking data: `tip_poses()` (fingertip poses), `hand_joint_angles()` (21 DoF joint angles), and `hand_skeleton()` (21 hand keypoints).
* Added tactile point cloud data: `tactile_point_cloud()` for 3D tactile visualization.
* Added the device logging module.
* Changed the device parameter management API: `load_profile()`/`has_profile()` replaced by `get()`/`set()`/`save_params()`.
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Wuji SDK | v0.5.0 | `pip install wuji-sdk` |
**Key Updates**
* **Wuji SDK launch**: Python development kit for Wuji devices
* Callback subscription support with `subscribe_with_callback()`
* Async/await support with `recv_async()`
* IDE auto-completion support
* Data stream subscriptions: tactile matrix, tactile zones, EMF poses
**Supported Devices**
* Wuji Glove — Smart glove with tactile sensing and motion capture
**Component Versions**
| Component | Version | Update Method |
| - | - | - |
| Firmware | v0.4.0 | Update via Wuji Studio |
| Wuji SDK | v0.5.0 | `pip install wuji-sdk` |
| Wuji Studio | v0.5.0 | [Click to download](https://github.com/wuji-technology/wuji-studio/releases/tag/v0.5.0) |
**Key Updates**
**Introducing Wuji Glove**
* Smart glove with tactile sensing and motion capture.
* Tactile sensing: Full-hand tactile data with per-zone output (palm, thumb, index, middle, ring, pinky).
* Motion capture: Fingertip tracking module for 5-finger motion capture.
* LED indicator: Multi-state, multi-mode feedback for device status.
**Wuji Studio launch**
* New desktop application for multi-device connection, device management, and data visualization.
* Visualization panels: 3D view, Plot, Raw Message, and Tactile Matrix for intuitive data presentation.
* Device management: Device discovery, connection history, rename, calibrate, export calibration data, and device info.
* Firmware upgrade: Online download and local firmware upload with progress tracking and error diagnostics.
* Automatic left/right hand detection during device naming.
* 3D glove landmark visualization with positioning error mapped to point color.
* Light and dark theme switching.
**Wuji SDK launch**
* Semantic API for Wuji Glove with callback subscription and async support.
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.