Jumper, the Jumping Crab Robot: What Is Open Source, What Isn't, and What You Can Do Without One

Robotics is a new EXEPERT section about robots that people can build, train or buy, and the software and hardware behind them. Each post explains how a robot works and checks what is being claimed about it.

The first post starts with a viral claim. On 4 October 2026, the Threads user @aeejazkhan posted that someone had built a tiny crab robot that can jump around your house, adding that "everything is Open Sourced" (aeejazkhan, 2026).

The robot is Jumper, and the "someone" is a company: Beijing KingKong Technology, which publishes Jumper's code on GitHub as KingKong Robotics. This post explains what Jumper is and how its open toolkit works, then checks what "everything" actually covers.

What Jumper is

KingKong Technology is based in Changping District, Beijing. It makes encoders for robot joints and small servo motors that it calls tactile servos (KingKong Technology, n.d.-b). Jumper, called Tiaotiao in Chinese, is the small robot it has built on those parts. A report republished by China.com on 30 September 2026 says the robot had appeared at the World Artificial Intelligence Conference, the World Robot Conference and a Douyin creators' conference, and that one video of it passed ten million views. The report names the company's founder as Liang Zheng, a technology content creator who posts as Liang Buwai (China.com, 2026).

The repository's README describes Jumper as a crab robot with 22 degrees of freedom (KingKong Robotics, 2026c). The joint names in its simulation model show how they are split: four walking legs with three joints each, and two front arms with five joints each that end in claws.

The hardware page in the repository lists the following (KingKong Robotics, 2026d):

KingKong's product page adds performance figures: a top speed of at least 0.5 m/s, a maximum jump height of at least 400 mm, a grasping load of up to 1 kg and about two hours of battery life. It notes that specifications, test conditions and the delivered configuration are subject to official product documentation (KingKong Technology, n.d.-a).

The hardware page links Jumper's servos to KingKong's tactile servo page. That page describes the TS20 as a motor, gearbox, triple encoder and driver packed into a 20 × 35 mm body weighing 35 g, with 50:1 or 100:1 gearing, RS485 communication and backdrivable force feedback (KingKong Technology, n.d.-b).

How the toolkit works

The README calls the repository "Jumper's AI toolkit for appearance, motion, and scene creation" (KingKong Robotics, 2026c). It is designed to be opened in an AI coding assistant. The README offers three one-sentence prompts, for designing an appearance, training a motion and creating a scene, and the repository ships written playbooks, which it calls skills, for setting up a machine, adding a training task, changing controls and deploying a policy to the robot.

Appearance

Appearances and scenes live in a second repository, jumper-design, also under Apache-2.0 (KingKong Robotics, 2026b). An appearance is exported as a .skin package; the examples include a warm sand ranger, a suit of silver armour and a Raphael turtle. In the current version, skins are display-only, and the training code cannot load them (KingKong Robotics, 2026e). jumper-design also describes a workflow for designing a 3D-printed shell for the same robot. For that, it includes a CAD pack of the original upper shell's mounting interface, which its documentation calls "an engineering reference, not a certified manufacturing release"; the pack's physical fit has not been tested (KingKong Robotics, 2026h).

Motion: reinforcement learning in simulation

Jumper's movements are controlled by a policy: a small neural network that reads the robot's sensors, such as joint angles and the IMU, and outputs target angles for the joints many times a second. Nobody writes the walking rules by hand. Instead, reinforcement learning trains the policy by trial and error. Hundreds or thousands of simulated Jumpers run in parallel, earn rewards for doing what the task asks, such as following a speed command without falling over, and the network is nudged towards the actions that earned more reward.

The training stack is built from established open projects:

• MuJoCo, a physics engine designed for robots that make contact with the world (Todorov et al., 2012), now developed by Google DeepMind.

• MuJoCo Warp, a GPU-accelerated version of MuJoCo for NVIDIA hardware, maintained by Google DeepMind and NVIDIA (Google DeepMind & NVIDIA, 2026). Jumper's project guide calls it the primary trainer, with ordinary MuJoCo running on CPU threads as a second option (KingKong Robotics, 2026e).

• mjlab, which combines the task-building interface of NVIDIA's Isaac Lab with MuJoCo Warp (Zakka et al., 2026).

• rsl_rl, a learning library from ETH Zurich's Robotic Systems Lab (Schwarke et al., 2025), which supplies proximal policy optimisation (PPO), a widely used reinforcement learning algorithm (Schulman et al., 2017).

The tasks include three walking gaits (tripod, tetrapod and ripple), posture changes, a jump, dances, gestures and grasping with the claws. The jump and the dances are guided by recorded motions: the jump's reference is a crouch, jump, tuck and landing lasting 1.47 seconds, and the policy learns to follow it while staying balanced (KingKong Robotics, 2026f).

The hard part of training robots this way is the gap between simulation and reality. A policy can learn to exploit a simulator's quirks and then fail on real motors. The repository's notes show how it narrows that gap. The simulated servos are limited by a torque-speed curve, and the jump notes record that an earlier reference motion assumed 2.0 N·m of torque that the motors could not deliver at speed; it was regenerated against a peak of 1.7464 N·m (KingKong Robotics, 2026f). The export step also refuses any policy that relies on something the real robot cannot measure, such as its own linear velocity, for which Jumper has no estimator (KingKong Robotics, 2026a).

Scenes

Scenes are .map packages made with jumper-design. The examples include a park pump track, a bedroom and a soccer pitch. Imported maps work for replay but not for training, so policies are trained in built-in scenes: a studio floor, rough ground, ice, stairs and a rope swing (KingKong Robotics, 2026e).

From simulation to the robot

A trained policy is exported to ONNX, a standard format for neural networks, then converted to RKNN to run on the RK3576's neural processing unit. It is packaged with a controller written in Rust into a .app bundle. The same bundle is designed to run on three hosts: the robot's board, a web browser and the desktop replay tool. On the robot, the controller is meant to send joint commands at 1 kHz, while each policy runs at its own rate: 200 Hz for the current walking mode and the jump, 50 Hz for the claws, dances and gestures (KingKong Robotics, 2026a).

What you can do without the robot

Most of the toolkit needs no hardware at all.

• Train in Google Colab. The notebook runs on a hosted GPU, so your computer only needs a browser. A new run defaults to the tripod gait, 256 parallel environments and 500 iterations. It plots training curves, records MP4 replays, exports the policy to ONNX and saves a backup ZIP, and KingKong says the workflow was tested on an NVIDIA Tesla T4 (KingKong Robotics, 2026j).

• Train on your own machine. The project needs Python 3.10 to 3.13. An NVIDIA GPU is the fast route, but a CPU-only run with 64 environments is supported (KingKong Robotics, 2026e).

• Try the browser simulator. The product page includes one: click the floor and Jumper walks there around obstacles, or drive it with the keyboard (KingKong Technology, n.d.-a).

• Enter the challenge. The README's "Get a free Jumper" link leads to the Crab Robot Open Motion Challenge, which opened on 30 September 2026. According to the China.com report, it is run by Liang Zheng's account with KingKong and Douyin; entrants in China post a video of more than 15 seconds on Douyin, and entries are judged 60% on video popularity and 40% on expert scores. The prizes are 100 Jumper engineering units, which the report says are not a finished product (China.com, 2026).

The Colab guide is unusually candid about what a short run achieves. Its own 500-iteration demonstration stayed at the first curriculum level, with a tracking error of 0.195 against a promotion threshold of 0.105. The guide says the video "demonstrates the workflow, not a converged gait" (KingKong Robotics, 2026j). Expect to train for longer, and to judge results by the curves and replays rather than by the run finishing.

Is everything open sourced?

Here is what the two repositories contain, as read on 13 October 2026:

The software half of the claim holds up. The training pipeline, the robot's simulation model, example policies and the controller meant to run on the board are all public. Apache-2.0 is a permissive licence: it allows modification and commercial use, provided the licence and notices are kept, and it includes a patent grant. The README adds two limits: third-party material stays under its own terms, and files you generate with the tools do not automatically inherit the repository's licence (KingKong Robotics, 2026c).

The hardware half does not. The STL meshes in the repository describe the shapes of the robot's parts for simulation and rendering. They are not manufacturing drawings, and there is no bill of materials, electronics design or assembly guide. jumper-design's licence notice says plainly that historical manufacturing CAD and print deliveries were excluded from the public edition (KingKong Robotics, 2026g). The only CAD files in either repository sit in the upper-shell interface pack, included so people can design replacement shells; its documentation says its redistribution status is unconfirmed and that the Apache-2.0 licence must not be assumed to cover it (KingKong Robotics, 2026h). The servos are KingKong's own product. You cannot build a Jumper from what has been published; you can only train for one.

Two more details are worth knowing.

First, the project guide says real-hardware work is still a separate step. Neural-network inference on the robot's NPU "has not yet been verified on the board", and the controller loop has not yet driven the robot's live motor bus (KingKong Robotics, 2026e). The repository's notes on the website clips used in its README say they are not evidence that its simulation policies drive the robot shown (KingKong Robotics, 2026i).

Second, the numbers differ. The product page claims a maximum jump height of at least 400 mm (KingKong Technology, n.d.-a). The repository's jump record, measured in simulation, shows earlier versions raising the body by 0.15 to 0.16 m, and the current reference motion asks for a 0.141 m rise (KingKong Robotics, 2026f). The two figures may measure different things, and the simulation numbers come from one policy at one stage of development. But they are a reminder to read a spec sheet and a trained policy separately.

None of this makes the release less useful. It is a well-documented, permissively licensed robot-learning project, and its documentation is careful about what has and has not been tested. A fair summary of the Threads post: a company, not a lone maker, built the robot; the software for training it is open source; the robot itself is not.

What to watch

• Price and availability. Neither the product page nor the README lists a price or a sale date.

• Mechanical files. Whether KingKong publishes CAD, a bill of materials or assembly instructions, which would make the hardware open as well.

• Hardware validation. The first public evidence of a policy trained with the open toolkit running on a real Jumper through the open controller.

• The challenge. The results, and how entrants outside China can take part.

References

aeejazkhan. (2026, October 4). Someone built a tiny crab robot that can jump around your house (everything is Open Sourced) [Threads post]. Threads. https://www.threads.com/@aeejazkhan/post/DeEqWw7CD37

China.com. (2026, September 30). 爆火的螃蟹机器人“跳跳”开源了，还将免费送出100台 [Viral crab robot Tiaotiao goes open source and will give away 100 units]. https://mtz.china.com/touzi/2026/0930/266506.html

Google DeepMind & NVIDIA. (2026). MuJoCo Warp (MJWarp) [Computer software]. GitHub. https://github.com/google-deepmind/mujoco_warp

KingKong Robotics. (2026a). Deploy: From a checkpoint to whatever runs it. GitHub. https://github.com/KingKongRobotics/jumper/blob/main/deploy/README.md

KingKong Robotics. (2026b). Design workflow [Computer software]. GitHub. https://github.com/KingKongRobotics/jumper-design

KingKong Robotics. (2026c). Jumper [Computer software]. GitHub. https://github.com/KingKongRobotics/jumper

KingKong Robotics. (2026d). Jumper hardware specifications. GitHub. https://github.com/KingKongRobotics/jumper/blob/main/docs/HARDWARE.md

KingKong Robotics. (2026e). Jumper project guide. GitHub. https://github.com/KingKongRobotics/jumper/blob/main/docs/PROJECT_GUIDE.md

KingKong Robotics. (2026f). jumper.jump jump task: Version record. GitHub. https://github.com/KingKongRobotics/jumper/blob/main/docs/jumper_jump.md

KingKong Robotics. (2026g). License scope and provenance. GitHub. https://github.com/KingKongRobotics/jumper-design/blob/main/NOTICE.md

KingKong Robotics. (2026h). Mechanical platform packs. GitHub. https://github.com/KingKongRobotics/jumper-design/blob/main/docs/platform-pack.md

KingKong Robotics. (2026i). Motion showcase sources. GitHub. https://github.com/KingKongRobotics/jumper/blob/main/docs/media/MOTION_SOURCES.md

KingKong Robotics. (2026j). Run Jumper in Google Colab. GitHub. https://github.com/KingKongRobotics/jumper/blob/main/docs/COLAB.md

KingKong Technology. (n.d.-a). Jumper: Open-source crab robot. Retrieved October 13, 2026, from https://kingkong.tech/en/jumper

KingKong Technology. (n.d.-b). Tactile servo. Retrieved October 13, 2026, from https://kingkong.tech/en/servo

Schulman, J., Wolski, F., Dhariwal, P., Radford, A., & Klimov, O. (2017). Proximal policy optimization algorithms (arXiv:1707.06347). arXiv. https://arxiv.org/abs/1707.06347

Schwarke, C., Mittal, M., Rudin, N., Hoeller, D., & Hutter, M. (2025). RSL-RL: A learning library for robotics research (arXiv:2509.10771). arXiv. https://arxiv.org/abs/2509.10771

Todorov, E., Erez, T., & Tassa, Y. (2012). MuJoCo: A physics engine for model-based control. In 2012 IEEE/RSJ International Conference on Intelligent Robots and Systems (pp. 5026–5033). IEEE. https://doi.org/10.1109/IROS.2012.6386109

Zakka, K., Liao, Q., Yi, B., Le Lay, L., Sreenath, K., & Abbeel, P. (2026). mjlab: A lightweight framework for GPU-accelerated robot learning (arXiv:2601.22074). arXiv. https://arxiv.org/abs/2601.22074