Latest / Embodied AI 101 / GraspGen-X: A Foundation Model for Zero-Shot 6-DoF Grasping
Transcript
- GraspGen-X: A Foundation Model for Zero-Shot 6-DoF Grasping. Imagine a robot gripper that can seamlessly adapt to a new arm it has never seen before, and still pick up objects it’s never encountered—without any special training. This is precisely the promise of GraspGen-X, a new “foundation model” for robotic grasping unveiled by NVIDIA Research at CVPR 2026. Drawing on an unprecedented scale of simulation — billions of synthetic grasp trials — GraspGen-X is designed to generalize across embodiments: it can handle different gripper shapes and configurations without needing to train a separate policy for each one. In practical terms, it means a robot equipped with GraspGen-X can be pointed at a brand new object with a brand new gripper and still deliver reliable grasp proposals. In this article, we’ll delve into what GraspGen-X is, why it’s a breakthrough, and how it works. We review the technical ingredients that make it tick – from diffusion-based generative models to clever ways of describing an arbitrary gripper – and we look at what the experiments tell us about its performance. Throughout, we’ll place GraspGen-X in context: how does it compare to prior grasp planning methods, and what new capabilities does a foundation model enable? The goal is to give a clear picture of this research for robotics and ML practitioners: what did the authors actually do, and how might you leverage or extend it in your own work?. The Challenge of General-Purpose Grasping. Grasping is a fundamental manipulation skill for robots. Yet even with decades of research, it remains surprisingly hard to do reliably in complex, unstructured settings. A robot must perceive an object (often from partial sensor data), plan how to approach and close its fingers, and then execute the motion while avoiding collisions — all under uncertainty. Much progress has been made with machine learning: neural networks and reinforcement learning policies can learn grasp strategies for specific scenarios. But those solutions often come with a catch: they tend to be narrowly tuned to a particular robot or gripper. In practice, most learned grasping systems are specialists. If you train a policy for a two-fingered parallel-jaw gripper (very common in industry), that policy learns how to use exactly those two fingers and that exact geometry. If you put on a different gripper — say a suction cup or a three-fingered hand — the model usually fails. In order to handle a new gripper, you normally have to collect new training data or fine-tune the model. This “per-gripper training” cycle is a major bottleneck. The NVIDIA blog introducing GraspGen-X notes that “most AI systems for robotic grasping are specialists” and that companies typically pick one gripper and stick to it because re-training per gripper is costly. The dream of a generalist grasp model is an attractive one: a single system that, given the geometry of a fresh gripper and an unknown object, can compute good grasps without additional training. This concept parallels ideas from other domains: for example, a large language model (LLM) can often handle a new language or task zero-shot because it learned broad patterns of text. Similarly, a “foundation model” for grasping would have an internalized understanding of how geometry and contact relate, which could transfer to novel hardware. GraspGen-X steps toward that dream. NVIDIA calls it “the first foundation model for zero-shot grasping”. The claim is that it was trained once, on a vast synthetic dataset, and can then propose grasps out-of-box for previously unseen grippers. If true, this is a significant shift. Instead of many smaller models each tied to a specific robot, we have one big model conditioned on the gripper shape. Robot makers could simply feed in a description of their new gripper and immediately start getting grasp proposals, rather than collecting new grasp examples or running expensive RL. This generalization is achieved through scale and architecture design. The researchers generated on the order of two billion simulated grasp examples — an amount of data impossible to gather in the real world. They also reimagined the grasp generation model so that it doesn’t just take an object as input but also a descriptor of the gripper. A key trick they introduce is a swept-volume representation of the gripper (we’ll explain what that means below), which allows the machine learning model to reason about the geometry of whatever gripper it’s given. Before diving into the specifics of how GraspGen-X works, let’s step back and review some background: how have people been generating 6-DoF grasps with learning methods, and what is a diffusion generative model for grasping?. Generating 6-DoF Grasps with Learning. At a high level, generating a 6-DoF grasp means specifying a rigid-body pose (position and orientation) of the gripper in space, such that when the gripper moves to that pose and closes, it makes a stable grasp on the object. 6-DoF means the gripper can be oriented arbitrarily (unlike simpler 2D or 4-DoF grasping that might constrain orientation). This high-dimensional output (six dimensions) makes the problem challenging. One straightforward approach to grasp generation is analytic methods (e.g. force closure grasp synthesis, optimization). Those can work well for simple tasks but often struggle with real sensor noise, complex objects, and advanced gripper shapes. Learning-based methods augment or replace those: they learn from data which grasps tend to work. Historically, many learning approaches rendered grasp planning as a classification or regression problem. For instance, a body of work built neural networks to evaluate candidate grasps (like an image patch or 6-DoF pose) and predict if they are successful or not. One would sample many grasp hypotheses, score them, and pick the best. Others build a network that directly regresses to a promising grasp from an input observation. Most of these machine learning models were trained on examples (real or simulated) for a fixed gripper type and potentially a fixed object set. The last few years, researchers have introduced generative models to the grasping problem. These models aim to generate (sample) grasps directly from a distribution, rather than evaluating one hypothesis at a time. A notable line of work is diffusion models for grasp synthesis. A diffusion model is a type of deep generative model that gradually transforms noise into a desired sample through an iterative denoising process. In computer vision, diffusion models have become popular for image generation (like DALL-E 2, Stable Diffusion). For robotic grasps, the idea is analogous: start with random noise in the space of 6-DoF grasps, and iteratively refine it until you get plausible grasp poses that align with the observed object shape. One of the first systems to use diffusion for grasps was NVidia’s own GraspGen (earlier work by some of the same authors). GraspGen (Murali et al., 2025) treated grasp generation as an “iterative Denoising Diffusion Probabilistic Model” (DDPM) process. Technically, GraspGen trained a neural network that, at each denoising step, takes a noisy grasp and the object’s point cloud and predicts a slightly cleaner grasp. Repeated many times, this yields many candidate grasps for the object. To pick the best ones, GraspGen also used a learned discriminator to score and rank the grasps on the fly. The outcome was a system that could generate diverse and high-quality grasp candidates faster than previous methods, reaching real-time speeds (around 20 Hz inference) and outperforming older approaches on benchmarks. Crucially, however, GraspGen was still somewhat specialized. It was trained to handle three different gripper types (two-finger pinch, and two forms of suction), but that was still a fixed set. If you changed the gripper shape beyond what it saw, it wouldn’t know what to do. The model itself accepted as input the object point cloud and (for the suction case) the suction point, but not a flexible description of any arbitrary gripper. In practice, one would train separate models or separate heads for each gripper type. By contrast, GraspGen-X is built to condition on the gripper description, so that a single model can, at inference time, accommodate unseen grippers. Conceptually, you can think of it as extending the diffusion model in GraspGen with an extra input channel carrying gripper geometry information. This way, the model’s joint distribution is over “(gripper, object, grasp)” triples, whereas before it was only “(object, grasp)” or “(object, grasp, [few known grippers])”. That’s why the authors call it “cross-embodiment” grasping – the ability to span across different embodiments (gripper shapes). In summary, before we look at the new model: Grasping policy networks have traditionally been per-embodiment, but diffusion models like GraspGen introduced a powerful generative approach for fixed gripper scenarios. GraspGen-X builds on this by adding the gripper geometry as part of the generative model, enabling zero-shot generalization to new grippers. Building a Massive Grasping Dataset. One of the hardest parts of making a foundation model is getting enough training data. The hallmark of a foundation model — whether in vision, language, or here in robotics — is typically a huge dataset that covers a wide diversity of inputs. For language models, that’s text from all over the internet; for images, billions of pictures. For grasping, however, collecting real-world data at that scale is effectively impossible. You’d have to program robots for billions of episodes across thousands of grippers, objects, and conditions. NVIDIA’s solution: simulation at scale. The GraspGen-X team generated on the order of two billion simulated grasp examples. In their press materials, they emphasize how this dataset “would be impossible to collect in the real world”. It consisted of “2 billion simulated grasps across thousands of object shapes and synthetic gripper configurations”. In other words, not only did they simulate a very large number of grasps, but they did so on a wide variety of objects and simulated grippers. We don’t have a detailed breakdown of exactly how they generated all these data, but we can infer the likely approach. Modern robotics simulators (NVIDIA has its Isaac Sim platform) can sample random poses and joint configurations, and check grasp stability with physics. They probably took a large database of 3D object models (maybe including existing datasets like ShapeNet or other repositories, as well as procedurally generated shapes) and a library of gripper designs. They mention “procedural grippers” in the abstract, which suggests they programmatically created or parametrized many gripper geometries (for example, varying finger lengths, shapes, number of fingers, suction cup sizes, etc.). Each gripper shape would come along with some kinematic configuration (how it opens/closes) and an initial pose relative to an object. For each (object, gripper) pair, a data-collection pipeline would sample many candidate grasps: e.g. for a parallel-jaw, different approaches around the object; for a suction, different contact points; for a multi-finger hand, different ways to close on the object. The simulator would test if the physics leads to a successful grasp (i.e., object held when lifting). All this results in labeled grasp examples (successful or not, plus grasp pose data). Repeating this across say tens of thousands of objects and thousands of grippers — with perhaps millions of configurations each — could clearly generate billions of examples. NVIDIA has a repository called GraspDataGen (mentioned in connection with their ICRA 2026 acceptance in a GraspGen GitHub readme), which likely contains tools for exactly this kind of data generation. This suggests they built on that platform to crank out data. In summary, the dataset is synthetic but vast: billions of grasps covering diverse shapes. This approach echoes what has been done in other robotics domains: for example, the ACRONYM dataset in 2020 provided ~1.7 million grasps from simulation for a single gripper and around 8,840 objects. GraspGen took that to ~50 million grasps with multiple grippers. GraspGen-X pushes it further by two orders of magnitude to ~2,000 million grasps and explicitly targeting “cross-embodiment” diversity. By training on such a massive dataset, the model can learn very general patterns: how various gripper shapes interact with various object geometries in simulation. It’s akin to how very large vision models learn from internet images; here, the model learns from “internet-scale” synthetic grasp experiences. This breadth of data is crucial to the zero-shot claim: if the model has seen an enormous variety of scenarios, with clever data generation it can hopefully interpolate to a new gripper or object it hasn’t literally seen before. We can cite the NVIDIA blog for this: it explicitly notes the scale and scope of the data collection — “2 billion simulated grasps, thousands of object shapes and synthetic gripper configurations” — and calls out that this was necessary to create a foundation model for grasping. The blog emphasizes that this scale was impossible with real robots, underscoring the synthetic strategy. The GraspGen-X Model: Diffusion Meets Gripper Geometry. With data in hand, the next question is architecture: how does GraspGen-X turn object and gripper data into grasp proposals? The high-level answer is that it extends the diffusion-based framework of GraspGen to include gripper information. Let’s break down the components. Input encoding. The model needs to know about the object and the gripper. For the object, typically such grasp models use a 3D representation — often a point cloud or voxel grid of its geometry. We don’t have a full detail here, but given the authors’ past work, it’s likely they use an object point cloud or mesh as input, representing the object’s geometry in 3D space. This captures what part of the object is where, which is crucial for planning a grasp. (In partial-observability scenarios, they might take partial depth scans, but even that is possible; the blog doesn’t emphasize that, so maybe it assumes fairly complete object models or a good point cloud.). For the gripper geometry, GraspGen-X does something clever: it computes a swept-volume encoding of the gripper. What does that mean? Intuitively, imagine moving the gripper’s fingers (or suction surface) from their fully open pose to their fully closed pose. The union of all points that any part of the gripper sweeps through is the swept volume of the motion. This volume captures the full spatial footprint of the gripper’s closing action. By encoding this volume somehow, the model gets information about the gripper’s shape, size, and reach. Why is this useful? A new gripper can be arbitrarily shaped, so we need a representation that our network can handle. One naive option would be to feed the raw mesh or joint kinematics, but that is complex. The swept-volume summarization is a heuristic that reduces the gripper description to a 3D volume that the network can easily process — it’s basically “fill in the space this gripper spans.” The authors say they introduced a “swept-volume heuristic for encoding the gripper”. They presumably turn that volume into some form like a voxel grid or distance field, or a set of points – sufficient to capture the gripper’s envelope. In effect, then, the model sees something like:. A 3D representation of the object (point cloud, for instance). A 3D representation of the gripper (the swept volume). Possibly other context like a top-down goal (if any), but probably just these. With these inputs, the model’s job is to generate a 6-DoF grasp pose (position and orientation of the gripper relative to the object). Since it uses diffusion, it doesn’t output one guess. Instead, it defines a probabilistic model over grasp poses and samplesが. Diffusion generation. The modern diffusion model approach works roughly as follows: you start with many “samples” of random Gaussian noise in the space of object+grasp+gripper input, and then train a neural net to denoise them step by step into valid triples (object, gripper, grasp) that look like the training data. Concretely, at inference time, you feed in the actual object and gripper of interest, and gradually refine some noise vectors until they align – these become candidate grasps. The network is usually designed so it sees both the conditioning inputs (object, gripper) and a candidate grasp pose (which gradually becomes less noisy). The GraspGen project used a "Diffusion-Transformer" architecture, combining attention layers with positional encodings to process the 3D data and the grasps. GraspGen-X likely continues in that spirit, possibly reusing or extending the same architecture. The novelty mainly is the conditioning on a flexible gripper description. So at each denoising step, the model has to consider not only “what does the object look like?” but also “what does this gripper look like and how can it reach?”. By training on the vast dataset, the model learns the joint relationships: e.g., “I see a wide box and I have a two-finger parallel gripper, so I can produce grasps that pinch opposite sides of the box; but if I had a suction cup, I would use a flat surface grasp.”. There is typically also a discriminator or scoring network in these systems. In GraspGen, after sampling many grasps by diffusion, they ran them through a discriminator to rank which ones are best. GraspGen-X likely keeps a similar mechanism, although details aren’t spelled out in the summaries. The result is a ranked set of grasp proposals. The key outcome is that the model is zero-shot for new grippers. That is, it can take as input the geometry of a grip it never saw in training, and still produce grasps. The blog and abstract claim that in simulation, GraspGen-X achieves “the best zero-shot generalization to novel real-world grippers and objects over baseline methods”. The phrasing “novel real-world grippers” suggests they tested on some real gripper geometries in simulation (like actual hardware prototypes), and it worked better than alternatives. Part of the magic is that the diffusion framework is quite flexible: by giving it the right conditional signal (the gripper rep), it can adapt its generated poses. A couple more subtleties: The model can also serve as a starting point for fine-tuning. The summary notes that “our model also serves as a good initialization for fine-tuning to adapt to novel grippers”. In practice, if you do have a specific new gripper and you want even better performance than zero-shot, you can take the foundation model and do a bit of extra training on a small set of grasps for that gripper (in simulation or real). The pre-trained model’s weights already encode lots of geometry knowledge, so it fine-tunes faster than learning from scratch. This transfer learning aspect fits the “foundation model” paradigm, where we expect a base model to accelerate downstream specialization. Zero-Shot Performance: Outperforming the Competition. What do the experiments show? Although we don’t have the paper’s exact results, the authors’ claims give us the gist. In simulation, GraspGen-X “surpasses baselines in cross-embodiment generalization”. This presumably means they compared against other grasp-generation systems under a scenario where the gripper is different at test time. Baseline methods might include: a diffusion model trained on only a single gripper (then tested on another, where it should fail), or a multi-gripper model without conditioning (which might collapse to something less flexible), or even older non-diffusion methods. GraspGen-X beats them on accuracy of grasp success predicted. They also report that GraspGen-X can generalize to real-world grippers in simulation. That hint suggests they took CAD models of actual grippers (or real prototypes) that were not in the training set, encoded them with the swept-volume representation, and ran the model. It still produced viable grasps, whereas presumably the baselines did worse. These test grippers are likely things like a new two-finger design or a different seven-finger hand, etc. The fact they emphasize real-world implies they tried to bridge simulation-to-hardware, or at least use realistic models. In practical terms, this likely translates to metrics like “success rate of the top N predicted grasps on a set of test objects, using a new gripper.” (Details aside, the blog says it’s the best zero-shot, so one assumes error bars or success rates were higher.) And then beyond just generating grasps, they combined it with a CUDA-accelerated trajectory planner (CuroboV2) to actually move a robot arm to those grasps in unknown scenes. So they have at least a demonstration pipeline from perception to motion to grasp execution, showing it in some form of robot or simulation. One important nuance: The performance is likely measured as comparisons of quality of proposed grasps, not as how fast or cheap the model is to run. The original GraspGen model was already quite efficient (20 Hz, 21x less memory than previous work). GraspGen-X might be heavier because it conditions on more input, but it might still be real-time or near real-time, since it is intended to be used on robot hardware. The NV blog doesn’t comment on speed, but the emphasis on “foundation model” implies that inference speed wasn’t sacrificed. In any case, the big story is generality, not micro-optimizations. We should mention the model is meant to run on real robots: the blog highlights that it can be “applied out of the box” with common grippers, suggesting it’s ready-to-use. Finally, it’s worth noting what tasks this enables. With GraspGen-X in hand, a robot company or researcher could swap hardware or add new grippers without retraining grasp policies. For example, a logistics robot could choose the best end-effector (maybe a large gripper for pallets vs a small one for envelopes) and not worry about re-collecting data. Or one could have a system that auto-calibrates to an unknown gripper by scanning its shape and plugging it into GraspGen-X. It truly makes grasping “plug-and-play.” This mirrors how LLMs allowed “zero-shot” use on new text tasks; here it’s “zero-shot grasping on new hardware.”. And because it’s a “foundation” in the sense of large-scale training, you can still specialize further. The authors note that you can fine-tune for a new gripper if you want to squeeze out extra performance, and the model is a good starting point for that. But if you don’t have that option or want to save time, you can use it as-is. That flexibility is valuable: one can spin up a general model immediately, then refine it as needed. Putting It All Together: How does GraspGen-X Work?. Let’s summarize the GraspGen-X pipeline in practical terms, and highlight the key innovations:. Synthetic Data Generation: The team uses a physics simulator (likely NVIDIA Isaac Sim) to create a colossal dataset. They programmatically define many gripper morphologies (“procedural grippers”), and pair them with thousands of object shapes. For each gripper-object pair, they simulate billions of candidate grasps (possibly sampling contact points, approach directions, etc.) and record which ones would succeed. The result is on the order of 2 billion labeled grasps. This scale of data provides the raw material for a foundation model. Gripper Representation: To let the learning algorithm understand “what the gripper is,” they compute a swept-volume encoding for each gripper shape. Imagine virtually closing the gripper from open to closed; the volume swept by the gripper’s fingers or surfaces is computed (e.g. as a voxel occupancy grid or distance transform). This volumetric descriptor captures the reach and geometry of the gripper. It’s a compact way to feed arbitrary gripper shapes into a network. (This idea — the volume traced by closing motion — is a heuristic, but apparently an effective one according to the authors.). Model Architecture: The core model is a 6-DoF diffusion-based generator. During training, the network learns to turn noisy grasp proposals into cleaner ones, conditioned on the input object point cloud and the swept-volume of the gripper. Conceptually, a training example is (point cloud of object, representation of gripper, successful grasp pose). The diffusion network is trained to move a pose solution from random noise towards a valid grasp given that context. The exact architecture likely mirrors earlier work: a transformer or attention-based network that handles the 3D inputs and outputs adjustments to poses. A paired discriminator network is trained alongside (or as a second stage) to score and rank candidate grasps. This ensures that the final outputs are not just possible grasps, but high-quality ones. Zero-Shot Inference: At test time, to grasp a new object with a new gripper, one first obtains the object’s geometry (e.g. via a depth sensor or known mesh). Then compute the swept-volume of the gripper geometry (this is an offline step, since the gripper geometry is known). Feed both into the model. Initialize some random pose hypotheses and run the diffusion process (for example, start with Gaussian noise in pose space and iterate a fixed number of steps). Each output from one diffusion chain is a 6-DoF grasp candidate. Run several of these chains in parallel to get multiple proposals, then feed them through the discriminator to pick the best few. The result is a small set of grasp poses tailored for that specific gripper and object, even if the gripper was never seen during training. One can then use a separate motion planner (like CuroboV2) to execute the chosen grasp in the actual robot. Fine-Tuning (Optional): If extra performance is needed for a particular new gripper, one can take the base model and train it further on a smaller grasp dataset involving that gripper. Because the model already has encoded general grasping knowledge, it adapts faster than a model trained from scratch. This is a classic “fine-tune a foundation model” approach. Throughout this process, the model’s innovation is in conditioning on the gripper. Previously, you’d have to rebuild or re-train a separate net for each new gripper. GraspGen-X internalizes the idea that a gripper is just another part of the input space. The “swept-volume” trick is an engineering solution to give a unified representation. The expectation is that if you give it any physically plausible gripper shape, it will automatically handle it. Significance and Future Directions. Why does GraspGen-X matter? The headline is definitely the leap toward generalization. For robotics libraries and practitioners, it could mean:. Rapid Deployment: You plug in a new hardware design, and out-of-the-box, you get grasp proposals. This could drastically cut down the development cycle for new robots or new end effectors. Multi-Robot Systems: In scenarios where multiple robots with different hands need to solve a task collectively, a single model could manage all their grasps rather than needing separate policies. Robustness: The model has seen a wider variety of data, so it may be more robust to odd shapes or sensor noise than a narrowly trained model. Foundation Paradigm: This is a milestone in the broader trend of foundation models in robotics. Just as large image or language models are used as building blocks, a grasp foundation model could be one. It lowers the barrier to entry for advanced grasping tech. Integration with Control: The blog hints that GraspGen-X is step in a pipeline. Following grasp generation, you still need motion planning and control to execute the grasp. NVIDIA mentions “Grasp-MPC” as follow-up work for closed-loop execution. In practice, GraspGen-X could be one component: the perception-to-pose piece. Coupled with fast planning (CuroboV2) and possibly tactile or vision-based feedback, it could enable a full grab pipeline. Of course, there are limitations to keep in mind:. Real-World Reality Gap: The model was trained on simulation data, albeit diverse. How well it transfers to the real world depends on how realistic the simulation is, and how much noise or calibration error exists. The blog claims zero-shot on real-world grippers (in sim), but it’s not clear if they actually ran the network on a live robot with a new hand. That would be the ultimate test. Sometimes grasp networks do surprisingly well sim-to-real, especially if they see sufficient variability in shapes. Task Constraints: GraspGen-X focuses on single-object grasp synthesis. It’s not clear how it would handle cluttered scenes or task-oriented constraints (e.g. “grasp the mug by the handle”). It might handle clutter as long as the object segmentation is separate, but it is not explicitly a semantic or language-driven model. It's a direct geometric planner. Gripper Diversity: It likely generalizes best to gripper shapes that can be meaningfully encoded by the swept volume. Completely exotic grippers (e.g., multi-finger dexterous hands with finger degrees of freedom) might be a stretch if the model mainly saw simpler grippers. The abstraction may break down for very high-dof hands or soft grippers, but for many standard grippers (parallel jaws, suction, simple multi-finger tools), it should work well. Compute: Running a diffusion model requires some computation. The blog doesn’t mention hardware, but NVIDIA would presumably target GPU acceleration. The fact that they integrate with CUDA planning suggests they might run GraspGen-X on GPUs onboard the robot or a connected station. For high-speed requirements, one would need to profile it, but likely the focus is on quality, not ultra-low latency. Finally, GraspGen-X also sets the stage for future research. It shows that investing in scale and diversity pays off in robotics as it has in other AI domains. Other researchers might build on this with:. More complex tasks (e.g., combining grasping with placement or pushing actions). Language integration (imagine a model that takes both a gripper and a language instruction like “pick up the red cube with the gripper and place it on the shelf”). Applying the cross-embodiment idea to other manipulation skills like in-hand dexterous manipulation, whole-body balancing, etc. Better gripper representations: the swept-volume heuristic might inspire other learned encodings (maybe a network that auto-encodes gripper meshes, etc.). Scaling beyond grasps to whole pick-and-place pipelines. In the immediate term, roboticists interested in grasping should look at GraspGen-X as a new baseline: it sets a high bar for zero-shot performance. It also illustrates a general recipe for robotics: if you can simulate massively and devise a way to encode the embodiment, you might train a single powerful model instead of many separate ones. Conclusion. GraspGen-X is a step toward more generalist robot manipulation. By training on billions of simulated grasp examples and designing a model that understands arbitrary gripper shapes, NVIDIA’s team has created a grasping “foundation model” that doesn’t need retraining for each new hardware. It’s a compelling demonstration of economy of scale: we’re seeing robotics follow the trend of other AI fields, where massive pre-training yields broad capabilities. For practitioners, the takeaway is that future robots might come with a “universal” grasping brain: show it the robot hand and see it work. For researchers, GraspGen-X opens questions about how far we can push this idea. Can we do the same for much more complex manipulators? Or for whole-body tasks? As robotics integrates more with AI advances, the line between language/vision models and physical-action models is blurring. GraspGen-X is one of the first footsteps in that uncharted territory — one that could make our robots both easier to reconfigure and smarter in how they grasp the world. Sources: NVIDIA’s research blog on CVPR 2026, and the NVIDIA Learning & Perception write-up (citing the CVPR submission, briefly summarized on papers.cool). We also reference the earlier GraspGen diffusion grasping framework for background on diffusion-based 6-DoF grasp synthesis. These sources provide the foundation of our understanding of GraspGen-X and its context in the field.