Unitree IPO: o stack de software que sustenta robôs humanoides

A chinesa Unitree — conhecida também como Yushu Technology — acaba de abrir capital na Bolsa de Xangai avaliada em cerca de US$ 9 bilhões, segundo reportagem do Olhardigital.com.br. É a primeira fabricante de robôs humanoides a estrear no mercado acionário continental chinês, e isso diz muito sobre onde a indústria de robótica está indo. Mais do que o número em si, o que me interessa como desenvolvedor é o que essa avaliação revela: existe um mercado real, com software real, sustentando esses bonecos de metal que aparecem dançando no YouTube.

Por que essa IPO me chamou atenção como dev

Quando vi os números — receita que mais que quadruplicou no último ano, robôs humanoides virando o produto principal com 867,8 milhões de yuans em vendas —, a primeira coisa que pensei não foi no hardware. Pensei no software stack que sustenta isso. Robôs humanoides não são hardware com um firmware jogado: eles rodam pilhas inteiras de software que vão de controle de motores em tempo real até modelos de visão computacional e políticas de aprendizado por reforço.

A Unitree não está sozinha nesse IPO da robótica. A DeepSeek — empresa chinesa de IA que viralizou no início de 2025 com modelos competitivos ao GPT-4 a um custo de treinamento muito menor — está entre os investidores estratégicos da oferta. Isso me diz algo importante: o futuro da robótica humanoide está intimamente ligado ao progresso dos modelos de IA. Não é coincidência que o maior comprador de GPUs do mundo (a NVIDIA) tenha toda uma divisão de robótica, ou que o Figure AI tenha captado dinheiro pesado da OpenAI.

O stack tecnológico por trás de um robô humanoide

Se você nunca colocou a mão num SDK de robótica, talvez imagine que o software é “misterioso”. Não é. A Unitree, por exemplo, mantém o unitree_sdk2 aberto no GitHub, escrito majoritariamente em C++ com bindings para Python. A comunicação usa CycloneDDS — uma implementação open-source do protocolo DDS (Data Distribution Service) —, o que permite trocar mensagens em tempo real entre processos com latência determinística.

Na prática, o robô expõe uma série de “tópicos” DDS por onde você lê estado (posição das juntas, IMU, dados de câmeras de profundidade) e escreve comandos (velocidade, torque, posições alvo). É o mesmo paradigma publish/subscribe que devs de backend conhecem do RabbitMQ ou do Kafka, só que otimizado para garantir entrega em microssegundos.

Acima dessa camada de comunicação, o que roda é o que importa:

• Estimador de estado: fusão sensorial via filtro de Kalman estendido (EKF) ou, mais recentemente, filtros de partículas para casos não-lineares.
• Controlador de baixo nível: loops PID ou MPC (Model Predictive Control) rodando a 1 kHz em cada junta.
• Planejamento de movimento: algoritmos de locomoção inteira do corpo (whole-body control) que decidem como cada uma das 30+ articulações deve se mover para manter o equilíbrio.
• Política de alto nível: hoje, cada vez mais, modelos de aprendizado por reforço ou modelos de visão-linguagem-ação (VLA) que recebem imagem da câmera e comando textual e devolvem a próxima ação.

Unitree vs. concorrentes: comparativo honesto

Vale colocar a Unitree no mapa contra os principais players:

Na minha experiência com APIs e SDKs de hardware, a vantagem competitiva real da Unitree está exatamente na abertura do SDK. Quando o software é fechado, a curva de aprendizado explode e o ecossistema trava. Foi assim com ROS1 vs ROS2, foi assim com Android vs iOS em certas camadas. Um SDK aberto significa que devs podem escrever módulos próprios, criar tutoriais, construir bibliotecas — e isso acelera a maturação do produto de um jeito que dinheiro puro não alcança.

Na Prática: integrando com o SDK da Unitree

Para você ter uma ideia do trabalho real com um robô humanoide, veja um exemplo funcional em Python usando o padrão do SDK2. O código abaixo se conecta ao robô via DDS, lê o estado das juntas e envia um comando simples de posição:

# pip install unitree_sdk2py
import time
from unitree_sdk2py.core.channel import ChannelSubscriber, ChannelFactoryInitialize
from unitree_sdk2py.idl.default import unitree_hg_msg_dds__LowState_
from unitree_sdk2py.idl.unitree_hg.msg.dds_ import LowCmd_

# Inicializa o canal DDS (ajuste o domínio se necessário)
ChannelFactoryInitialize(0, "eth0")

# Subscriber: lê o estado completo do robô em ~1kHz
state_sub = ChannelSubscriber("rt/lowstate", LowState_)
state_sub.Init()

# Publisher: envia comandos de baixa nível
cmd_pub = ChannelPublisher("rt/lowcmd", LowCmd_)
cmd_pub.Init()

def mover_juntas(target_positions, duration=2.0):
    """Interpolação linear simples até a posição alvo."""
    state = state_sub.Read()
    if state is None:
        print("Sem estado ainda, ignorando...")
        return

    start = [m.q for m in state.motor_state[:12]]
    steps = int(duration * 50)  # 50Hz de envio

    for step in range(steps):
        alpha = (step + 1) / steps
        cmd = LowCmd_()
        for i in range(12):
            cmd.motor_cmd[i].q = start[i] + alpha * (target_positions[i] - start[i])
            cmd.motor_cmd[i].dq = 0.0
            cmd.motor_cmd[i].kp = 80.0   # ganho proporcional
            cmd.motor_cmd[i].kd = 2.0    # ganho derivativo
            cmd.motor_cmd[i].tau = 0.0
        cmd_pub.Write(cmd)
        time.sleep(0.02)

# Exemplo: levantar o braço direito
alvo = [0.0] * 12
alvo[4] = 0.5   # ombro
alvo[5] = -0.3  # cotovelo
mover_juntas(alvo)

Esse é o “Hello, World” da robótica humanoide. Parece simples, mas note três coisas que devs de software tradicional esquecem: controle é em tempo real (atraso de 20ms aqui é luxo; em produção queremos abaixo de 1ms), ganhos PID errados podem fritar o motor ou mandar o robô ao chão, e toda comunicação assume que a rede pode falhar — por isso o protocolo DDS tem QoS configurável. Se você vem de APIs REST, esse choque de paradigma é o primeiro obstáculo.

Erros Comuns (e como evitá-los)

O que evitar ao começar com robótica humanoide

• Tratar o robô como se fosse um servidor HTTP. A maior parte dos bugs em projetos de robótica vem de quem tenta abstrair tudo em requisições síncronas. Não funciona. Latência variável mata controle.
• Ignorar a calibração do IMU. Sem calibração correta, o filtro de Kalman recebe dados viesados e o robô compensa errado. Parece problema de hardware, mas é problema de software na maioria das vezes.
• Hardcodar posições de juntas. Cada unidade tem pequenas variações mecânicas. Use offsets de calibração por instância, não valores mágicos.
• Subir tudo em GPU e esquecer do determinismo temporal. Modelos de IA no loop de controle precisam rodar em taxa fixa. Se o inferência pula de 30ms para 80ms porque a GPU esquentou, o robô cai.
• Não versionar as políticas de RL. Quando você treina uma política nova e o robô começa a se comportar de forma estranha, você precisa de rollback. Git + MLOps, igual a qualquer modelo em produção.

O que muda para nós, devs, com essa IPO

Avaliação de US$ 9 bilhões significa que existe um mercado pagador — e isso muda a equação de carreira. Robótica humanoide deixou de ser projeto de PhD em laboratório japonês e virou vertical de investimento. Isso traz três consequências práticas para quem programa:

1. Mais vagas: empresas vão precisar de engenheiros de controle, vision engineers, engenheiros de ML embarcado e integradores. É um perfil raro no Brasil e bem pago no exterior.
2. Mais bibliotecas maduras: dinheiro entrando no setor significa mais gente mantendo os SDKs, mais documentação, mais exemplos — exatamente o que aconteceu com PyTorch depois que a Meta abriu o código.
3. Mais concorrência geopolítica: a própria reportagem do Olhardigital.com.br lembra que controles de exportação e restrições comerciais podem travar a expansão da Unitree fora da China. Para o dev, isso significa trabalhar com fornecedores duplicados e considerar arquiteturas que não dependam de um único hardware vendor.

FAQ — Perguntas que devs realmente fazem

Preciso de hardware caro para começar a estudar robótica humanoide?

Não. Simule. O Mujoco (agora da DeepMind) e o Isaac Gym da NVIDIA são gratuitos para uso acadêmico e rodam políticas de RL completas em GPU. Quando você precisar do robô real, a Unitree oferece o G1 a partir de cerca de US$ 16 mil — caro, mas viável para labs.

ROS ainda é relevante em 2026?

ROS2, sim. O ROS1 foi descontinuado. Hoje, quem está sério em produção roda ROS2 Humble ou Jazzy, com middleware DDS. É o padrão de fato, embora alguns fabricantes (incluindo a Unitree em parte do stack) prefiram suas próprias camadas por questão de performance.

Vale aprender reinforcement learning agora?

Na minha experiência, sim — mas não no vácuo. RL puro é legal em pesquisa, mas o que está chegando em produção é a combinação RL + imitation learning + LLMs como planejador de alto nível. Comece pelo Stable Baselines3 ou CleanRL, entenda os fundamentos, depois vá para Isaac Lab.

Os robôs da Unitree são mesmo bons ou é só marketing?

Os vídeos de dança e artes marciais não são truque de edição — o controle de locomoção deles é genuinamente bom. Onde ainda há espaço para melhorar (e onde devs podem contribuir) é na robustez da manipulação e na generalização de políticas a ambientes novos.

A IPO afeta o preço dos robôs?

Não diretamente no curto prazo. Mas a captação de 6,1 bilhões de yuans que a Unitree levantou vai para expansão de capacidade industrial — e capacidade maior historicamente pressiona preços para baixo. Nos próximos dois anos, espere humanoides mais baratos.

Gostou? Me segue no GitHub e deixa um comentário se tiver dúvida ou quiser aprofundar algum ponto.