NVIDIA Corporation

How NVIDIA’s open humanoid stack uses relative actions, embodiment mapping, and human video to turn motion into a shared language across very different machines.

A hybrid security pipeline for agent-era supply chains, where static rules catch the obvious and LLM analysis catches the mismatch between promise and behavior.

A deep look at how NVIDIA split high-performance RTX inference out of the monolith, using ORT’s EP ABI, adaptive JIT compilation, and GPU memory tricks to make desktop deployment feel surprisingly modular.

A meta-repo that shows how NVIDIA is rethinking functions, tasks, autoscaling, and observability for GPU workloads that are too heavy for ordinary serverless systems.

How a USD-based standard turns 3D assets into simulation-ready contracts, catches physics bugs before runtime, and tries to end the chaos of incompatible units, joints, and runtimes.

A deep look at the MCP bridge, agent skills, and industrial-grade monorepo that turn a web component library into a harness for humans and LLMs alike.

A look at how NVFlow turns synthetic data, fine-tuning, and cluster execution into reusable workflows that speak NeMo and Slurm natively.

Replica expansion, late-bound expressions, readiness probes, and GPU-aware placement turn static workflow files into a runtime graph for HPC and LLM inference.

A catalog of portable agent skills, schema checks, signatures, and plugin bundles shows how NVIDIA is standardizing what coding agents know, how they run, and what they are allowed to trust.

NVIDIA's comfy_nv_video_prep turns masks, crops, and keyframes into portable workflow state, so video prep happens before generation instead of after it.

OpenShell keeps credentials, policy, and audit logging outside the sandbox, so autonomous code can act without owning the keys.

NVIDIA’s ALCHEMI toolkit treats atomistic simulation as a live pipeline, with inflight batching, composable stages, and model wrappers that keep GPU work flowing.

A geometry-aware system for recovering camera pose, synthesizing consistent novel views, and lifting them into Gaussian splats for simulation.

A zero-dependency Isaac Lab dashboard uses manifest-driven JSON, Git LFS, Chart.js, and preview images to turn benchmark runs into a browsable, versioned record.

NVIDIA’s community repo packages sandboxes, skills, and bootstrap tooling around a sharper idea of AI safety: constrain the runtime, not the prompt.

Inside NVIDIA’s open-source retargeting pipeline, where a standardized human skeleton, GPU-accelerated IK, and foot stabilization turn BVH motion into robot-ready joint data.

How an adversarial testing engine and hardware clock-locking force AI code generators to compete against the absolute limits of silicon.

How NVIDIA built a multi-stage Python and Go pipeline to generate valid OpenTelemetry configurations for GPU serverless workloads.

How a Python control plane creates a programmable digital twin to orchestrate raw NVMe hardware and resolve kernel-level split-brain.

Inside the BMC logic that sequences power rails, watches for failure states, and adapts to NVIDIA hardware through configuration instead of hardcoded assumptions.

How a clever Python DSL and a Pydantic-powered compiler reverse the modern data stack to process petabytes of climate data exactly where it lives.

How a strict power-of-two compiler abstraction and an open-source MLIR dialect are replacing manual thread management for AI workloads.

How a massive C-API orchestrates the shift from traditional rasterization to hardware-accelerated neural rendering.

A deep dive into the stack that wraps OpenClaw in OpenShell, layers declarative policy on top, and turns autonomous assistants into operator-contained workloads.