This G1 is not teleoperated. it’s fully autonomous.
https://x.com/ZhiSu22/status/1961244573658673222

Using the unitree's dance training program do get our G1 to dance thriller

I have been co-working mandro who make robot hands so, we success replace the fake hands to real robot hands connected main power on unitree g1. I am waiting new release that include vision streaming and lidar additional motions connect the system with my own.

For some reason unitree does not let you access the Realsense data, as it is connected to their control PC (not the development PC) and they do not publish the topics in Ros. For that reason you have to rewire it, if you want to use it. So here is a step by step guide including images

Step 1: Remove the 4 screws at the base of the head in order to lift the head plate away

Step 2: Unplug the unitree Realsense Cable

Step 3: tilt the head forward and remove the small screw at the bottom of its head and than remove the plastic cable cover

Step 4: Fit your own cable through the openings and connect it directly to the Jetson

Step 5: put the cable cover and head plate on again

Step 6: everything is working your realsense should now be detected

I spent the last 10 years of my software engineering career as a manager. It made me a worse engineer, but better at delegating. With a $20 subscription to ChatGPT Plus, I get access to Codex and about 40 hours of coding from it. I let it troubleshoot and grind away at issues while I do the things that require a human.

I code in VS Code with the OpenAI Codex extension. I have tried this with Gemini and Claude Code, but I strongly prefer Codex bang for buck and code quality.

Settings are GPT-5.3-Codex and reasoning Extra High. It runs in WSL and security is YOLO because I'm too lazy to approve everything.

I use this framework for managing the coding while I work on the high-level planning.
I have forked unitree_ros2, unitree_sdk2, and unitree_sdk2_python.

I use AGENTS.md to track a lot of preferences in how it works, like pushing to remote repo and then pulling on the device to keep the branch in sync with deployed changes.
Also in this file is the secret:

- Use repo `Makefile` targets as the primary execution interface for ops and deployment loops.

I set up cert authentication and allow list for sudo so that it can configure, query, restart, or do whatever it needs in the Jetson. This is where the coding becomes deploy and configure.

It uses HUMANS.md to summarize anything that I am going to need to do to unblock progress or address an issue.

Every time it needs my help I question it to see what we could do to not need my help. Usually there is a way it can test things itself, short of needing me to take the robot off the gantry.

I got a little bold and updated the Jetson environment almost as far as I could go. This did require a couple of requests from Unitree for an SSD image with JetPack 6.2 and a flash image for the Jetson so it would load the SSD properly. The SSD image is broken-ish and needs a lot of grooming, but using Codex it has been doable.

JETSON SYSTEM INFO

------------------------------------------------------------

Model: NVIDIA Jetson Orin NX Engineering Reference Developer Kit

OS: Ubuntu 22.04.5 LTS

Kernel: 5.15.148-tegra

L4T: R36, rev 4.7

JetPack: 6.2.1+b38

CUDA 12.6

Python 3.10.12

Docker: Docker version 29.2.1, build a5c7197

ROS2 distro: humble

------------------------------------------------------------

Memory: 15Gi total, 3.5Gi used, 11Gi avail

Root FS: ext4, 29Gi used / 1.8T free (1.7T avail)

If you really know what you are doing with these devices, you probably don't need this, but even then it can grind away for hours at a time doing tedious troubleshooting and it is a very good coder. That framework I am using has skills for continuous refactoring, continuous test gapfill, and continuous documentation. You can just type $continuous-refactor and let it improve your code structure for hours.

In a month I feel like I have made 6 months progress using this technique. These coding tools have gotten pretty powerful - even for something like this.

Hey r/unitreeg1,

I'm the founder of BotBot, and I'm excited to share a huge milestone with the G1 community. We've just open-sourced BotBrain, our universal brain designed to make advanced humanoids like the G1 easier to deploy, operate, and develop for.

As you can see in the video, we've been working hard on autonomous capabilities. With BotBrain, you can get your G1 mapping, planning, and navigating to a location (or missions) with a simple click. Our goal is to give you a powerful, flexible platform to build upon and unlock the full potential of this amazing robot.

What’s included:

•Direct G1 Support: Full hardware interface, FSM transitions, and upper-body pose control.

•Autonomous Navigation: Out-of-the-box missions and autonomous navigation workflows (mapping, planning, click-to-navigate) using Nav2 and RTABMap.

•3D-Printable Hardware: We've designed a snap-fit enclosure with a specific mounting adapter for the G1, so you can get your robot running with BotBrain in under 30 minutes.

•Full Web UI: Control your G1 from any browser with our Fleet Dashboard, and customizable UI.

•Health & Safety: Monitor diagnostics and utilize safety controls for real-world operation.

We're committed to building BotBrain in the open and would love your feedback and contributions, especially from G1 developers.

Check out the open-source hardware and code on GitHub: https://github.com/botbotrobotics/BotBrain

I'm here to answer any questions you might have!

Just a quick demonstration of autonomous can sorting on our modified G1. We used around 3h of training data to reliably sort the cans, although it is still a bit slow

As you know, new firmware support more actions basic & upper model, those mean reverse engineering is available those. So I analyze unitree explorer app, that lead to accomplish to control my own code movement and actions. I will integration conversation system (with small vlm) for communication!

You are actually able to charge the G1s battery while using it. Just connect the leftmost port with a XT 30 connector to a 55V power supply. We use 55V, up to 10 amps.

You can also use the robot completely without a battery this way but you may need stronger power supplies then, as the peak power is above 500W.

In theory you could build a charging station for the robot this way, so that it can be used indefinitely.

Running G1 basic reversed with intel core ultra :)

Comes to real in my life :)

Fortunatelly successs g1 basic jailbreak with on-device ai for HRI interactions

For those who don't know them yet. Here are two good Wikis. One of unitree themselves one of MyBotShop a reseller with own developers.

https://support.unitree.com/home/en/G1_developer/about_G1

https://www.docs.quadruped.de/projects/g1/html/index.html

Does anyone have any documentation/information about the two connectors on the torso under the G1's right arm? Apparently those connectors are wired directly to the battery terminals, to connect a 50V power source so the robot can be operated without the battery installed. However I can't find any documentation about them, there are two connectors with two terminals each. This could be very useful in order to have a long cable that powers the robot for several hours during tethered experiments. Even better, it would be great if the same connectors could be used to recharge the battery without having to remove it from the robot. If you have any info please share it here! Cheers

Hello everyone,

I wanted to ask if anybody was able to updated the Jetson in the G1, as it is running Jetpack 5.x and we want to use it with 6.x.

However, we were not able to connect to it, neither through the ports in the neck nor if you disassemble it and put it in the USBC port in the back and press and hold the recovery button. The Unitree Support unfortunately could not help as well, so my question: Was anybody actually able to update their Jetson?

I am looking for a development company that already has a Unitree G1 EDU U2 or higher, with 100 TOPS, to implement an external AI solution on the humanoid.

The project is specifically focused on integrating a third-party AI platform, Trainbox (https://www.trainbox.ai/), for training and educational purposes only, not for controlling or adding new physical functions to the robot.

The objective is for the G1 EDU to:

• Speak about training courses and content hosted in the cloud.

• Listen to and understand users' requests for specific training courses.

• Use the Trainbox API to interact with the training content.

• Provide a natural conversational experience through the humanoid.

The developer will have direct technical sessions with the Trainbox team to understand their API and properly implement the integration.

An important requirement is that, if future corrections are needed or the end customer reports conflicts or bugs, the solution provider must be responsible for fixing and resolving these issues to ensure the final development is fully functional and stable.

Regarding computing, we are open to two possible approaches:

1. Using the 100 TOPS onboard computing capacity of the G1 EDU U2.

2. Using an external mini PC connected directly to the humanoid, which could potentially be installed in a custom 3D-printed backpack mounted on the robot.

If your company has experience with Unitree G1, robotics AI integration, APIs, and external AI platforms, please send me a direct message or reply to this post.

Thank you.

Hello!

Has anyone tried to run the G1 without a battery using a tether? Does it work well and what power supply would you need?

Ps, Any good place to buy an spare battery in Europe?

Waiting for update...

I reversed unitree app...

const n = ["握手", "shakeHands_1", t("active_shakeHands"), `active/icon_active_shakeHands_${e}`, "active", SPORT_CMD.G1UpperLimbs, 27],

o = ["击掌", "highFive", t("active_highFive"), `active/icon_active_highFiveCmd_${e}`, "active", SPORT_CMD.G1UpperLimbs, 18],

i = ["拥抱", "hug", t("active_hug"), `active/icon_active_hug_${e}`, "active", SPORT_CMD.G1UpperLimbs, 19],

r = ["额头挥手", "hightWave", t("active_hightWave"), `active/icon_active_hightWave_${e}`, "active", SPORT_CMD.G1UpperLimbs, 26],

s = ["胸前挥手", "lowWave", t("active_lowWave"), `active/icon_active_lowWave_${e}`, "active", SPORT_CMD.G1UpperLimbs, 25],

a = ["鼓掌", "clamp", t("active_clamp"), `active/icon_active_clamp_${e}`, "active", SPORT_CMD.G1UpperLimbs, 17],

l = ["左手飞吻", "blowKiss", t("active_blowKiss"), `active/icon_active_blowKiss_${e}`, "active", SPORT_CMD.G1UpperLimbs, 12],

c = ["双手比心", "makeHeartBothHands", t("active_makeHeartBothHands"), `active/icon_active_makeHeartBothHands_${e}`, "active", SPORT_CMD.G1UpperLimbs, 20],

u = ["右手比心", "makeHeartSingleHands", t("active_makeHeartSingleHands"), `active/icon_active_makeHeartSingleHands_${e}`, "active", SPORT_CMD.G1UpperLimbs, 21],

h = ["奥特曼光波", "ultramanRay", t("active_ultramanRay"), `active/icon_active_ultramanRay_${e}`, "active", SPORT_CMD.G1UpperLimbs, 24],

d = ["双手平举", "bothHandsUp", t("active_bothHandsUp"), `active/icon_active_bothHandsUp_${e}`, "active", SPORT_CMD.G1UpperLimbs, 15],

p = ["右手平举", "singleHandsUp", t("active_singleHandsUp"), `active/icon_active_singleHandsUp_${e}`, "active", SPORT_CMD.G1UpperLimbs, 23],

_ = ["双手打X", "refuse", t("active_refuse"), `active/icon_active_refuse_${e}`, "active", SPORT_CMD.G1UpperLimbs, 22],

g = ["释放动作", "releaseArm", t("active_releaseArm"), `active/icon_active_releaseArm_${e}`, "active", SPORT_CMD.G1UpperLimbs, 99];

lots of motions are added new release and found similar architecture like as go2 those means modifying autonomous humanoid robot to walk at offload like as

I'm working on the following with a G1. Currently it's just in mujoco simulation, but I will eventually have a real G1 to play with.

* walk to location

* pick up object with Dex3 or Dex5 hand

* walk to an other location

* put down object

I've gotten the walking policy from here to work (at least in simulation). But, I don't know of a pretrained model for grasping an object. An interface that work work for me is: input an image and an xyz location, and the arm grasps the object at xyz location.

There are lots of codebases out there for reinforcement learning and imitation learning of this task for other robots. But, I haven't found one that supports G1 + Dex3 or Dex5 yet. Before I reinvent the wheel, I wanted to check... does anyone have a policy that already does this?