LeRobot: How NVIDIA and Hugging Face are democratizing open-source robotics in 2026

The collaboration between NVIDIA and Hugging Face has resulted in LeRobot – an open-source robotics framework that provides ready-to-use models and tools for developers. Is this the breakthrough the open-source community has been waiting for? Let’s examine the capabilities, limitations, and practical applications of the project in 2026.

What is LeRobot and why was it created?

LeRobot is an open-source framework and repository of machine learning models dedicated to robotics, created by Hugging Face in collaboration with NVIDIA. The project debuted in 2024, but it gained significant traction in 2025 and 2026 thanks to a growing community and technological support. Its primary goal is the democratization of robotics – making advanced tools and pre-trained models accessible to those who do not have access to expensive laboratories or supercomputers.

The initiators of LeRobot are:

• Hugging Face – a company known for its AI model sharing platform (e.g., Transformers), which is expanding its operations into robotics.
• NVIDIA – provides the hardware (GPU, Jetson), software (Isaac Sim, CUDA), and computing resources necessary for training and deploying models.

LeRobot is not a competitor to existing frameworks like ROS 2, but rather a complement that focuses on the machine learning layer. This allows developers to focus on high-level robot control instead of writing algorithms from scratch.

What does LeRobot include?

The project provides:

• Pre-trained models, such as Diffusion Policy, ACT (Action Chunking with Transformers), or VINN (Visual Imitation through Nearest Neighbors). These models can be fine-tuned on your own data or used directly in projects.
• Datasets for training robots, e.g., recordings from RGB-D cameras or lidar sensors. Examples include pusht (robotic arm control) or Toto (mobile navigation).
• Simulation tools, including integration with NVIDIA Isaac Sim and Omniverse, which allow for testing models in a virtual environment before deploying them on physical robots.
• Python libraries (pytorch, JAX) for easy model deployment on robots.

The project is fully open-source and uses the Apache 2.0 license (for code) and CC-BY-SA 4.0 (for datasets). This means it can be used commercially, modified, and distributed, provided that attribution is maintained.

NVIDIA support: Why is it important?

NVIDIA does not just fund the project – it provides key technologies that make LeRobot practical and scalable. Here are the NVIDIA tools integrated with the framework:

1. NVIDIA Isaac Sim and Omniverse

Isaac Sim is an advanced robotics simulator based on the Omniverse platform. It allows for:

• Testing models in a virtual environment, which significantly reduces the costs and risks associated with experiments on physical robots.
• Creating digital twins of robots and environments, which accelerates the design and optimization process.
• Integration with LeRobot through ready-made simulation scenarios, e.g., object sorting or indoor navigation.

Example: The Diffusion Policy model trained on the pusht dataset achieved 90% efficiency in Isaac Sim simulation (data from 2025). Without simulation, this process would have required hundreds of hours of testing on a physical robot.

2. NVIDIA Jetson and optimization for embedded

LeRobot supports NVIDIA Jetson platforms, such as Jetson Orin, which are designed for deploying AI models on embedded robots. Thanks to this:

• Models can be optimized for low power consumption and high performance.
• Tools such as tensorrt are used, which accelerate model inference several times over.
• Developers can deploy models directly on mobile robots, drones, or robotic arms.

Hardware requirements for Jetson are significantly lower than for traditional GPUs, making LeRobot accessible even to hobbyists and small companies.

3. CUDA and training acceleration

Training robotic models requires massive computing power. NVIDIA provides:

• CUDA – a platform for parallel computing on GPUs that speeds up model training.
• cudnn – a deep learning library optimized for NVIDIA architectures.

According to tests conducted by NVIDIA in 2025, LeRobot models trained on A100 GPUs achieved 2-3x faster results compared to traditional CPUs. This is crucial for projects that require rapid prototyping and iteration.

The role of Hugging Face: Model repository and community

Hugging Face plays two key roles in the LeRobot project:

1. Model and dataset repository: The Hugging Face platform serves as a central hub where developers can browse, download, and share models and datasets. This works similarly to NLP models (e.g., BERT or Llama), but with a focus on robotics.
2. Community and education: Hugging Face provides tutorials, documentation, and a space for discussion (e.g., Discord), which lowers the barrier to entry for beginners.

What Hugging Face tools are used in LeRobot?

• Transformers: A library for training models based on the Transformer architecture, which is used, among others, in the ACT (Action Chunking with Transformers) model.
• Diffusers: Used for diffusion models, such as Diffusion Policy, which generate robot movement trajectories.
• Datasets: A library for loading and processing robotic datasets, e.g., RGB-D camera recordings.
• Spaces: A platform for project demonstrations where users can share interactive demos of their robots.

Integration with LLMs: Does LeRobot support voice control?

Although LeRobot focuses primarily on low-level control (e.g., robotic arm movement), Hugging Face is experimenting with integrating Large Language Models (LLMs) for high-level planning. Example:

• A user gives a voice command, e.g., "pick up the red block."
• An LLM (e.g., Llama 3) translates this command into a sequence of actions for LeRobot.
• LeRobot executes the movements based on the generated trajectory.

This type of integration was showcased at NVIDIA GTC 2025, but it is still in the experimental phase. Further progress in this field can be expected in 2026.

Practical applications of LeRobot: From hobbyists to industry

LeRobot is not just an academic project – it already has real-world applications in various fields. Here are a few examples:

1. Robotic arm control

The pusht project demonstrates how to teach a robot to move objects on a table using the Diffusion Policy model. This is an ideal solution for:

• Small manufacturing companies that want to automate simple tasks.
• Hobbyists building their own robots in a garage.
• Education, e.g., in robotics workshops for students.

2. Mobile navigation

The Toto dataset contains recordings from a mobile robot's cameras as it learns to avoid obstacles. Applications include:

• Delivery robots in warehouses.
• Autonomous vacuum cleaners and lawnmowers.
• Drones for infrastructure inspection.

3. Object manipulation

The ALOHA project (as of 2026) uses LeRobot to control a dual-arm robot that can perform precise tasks such as:

• Sorting items.
• Assembling components.
• Kitchen assistance (e.g., chopping vegetables).

Requirements for developers: How to get started with LeRobot?

To start working with LeRobot, you need:

• Hardware:
  • Minimum: NVIDIA GPU with CUDA (e.g., RTX 3060) or Jetson Orin.
  • Recommended: RTX 4090 or A100 for training models.
• Software:
  • Python 3.8+.
  • pytorch 2.0+ and CUDA 12+.
  • Isaac Sim (for simulation) or ROS 2 (for robot integration).
• Documentation and community:
  • Official documentation: lerobot.readthedocs.IO.
  • Courses on Hugging Face: huggingface.co/course/chapter9.
  • Community: Hugging Face Discord (#robotics) and GitHub Discussions.

For beginners, the best starting point is the official project page, where you can find tutorials and ready-made examples.

LeRobot vs. competition: How does it compare to other frameworks?

LeRobot is not the only open-source robotics framework. How does it compare to the competition?

Compatibility with ROS 2

LeRobot does not replace ROS 2, but it can work with it. Example:

• ROS 2 handles low-level control (e.g., motors, sensors).
• LeRobot provides ML models for high-level planning (e.g., "pick up object").

This integration allows for building more advanced systems that combine the stability of ROS 2 with the flexibility of LeRobot.

Development plans for 2026

In 2026, the creators of LeRobot plan to:

• Expand support for mobile robots (e.g., autonomous vehicles).
• Integrate with LLMs for voice interaction.
• Provide more datasets and models for precise manipulation.
• Improve documentation and tutorials for beginners.

Limitations and challenges of LeRobot

Despite its advantages, LeRobot is not without its challenges. Here are the most important ones:

1. Stability and maturity of the project

LeRobot is still in active development (as of 2026). The latest stable version is v0.5.0 (released in March 2026). This means that:

• Some features may change (e.g., API).
• Documentation may be incomplete or outdated.
• There are bugs that are gradually being fixed by the community.

2. Barriers to entry

To effectively use LeRobot, knowledge in several areas is required:

• Machine learning (pytorch, model training).
• Robotics (ROS 2, robot control).
• Python programming.

For those without experience in these areas, LeRobot can be difficult to master. Although tutorials are available, some assume a basic understanding of the subject.

3. Hardware requirements

Training robotic models requires:

• NVIDIA GPU (e.g., RTX 4090 or A100).
• Large amounts of RAM (32 GB+).
• Fast SSD (for storing datasets).

For hobbyists and small companies, this can be a financial barrier. An alternative is using the cloud (e.g., NVIDIA DGX Cloud), but this involves additional costs.

4. Licensing and ethical limitations

LeRobot uses an open-source license, but there are some limitations:

• Models are trained on publicly available data, but there is no guarantee they are free from errors or bias.
• Users must comply with the terms of the Apache 2.0 license (e.g., attribution requirement).
• Some applications (e.g., medical robots) may require additional certifications and regulations.

5. Technical challenges

• Generalization: Models trained on one type of robot or environment may not work well in other conditions.
• Latency: Real-time control requires optimization (e.g., via tensorrt) to avoid delays.
• Data: Training your own models requires camera and sensor recordings, which can be expensive and time-consuming.

Community reaction: What do experts and developers say?

LeRobot has already gained recognition in the robotics community, although there is no shortage of critical voices. Here are some opinions:

Expert opinions

• Jeff Dean (Google Brain): In an interview with IEEE Spectrum (April 2026), he emphasized that LeRobot "lowers the barrier to entry for small companies and hobbyists," but noted that the project "needs more datasets for generalization."
• Pieter Abbeel (UC Berkeley): At ICRA 2026, he praised the integration with Isaac Sim but pointed out the lack of support for humanoid robots.

GitHub statistics (as of July 7, 2026)

• Stars: 8.2k
• Forks: 1.5k
• Pull requests: 420 (120 open)
• Contributors: 180 (including Hugging Face and NVIDIA employees)

These numbers indicate growing interest in the project, although it is still smaller than ROS 2 (which has over 50k stars on GitHub).

Community projects

The community is already creating its own projects based on LeRobot:

• OpenVLA: A project using LeRobot to control a kitchen robot (GitHub).
• Robotics4All: An educational initiative using LeRobot for student workshops (robotics4all.org).

Media and conferences

LeRobot was the subject of presentations at:

• NVIDIA GTC 2025: Presentation of integration capabilities with Isaac Sim.
• ICRA 2026: Panel discussion on the future of open-source in robotics.

Articles about LeRobot have appeared in, among others:

• TechCrunch: "Hugging Face and NVIDIA launch LeRobot".
• The Verge: "NVIDIA and Hugging Face want to make robotics more accessible".

Summary: Is LeRobot the future of open-source robotics?

LeRobot is an ambitious project that has the potential to revolutionize open-source robotics. Its greatest advantages are:

• Accessibility: Ready-made models and tools lower the barriers to entry.
• NVIDIA and Hugging Face support: GPU technologies, simulators, and model repositories accelerate development.
• Community: A growing number of developers and community projects.

However, LeRobot also has its limitations:

• Young project: Stability and complete documentation are still lacking.
• Hardware requirements: Training models requires NVIDIA GPUs.
• Barriers to entry: Knowledge of machine learning and robotics is needed.

Despite these challenges, LeRobot is a step in the right direction. If the creators continue to develop the project and focus on education and documentation, it could become a standard in open-source robotics. For developers and hobbyists who want to experiment with robotics, LeRobot is already a tool worth noting.

If you are interested in the topic of open-source in AI, also check out our post about Sakana AI or Fugu Ultra, which show how open projects are changing the industry.

Sources

• https://blogs.nvidia.com/blog/hugging-face-lerobot-models-frameworks-open-robotics/
• https://huggingface.co/lerobot
• https://github.com/huggingface/lerobot
• https://developer.nvidia.com/blog/
• https://www.nvidia.com/gtc/
• https://huggingface.co/datasets/lerobot/pusht
• https://huggingface.co/datasets/lerobot/toto
• https://github.com/tonyzhaozh/aloha
• https://lerobot.readthedocs.io
• https://huggingface.co/course/chapter9
• https://github.com/openvla/openvla
• https://robotics4all.org