Skip to main content

Wuji Hand 2

Wuji Glove

Wuji SDK

Wuji CLI

​
October 2026

​
Wuji Hand 2, Wuji Glove, Wuji SDK, Wuji CLI, and Wuji Description
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 ChangesWuji 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 FeaturesRuntime 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=<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.
ChangedFirmware 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 Fixes22 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 and C 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 and 7.mit_sweep.py, together with C opposition.c and 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 and 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

​
September 2026

​
Firmware v2.10.0 · Wuji SDK v2026.9.22
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 VersionsHighlights
  • 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
​
v2026.9.22
Component VersionsHighlights
  • 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
​
Firmware v1.0.2
Component VersionsHighlights
  • 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
​
v2026.9.22
Component VersionsHighlights
  • wuji viz supports live Wuji Glove visualization
  • wuji update --check shows the latest release notes and syncs the matching agent skills
​
Firmware v2.7.1 · Wuji SDK v2026.9.14
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 VersionsHighlightsBreaking 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

​
v2026.8.31
Component VersionsHighlightsGeneralChanged:
  • 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.
DevicesWuji Hand 2Added:
  • 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 GloveAdded:
  • 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.
SubmodulesRetargetingChanged:
  • Pinch-gesture retargeting now provides improved thumb-to-fingertip contact in both the Python and C SDKs.
​
Firmware v2.6.0 · Wuji SDK v2026.8.31
Component VersionsHighlightsAdded:
  • 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.
​
Firmware v0.12.0
Component VersionsHighlightsFirmware
  • Fixed some known issues.
​
v2026.8.31
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 VersionsHighlightsAdded:
  • 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.
​
v2026.8.17
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 VersionsHighlightsGeneralAdded:
  • 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.
DevicesWuji Hand 2Changed:
  • 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 GloveBreaking 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 HandFixed:
  • 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.
SubmodulesRetargetingChanged:
  • 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.
​
Firmware v2.4.0 · Wuji SDK v2026.8.17
Component VersionsHighlightsFirmwareAdded:
  • 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 SDKAdded:
  • 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 StudioFixed:
  • Fixed device connection issues.
  • Fixed an issue where incorrect firmware appeared in the firmware list during updates.
Wuji RetargetingChanged:
  • 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 DescriptionAdded:
  • 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 <site> 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 <site> 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.
​
Firmware v0.11.4 · Wuji SDK v2026.8.17
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 VersionsHighlightsFirmwareAdded:
  • 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 SDKBreaking 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.
​
v2026.8.17
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 VersionsHighlightsAdded:
  • 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 <sn>_<ts>_device.json + <sn>_<ts>_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.
​
v2026.8.3
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 VersionsHighlightsGeneralChanged:
  • 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.
DeviceWuji Hand 2New 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 GloveNew 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.
  • 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 HandChanged:
  • 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.
​
Firmware v2.2.3 · Wuji SDK v2026.8.3
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 VersionsHighlightsFirmwareNew 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
  • Added warning code 0x0015: abnormal motor parameters
Fixed:
  • Fixed some known issues
Wuji SDKNew 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 StudioFixed:
  • 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 RetargetingChanged:
  • 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.
​
Wuji SDK v2026.8.3
Component VersionsHighlightsWuji SDKNew 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.
  • 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.
​
v2026.8.3
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 VersionsHighlightsNew 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 [email protected].
  • 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

​
Wuji Hand 2
Component VersionsHighlightsWuji 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.
​
v2026.7.21
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 VersionsHighlightsDeviceWuji Hand 2New 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”
SubmodulesRetargetingNew 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
​
Firmware v2.1.0 · Wuji SDK v2026.7.21
Component VersionsHighlightsFirmwareNew 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 SDKNew 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”
​
v2026.7.15
Component VersionsHighlights
  • Fixed the install script exiting before it installed the agent skills
​
v2026.7.14
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 VersionsHighlightsGeneralNew 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
DeviceWuji HandNew 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 GloveBreaking 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
SubmodulesRetargeting
  • Optimized wheel packaging — download and installed size are significantly smaller. No functional change
​
Firmware v2.0.0 · Wuji SDK v2026.7.14
Component VersionsHighlightsFirmwareBreaking 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
​
Firmware v0.11.2 · Wuji SDK v2026.7.14
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 VersionsHighlightsFirmware
  • 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 SDKBreaking 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 StudioBreaking 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
​
v2026.7.14
Component VersionsHighlightsFirst 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 <topic>, 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
​
v2026.7.2
Component VersionsKey UpdatesDeviceWuji 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
SubmodulesRetargeting
  • 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
​
v2026.7.1
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 VersionsKey UpdatesC 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
DeviceWuji Hand 2Breaking 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 GloveBreaking 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.SubmodulesRetargetingShips 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
​
Firmware v0.11.1
Component VersionsKey UpdatesFirmware
  • 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

​
v2026.6.18
Component VersionsKey UpdatesWuji 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
​
Wuji SDK v2026.6.18 · Firmware v0.11.0
Component VersionsKey UpdatesWuji 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
​
v2026.6.16
Component VersionsKey UpdatesGeneral
  • 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.
​
Wuji SDK v2026.6.16
Component VersionsKey UpdatesWuji 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 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/.
​
v2026.6.2
Component VersionsKey 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

​
v0.10.0
Component VersionsKey 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
​
Wuji SDK v0.10.0
Component VersionsKey UpdatesWuji 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

​
Firmware v0.10.1
Component VersionsKey Updates
  • Fixed some known issues.
​
Firmware v0.10.0
Component VersionsKey UpdatesFirmware
  • 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.
​
v0.9.0
Component VersionsKey Updates
  • Fixed some known issues
​
Firmware v0.9.0 · Wuji SDK v0.9.0
Component VersionsKey Updates
  • Fixed some known issues.

​
March 2026

​
Firmware v0.8.0 · Wuji SDK v0.8.0
Component VersionsKey Updates
  • Fixed some known issues.
​
v0.8.0
Component VersionsKey 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
​
Firmware v0.7.0 · Wuji SDK v0.8.0
Component VersionsKey Updates
  • Improved log availability and reliability during startup and operation.
  • Improved upgrade stability and reduced false upgrade failure reports.
​
v0.7.0
Component VersionsKey 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

​
v0.6.0
Component VersionsKey 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)
​
Firmware v0.6.0 · Wuji SDK v0.6.0
Component VersionsKey UpdatesWuji 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().
​
v0.5.0
Component VersionsKey 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
​
Firmware v0.4.0 · Wuji SDK v0.5.0
Component VersionsKey UpdatesIntroducing 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.