Foundation welcomes Clockwork.io, Emmi AI, NIPA, Nota AI., Yasp, CommonAI CIC, Carnegie Mellon University, Monash University, and University of Leicester

Summary

• The PyTorch Foundation announced nine new members, adding five Silver members and four Associate members to its vibrant community since December 2025.
• Membership growth underscores rising demand for open, community-driven, production-ready AI tooling as agentic AI accelerates, strengthening the ecosystem around PyTorch Foundation projects like PyTorch, vLLM, DeepSpeed, and Ray.
• New Silver members include Clockwork.io, Emmi AI, National IT Industry Promotion Agency (NIPA), Nota AI., and yasp.ai, and new Associate members include Carnegie Mellon University, CommonAI CIC, Monash University, and University of Leicester.
• Developers, engineers, and industry leaders alike are encouraged to register for PyTorch Conference Europe in Paris on April 7-8, 2026 to learn more about the growing open source AI ecosystem.

NAPA, Calif. – Linux Foundation Member Summit – Feb. 24, 2026 — The PyTorch Foundation, a community-driven hub for open source AI under the Linux Foundation, today announced significant expansion of its membership, with nine new members joining since December 2025. New members include Carnegie Mellon University, Clockwork.io, CommonAI CIC, Emmi AI, Monash University, National IT Industry Promotion Agency (NIPA), Nota AI, University of Leicester, and yasp.ai.

New PyTorch Foundation membership signals sustained growth and progress in agentic AI innovation, with the Foundation leading the way on open, community-driven AI. Fueled by industry participation from leading universities, AI startups, global governments, and more, the PyTorch Foundation’s production-ready tools and libraries – including PyTorch, vLLM, DeepSpeed, and Ray – play integral roles in the AI stack.

“There are no agentic systems without the models that power them,” said Mark Collier, GM of AI at the Linux Foundation and Executive Director of the PyTorch Foundation. “From training frameworks like PyTorch and optimization systems like DeepSpeed that create capabilities such as advanced tool calling, to inference engines and orchestration layers like vLLM and Ray that operationalize them, the Foundation hosts critical layers of the open source AI stack. The growth of our membership reflects a shared recognition that these capabilities must be built collaboratively in a vendor-neutral environment.”

Clockwork.io, Emmi AI, NIPA, Nota AI, and yasp join the foundation as Silver members. CommonAI CIC, Carnegie Mellon University, Monash University, and University of Leicester join as Associate members.

This news follows Ray joining the PyTorch Foundation as a foundation-hosted project in October 2025. The open source distributed computing framework for AI workloads, developed by Anyscale, offers development teams a seamless way to execute data processing, forming an integrated open source distributed computing layer for agentic AI alongside vLLM and PyTorch as part of the foundation.

To learn more, join the global PyTorch community in Paris, France from April 7-8, 2026 for the inaugural PyTorch Conference Europe. Register here for early-bird pricing on the latest in open source AI and machine learning.

Supporting Quotes

“At Emmi AI, PyTorch is a key part of how we bring AI into real-world engineering workflows. Becoming a member of the PyTorch Foundation is a natural step for us as we contribute to an open ecosystem that accelerates research, deployment, and impact.”

– Miks Mikelsons, Chief Operating Officer & Co-Founder, Emmi AI

“Open source AI plays a critical role in bringing research innovations into real-world applications. By joining the PyTorch Foundation, we look forward to collaborating with the community and contributing our experience in AI model optimization.”

– Tae-Ho Kim, CTO, Nota AI 

“AI teams shouldn’t have to redesign their models every time the hardware changes. Our work focuses on separating model innovation from infrastructure constraints, so developers can run efficiently anywhere. Becoming part of the PyTorch Foundation aligns with our belief that open ecosystems are essential to reduce friction, avoid lock-in, and scale AI sustainably.”

– Reza Rahimi, CTO, yasp

###

About the PyTorch Foundation

The PyTorch Foundation is a community-driven hub supporting the open source PyTorch framework and a broader portfolio of innovative open source AI projects. Hosted by the Linux Foundation, the PyTorch Foundation provides a vendor-neutral, trusted home for collaboration across the AI lifecycle—from model training and inference, to domain-specific applications. Through open governance, strategic support, and a global contributor community, the PyTorch Foundation empowers developers, researchers, and enterprises to build and deploy AI at scale. Learn more at https://pytorch.org/foundation.

About the Linux Foundation

The Linux Foundation is the world’s leading home for collaboration on open source software, hardware, standards, and data. Linux Foundation projects, including Linux, Kubernetes, Model Context Protocol (MCP), OpenChain, OpenSearch, OpenSSF, OpenStack, PyTorch, Ray, RISC-V, SPDX and Zephyr, provide the foundation for global infrastructure. The Linux Foundation is focused on leveraging best practices and addressing the needs of contributors, users, and solution providers to create sustainable models for open collaboration. For more information, please visit us at linuxfoundation.org.

The Linux Foundation has registered trademarks and uses trademarks. For a list of trademarks of The Linux Foundation, please see its trademark usage page: www.linuxfoundation.org/trademark-usage. Linux is a registered trademark of Linus Torvalds.

Media Contact

Grace Lucier
The Linux Foundation
pr@linuxfoundation.org

The schedule for PyTorch Conference Europe is officially live! Join us 7-8 April in Paris for 95+ sessions across 8 tracks over 2 days dedicated to the builders, researchers, and practitioners advancing the PyTorch ecosystem across Europe and beyond. From core framework innovation to applied AI breakthroughs, this is where the community connects around what is working right now and what is coming next.

Featured Session Highlights

• Compliance Without the Pain: A PyTorch Engineer’s Guide – Yashasvi Misra, Pure Storage
• Lightning Talk: Enabling the Audio Modality for Language Models – Eustache Le Bihan, Hugging Face
• Lightning Talk: Accelerating PyTorch Models With Torch.compile’s C++ Wrapper Mode – Bin Bao, Meta

View the full schedule.

Join Us

Early bird registration pricing ends this week. Buy your ticket by 27 February to save. What’s Included?

• All conference content
• Social events & networking activities
• Community Expo
• Lunches, morning & afternoon coffee & snacks
• Event swag

Student or faculty? Learn more about our discounted academic rate.

Need help getting to the event? Scholarships are available through 11 March. Apply now!

Register now for PyTorchCon EU.

Become a Sponsor

Seize your opportunity to influence the future of Generative AI and Machine Learning by becoming a sponsor! PyTorch is at the forefront of innovation—empowering rapid experimentation, flexible model development, and efficient deployment into production environments with its powerful, versatile ecosystem of tools and thriving community of dedicated users.

As a sponsor, you’ll be in the heart of the vibrant, global AI/ML ecosystem, connecting directly with hundreds of expert attendees, researchers, engineers, and decision-makers who are actively shaping the conversations driving the next generation of advancements.

To view the PyTorch Ecosystem, see the PyTorch Landscape. Learn more about how projects can join the PyTorch Ecosystem. 

About Mooncake

Mooncake is designed to solve the “memory wall” in LLM serving. As context lengths grow and models scale, the static binding of Key-Value (KV) cache to specific GPU workers becomes a primary bottleneck.

Mooncake empowers inference engines to break this binding, unlocking four critical capabilities:

1. (Encoder) Prefill-Decode Disaggregation: Mooncake’s high-performance Mooncake Transfer Engine separates heavy computation (prefill/encoder) from latency-sensitive generation (decoding) into distinct clusters.
2. Global KVCache Reuse: By acting as a distributed shared memory for KV blocks, Mooncake Store enables valid cache to be reused globally across different requests and engine instances.
3. Elastic Expert Parallelism: By decoupling experts from specific workers,  Mooncake-EP enables elastic and resilient serving where experts of Mixture-of-Experts (MoE) models can be dynamically routed or recovered, ensuring high availability even during partial node failures.
4. PyTorch Distributed Backend: Mooncake Backend serves as a fault-tolerant PyTorch distributed backend. It provides robust collective communication primitives capable of continuing operation seamlessly in the presence of rank failures. 
5. Weighs Updating: Mooncake Store enables rapid weight updates for RL and checkpoint scenarios by storing weights internally. It offers tensor-native and zero-copy APIs.

Wide Industry Adoption

Mooncake originated from a research collaboration between Moonshot AI and Tsinghua University. It was born from the need to solve the “memory wall” in serving massive-scale models like Kimi. Since open-sourcing, it has evolved into a thriving community-driven project.

Mooncake’s architecture has been battle-tested in some of the world’s most demanding production environments. Its ability to decouple compute from memory has led to wide adoption across leading organizations, including Moonshot AI (Kimi), Alibaba Cloud, Ant Group, JD.com, Tencent, Meituan, Approaching.AI and LightSeek Foundation.

These organizations utilize Mooncake to maximize GPU utilization and ensure smooth serving for millions of concurrent users.

In Action: A Joint Solution

To demonstrate the full potential of this architecture, we present a joint solution that combines Mooncake with the ecosystem’s leading inference engines and orchestration tools.

In this architecture, we will use RoleBasedGroup (RBG, https://github.com/sgl-project/rbg) to orchestrate the entire topology, defining the relationships and startup order of the cluster. It deploys Shepherd Model Gateway (SMG, https://github.com/lightseekorg/smg) as the critical routing layer, which intelligently directs incoming requests to the appropriate workers based on cache locality and system load. The heavy lifting is then performed by SGLang (https://github.com/sgl-project/sglang) or vLLM (https://github.com/vllm-project/vllm) instances serving as compute workers, while Mooncake functions as the high-speed data plane: its Transfer Engine pushes prefilled KV cache via RDMA/NVLink, and its Store persists that cache for global reuse by decoding nodes.

1. Deployment with SGLang + Mooncake + SMG

Below is the RBG configuration that immediately deploys a complete SGLang architecture. In this case, both Prefill-Decode Disaggregation and Global KVCache-Reuse are enabled. The Prefill instances utilize Mooncake TE to transfer kvcache to Decode instances, while Mooncake Store facilitates reusing KVCache across different requests within the Prefill instance (more details in KEP-74 Mooncake Integration and pd-disaggregated-with-mooncake.yaml).

    YAML

# Joint Solution: RBG + SMG + SGLang + Mooncake (Production Ready)
apiVersion: workloads.x-k8s.io/v1alpha1
kind: RoleBasedGroup
metadata:
  name: sglang-mooncake-smg-v2
spec:
  roles:
    # 1. Mooncake Master: Centralized Metadata Server for TE and Store
    - name: mooncake-master
      replicas: 1
      template:
        spec:
          containers:
            - name: master
              image: lmsysorg/sglang:latest
              env:
                - name: POD_IP
                  valueFrom:
                    fieldRef:
                      fieldPath: status.podIP
              command: ["mooncake_master"]
              args:
                - --enable_http_metadata_server=true
                - --rpc_address=$(POD_IP)
                - --rpc_port=50051
                - --http_metadata_server_host=$(POD_IP)
                - --http_metadata_server_port=8080
                - --metrics_port=9003

    # 2. Mooncake Store: Distributed KVCache Storage Nodes
    - name: mooncake-store
      replicas: 3
      dependencies: ["mooncake-master"]
      template:
        spec:
          containers:
            - name: store-node
              image: lmsysorg/sglang:latest
              env:
                - name: MOONCAKE_MASTER
                  value: "s-sglang-mooncake-smg-v2-mooncake-master:50051"
                - name: MOONCAKE_TE_META_DATA_SERVER
                  value: "http://s-sglang-mooncake-smg-v2-mooncake-master:8080/metadata"
                - name: MOONCAKE_GLOBAL_SEGMENT_SIZE
                  value: "45gb"
                - name: MOONCAKE_PROTOCOL
                  value: "rdma" # Use RDMA for zero-copy KVCache transfer
              command: ["python3", "-m", "mooncake.mooncake_store_service"]
              resources:
                limits:
                  memory: "50Gi"
                  rdma/hca: 1 # Required for high-speed TE transfer
                requests:
                  memory: "50Gi"
                  rdma/hca: 1

    # 3. Prefill Worker (SGLang): High-throughput Prefill with Mooncake Push
    - name: prefill-worker
      replicas: 1
      dependencies: ["mooncake-master", "mooncake-store"]
      template:
        spec:
          containers:
            - name: sglang-prefill
              image: lmsysorg/sglang:latest
              env:
                - name: MOONCAKE_MASTER
                  value: "s-sglang-mooncake-smg-v2-mooncake-master:50051"
                - name: MOONCAKE_TE_META_DATA_SERVER
                  value: "http://s-sglang-mooncake-smg-v2-mooncake-master:8080/metadata"
                - name: MOONCAKE_PROTOCOL
                  value: "rdma"
              command:
                - python3
                - -m
                - sglang.launch_server
                - --model-path /models/Qwen3
                - --tp 4
                - --disaggregation-mode prefill
                - --disaggregation-transfer-backend mooncake # Activates Mooncake TE for KVCache Push
                - --enable-hierarchical-cache # Enables KVCache offloading
                - --hicache-storage-backend mooncake # Uses Mooncake as the L2/L3 cache backend
              resources:
                limits:
                  nvidia.com/gpu: "4"
                  rdma/hca: 1

    # 4. Decode Worker (SGLang): Low-latency Generation with Mooncake Pull
    - name: decode-worker
      replicas: 2
      dependencies: ["mooncake-master", "prefill-worker"]
      template:
        spec:
          containers:
            - name: sglang-decode
              image: lmsysorg/sglang:latest
              command:
                - python3
                - -m
                - sglang.launch_server
                - --model-path /models/Qwen3
                - --tp 4
                - --disaggregation-mode decode # Pulls shared KVCache from Mooncake Store
              resources:
                limits:
                  nvidia.com/gpu: "4"
                  rdma/hca: 1

    # 5. Shepherd Model Gateway (SMG): Intelligent PD-Disaggregation Router
    - name: smg-router
      replicas: 1
      dependencies: ["prefill-worker", "decode-worker"]
      template:
        spec:
          containers:
            - name: router
              image: lightseekorg/smg:latest
              command:
                - smg
                - --pd-disaggregation
                - --prefill http://s-sglang-mooncake-smg-v2-prefill-worker:8000
                - --decode http://s-sglang-mooncake-smg-v2-decode-worker:8000
                - --host 0.0.0.0
                - --port 8000

2. Deployment with vLLM + Mooncake

vLLM has also integrated Mooncake support, allowing users to leverage Mooncake connectors for seamless KV transfer. Below is the equivalent rbg() solution for deploying vLLM in a disaggregated setup using Mooncake connectors.

YAML

# Joint Solution: RBG + vLLM + Mooncake Connector
apiVersion: workloads.x-k8s.io/v1alpha1
kind: RoleBasedGroup
metadata:
  name: vllm-pd-with-mooncake-demo
spec:
  roles:
    # 1. Gateway: Routing to vLLM instances (SMG or vLLM Proxy)
  - name: proxy
    dependencies: [ "prefill", "decode" ]
    replicas: 1
    template:
      spec:
        containers:
        - name: proxy
          image: lightseekorg/smg:latest
          command:
          - smg
          - --prefiller-host
          - http://vllm-pd-with-mooncake-demo-prefill-0.s-vllm-pd-with-mooncake-demo-prefill
          - --prefiller-port
          - "8000"
          - --decoder-host
          - http://vllm-pd-with-mooncake-demo-decode-0.s-vllm-pd-with-mooncake-demo-decode
          - --decoder-port
          - "8000"

    # 2. Prefill Worker (vLLM): Producer role
  - name: prefill
    replicas: 1
    template:
      spec:
        volumes:
        - name: model
          persistentVolumeClaim:
            claimName: qwen2.5-7b
        - name: dshm
          emptyDir:
            medium: Memory
            sizeLimit: 30Gi
        containers:
        - name: prefill
          image: vllm/vllm-openai:latest
          command:
          - sh
          - -c
          - |
            pip install mooncake-transfer-engine && \
            vllm serve /models/Qwen2.5-7B-Instruct \
              --port 8000 \
              --tensor-parallel-size 4 \
              --kv-transfer-config '{"kv_connector":"MooncakeConnector","kv_role":"kv_producer"}'
          ports:
          - containerPort: 8000
            name: http
          readinessProbe:
            initialDelaySeconds: 30
            periodSeconds: 10
            tcpSocket:
              port: 8000
          resources:
            limits:
              nvidia.com/gpu: "4"
              rdma/hca: 1
              memory: "100Gi"
            requests:
              nvidia.com/gpu: "4"
              rdma/hca: 1
              memory: "100Gi"
          volumeMounts:
          - mountPath: /models/Qwen2.5-7B-Instruct
            name: model
          - mountPath: /dev/shm
            name: dshm

    # 3. Decode Worker (vLLM): Consumer role
  - name: decode
    replicas: 1
    template:
      spec:
        volumes:
        - name: model
          persistentVolumeClaim:
            claimName: qwen2.5-7b
        - name: dshm
          emptyDir:
            medium: Memory
            sizeLimit: 30Gi
        containers:
        - name: decode
          image: vllm/vllm-openai:latest
          command:
          - sh
          - -c
          - |
            pip install mooncake-transfer-engine && \
            vllm serve /models/Qwen2.5-7B-Instruct \
              --port 8000 \
              --tensor-parallel-size 4 \
              --kv-transfer-config '{"kv_connector":"MooncakeConnector","kv_role":"kv_consumer"}'
          ports:
          - containerPort: 8000
            name: http
          readinessProbe:
            initialDelaySeconds: 30
            periodSeconds: 10
            tcpSocket:
              port: 8000
          resources:
            limits:
              nvidia.com/gpu: "4"
              rdma/hca: 1
              memory: "100Gi"
            requests:
              nvidia.com/gpu: "4"
              rdma/hca: 1
              memory: "100Gi"
          volumeMounts:
          - mountPath: /models/Qwen2.5-7B-Instruct
            name: model
          - mountPath: /dev/shm
            name: dshm
---

apiVersion: v1
kind: Service
metadata:
  labels:
    app: vllm-pd-with-mooncake-demo
  name: vllm-pd-with-mooncake-demo
  namespace: default
spec:
  ports:
  - name: http
    port: 8000
    protocol: TCP
    targetPort: 8000
  selector:
    rolebasedgroup.workloads.x-k8s.io/name: vllm-pd-with-mooncake-demo
    rolebasedgroup.workloads.x-k8s.io/role: proxy
  type: ClusterIP

Conclusion

Mooncake adds a vital layer of memory virtualization to the open-source AI stack. By enabling PyTorch engines—whether SGLang, vLLM, or TensorRT-LLM —to adopt KVCache-centric architectures, we are paving the way for more efficient, scalable, and lower-latency LLM services.

We invite you to explore the project and start building:

• Mooncake GitHub: https://github.com/kvcache-ai/Mooncake

Mooncake Project Doc: https://kvcache-ai.github.io/Mooncake/

I want to start by thanking Matt White for everything he has built over the past two years. The growth of the PyTorch Foundation speaks for itself. What began as a single-project foundation is now a multi-project home for some of the most critical infrastructure in AI. That did not happen by accident. It is the result of real technical leadership, genuine community investment, and a clear belief in open collaboration. Matt is now stepping into the role of Global CTO of AI at the Linux Foundation and will transition to the role of CTO at the PyTorch Foundation, where he will focus on the technical strategy and direction that will define what’s possible next.

I’m thrilled to be joining the PyTorch Foundation as its new Executive Director. Here’s why.

The Most Important Open Source Projects in the World

There is not a more important open source project in the world right now than PyTorch. The daily onslaught of new state-of-the-art models proves it. When you hear about models writing compilers from scratch capable of compiling the Linux kernel, you’re getting a glimpse of the future that PyTorch makes possible.

But here’s what I think people outside of our community are only beginning to understand: the PyTorch Foundation is no longer just about PyTorch.

vLLM has become the inference engine of choice for the industry. When a new model drops, it runs on vLLM on day one, which tells us where the center of gravity lives. Inference is the largest workload in human history, and it runs on a PyTorch Foundation project.

DeepSpeed is pushing the boundaries of training efficiency at a scale that was unthinkable a few years ago. Ray is powering the orchestration and scaling layer that lets AI workloads run across the industry. These are foundational technologies with massive communities of their own, and they chose to make their home here.

Training. Inference. Orchestration. The critical layers of the AI stack live under one roof.

Every Innovation Story Is an Infrastructure Story

I’ve spent my career finding the infrastructure layer of emerging technology waves and building open source ecosystems around them. I co-founded OpenStack in 2010 and built the OpenStack Foundation (now OpenInfra Foundation), spending over a decade helping create the open source cloud. Last year we merged the OpenInfra Foundation with the Linux Foundation, and I became General Manager of AI and Infrastructure and Executive Director of the LF AI and Data Foundation. Now I get to put that experience into action with the PyTorch Foundation.

If there’s one thing I’ve learned across all of that, it’s that every innovation story is an infrastructure story if you know where to look. AI is going to reshape every aspect of the lives of every human being on earth, and it is going to do so at a speed that makes previous technological transitions look slow. The industrial revolution played out over generations. The internet transformed society over decades. AI is compressing that arc into years. The infrastructure that makes all of this possible is being built right now, in the open, by the communities in this foundation

We don’t want any one company or country to dominate such critical technologies. They have to be built together by communities that trust each other enough to do the hard work side by side. The best open source foundations foster the conditions that let communities lead. They keep the path open for the widest possible participation and the largest possible impact. That’s what we need to do again, and I’m here to do that work with all of you. 

The Energy Is Real

I had the opportunity to attend PyTorchCon in San Francisco last October, and I was in awe of the community energy in that place. That’s not easy to pull off in Moscone, and it’s not something you’ll find at just any open source conference. I’ve been to many of them. It reminded me deeply of the early OpenStack days when our summits were doubling every year, and people were genuinely having fun while changing the world.

If you’re part of this community, whether you contribute to PyTorch, vLLM, DeepSpeed, Ray, or the ecosystem around them, you may not fully realize it yet, but that’s exactly what you’re doing. Enjoy the ride.

What Comes Next

My prime directive is clear. Serve the communities that make this foundation what it is. Advocate for the open path that leads to the most innovation, the widest impact, and the largest number of people served by this technology. And make sure that every community that calls this foundation home knows that it belongs here and that its work matters.

If you’re headed to a PyTorch Conference, a PyTorch Day, or anywhere else this community gathers, come find me. I want to meet the people doing this amazing work. The best part of open source has always been the people, and I can’t wait to get to know more of you.

Let’s go build the future.

Mark Collier is Executive Director of the PyTorch Foundation, General Manager of AI and Infrastructure at the Linux Foundation, and Executive Director of the LF AI and Data Foundation. He co-founded the OpenStack project in 2010 and spent 13 years building the OpenStack Foundation and open source cloud community.

Over the past nearly two years, I’ve had the privilege of serving as Executive Director of the PyTorch Foundation. As I look back on what we have accomplished together, one thing stands out clearly: our momentum is not accidental. It is the result of a global community of maintainers, contributors, researchers, practitioners, member organizations, and volunteers who have chosen collaboration, openness, and technical rigor as the path to progress.

This post is both a thank you and a transition update, shared first and foremost with the PyTorch community.

What we built in a short time

In a relatively short period, the PyTorch Foundation has evolved from a single-project foundation centered on PyTorch into a multi-project home for critical components across the AI development lifecycle. Today, the Foundation proudly hosts four major projects: PyTorch, vLLM, DeepSpeed, and most recently Ray. Alongside these hosted projects, the broader PyTorch ecosystem has expanded to more than 100 projects, including Unsloth, verl, SGLang, FEAST, and many other high-quality open source efforts that are pushing the state of the art forward.

At the same time, our membership has grown to 33 organizations, nearly doubling, and we updated our membership tiers to better reflect the scale and maturity of our ecosystem. Those member commitments matter, because they translate into real investment in the shared infrastructure and community programs that enable open source AI to thrive.

Stronger governance and deeper technical collaboration

As our technical scope expanded, so did our governance. We launched the initial Technical Advisory Council and supported its growth into a more active forum for cross-project alignment. We also established five core working groups: CI Infrastructure, Multi-Cloud, Ecosystem, Accelerators, and Security.

These groups are where hard, practical problems get solved: keeping CI reliable and scalable, improving portability and cost efficiency, coordinating cross-project priorities, strengthening security posture, and making it easier for developers and organizations to adopt and deploy PyTorch and related projects. The result has been measurably increased technical engagement, clearer project roadmaps, and more consistent collaboration patterns across the Foundation’s hosted projects and the broader ecosystem.

A bigger global footprint, powered by the community

The growth of PyTorch is global, and our community programs have expanded accordingly.

We grew from a conference of roughly 300 attendees to a flagship PyTorch Conference in San Francisco that welcomed more than 3,000 participants. We successfully launched PyTorch Days with events in Paris and Beijing, and we are continuing to expand our global presence. In 2026, we will hold three PyTorch Conferences: Europe in Paris (April), China in Shanghai (September), and our flagship event, North America in San Jose (October). These will be complemented by additional PyTorch Days, starting in Bengaluru this past weekend, with more events in development, including Beijing, Seoul, and others.

We also launched the PyTorch Ambassadors program, now approaching 50 ambassadors, with another cohort planned. This is one of the most important community programs we run, because it scales something no single team can manufacture: local leadership. Ambassadors host meetups, welcome new contributors, and help PyTorch show up meaningfully in regions and communities around the world. In parallel, we’ve been building a speaker bureau to connect domain experts from the community with events seeking credible technical speakers.

Academic outreach, research engagement, and education

Another area of focus has been strengthening ties between research, education, and open source practice.

We kicked off an Academic and OSPO outreach program to engage academic labs and university Open Source Program Offices, with early work involving UC Berkeley, UC Santa Cruz, Stanford, the University of Vermont, and Caltech. The goal is to help students build practical open source skills, create clearer pathways from research to production, and identify emerging open source AI projects that could benefit from Foundation support.

We also increased the Foundation’s participation in major research and practitioner venues, supporting workshops, posters, and talks at MLSys, ICML, NeurIPS, and UC Berkeley’s AgentX program. Across the year, I joined many leaders from the PyTorch community in speaking at more than 100 events worldwide to advocate for PyTorch, the Foundation, and open source AI as a durable strategy for innovation.

Finally, the educational output from the community has been exceptional. In 2025, we published more than 130 pieces of educational content, including tutorials, webinars, and blogs, averaging nearly one substantive item every three days. That pace reflects both the depth of expertise across the community and the rate at which the ecosystem continues to evolve.

We also made meaningful progress toward scalable professional development. At the last PyTorch Conference, we kicked off onsite training for the PyTorch Certified Associate program with strong participation. In the coming months, we expect to publish the corresponding exam and online course, and then begin building the content pathway toward a PyTorch Certified Professional designation. The intent is to support developers who want to demonstrate practical PyTorch fluency, while giving employers a clearer signal for hiring and workforce development.

Infrastructure that scales with the ecosystem

Behind every reliable open source ecosystem is infrastructure that works. Over the past two years, we continued strengthening CI reliability and observability, expanded monitoring and logging, and progressed the migration of our download site to the Cloudflare CDN.

Just as importantly, the Foundation’s CI would not be sustainable without the support of member organizations and partners who contribute engineering effort, hardware, and operational expertise. Contributions, current and in progress, from Meta, AWS, AMD, Intel, Microsoft, and NVIDIA have been critical. We have also advanced a multi-cloud strategy so we can diversify our footprint across hyperscalers and neo-clouds, manage cost, and maintain the performance and scale that developers and production users depend on.

What comes next

Even with this progress, the next phase demands more. Key priorities ahead include:

• Expanding the hosted project portfolio, including adjacent domains such as agentic AI, environments, and reinforcement learning
• Further diversifying and optimizing CI architecture and costs
• Onboarding additional project CI workloads where shared accelerator access unlocks faster iteration
• Expanding training and certification into a durable revenue stream that strengthens Foundation sustainability
• Deepening community programs, including initiatives such as mentorship and stronger global enablement

As the scope grows, there is a straightforward operational reality: leadership capacity must scale so that organizational throughput, not leadership bandwidth, sets our pace.

A leadership transition to support the next stage

To support this next stage, I’m sharing a leadership transition that takes effect immediately.

I will be stepping into the role of Chief Technology Officer for the PyTorch Foundation, alongside my new role as Global CTO of AI at the Linux Foundation. At the same time, Mark Collier will join the PyTorch Foundation as our new Executive Director.

Mark brings deep experience building and scaling open infrastructure ecosystems, including founding OpenStack and the OpenInfra Foundation. As Executive Director, he will lead the operational and business execution of the Foundation, working closely with the Governing Board. His responsibilities include oversight of Foundation committees (including Finance and Marketing), community programs such as Ambassadors, Foundation-led events, staff management, finances, and membership development. Ultimately, he will be accountable for the overall direction and operations of the Foundation in partnership with the Governing Board.

As CTO, I will focus on technical strategy and execution across the Foundation: supporting the TAC and working groups; advancing our hosted projects and ecosystem alignment; strengthening CI and multi-cloud infrastructure; and driving technical programs, including Academic and OSPO outreach and PyTorch Certified. This structure is intended to increase clarity, accountability, and speed, while preserving community-led technical governance.

Quotes

“It’s great to see the PyTorch Foundation enter a new phase, just months after it evolved into an umbrella foundation. With Mark as the Executive Director and Matt as the CTO, the foundation acquires the level of maturity required by its ambitions. I can’t wait to help build the future of PyTorch with the new leadership and the rest of the TAC.”

– Luca Antiga, CTO, Lightning AI and Chair, PyTorch Foundation Technical Advisory Council (TAC)

“Watching the PyTorch Foundation grow into an umbrella ecosystem has been inspiring—it’s set PyTorch up not only for the short term, but for a long arc of impact foundational to AI. Congrats to Matt on an incredible chapter, and a warm welcome to Mark. I’m excited for where we take PyTorch next!” 

– Joe Spisak, Product Director, Meta Superintelligence Labs & PyTorch Core Maintainer

“The growth of the PyTorch Foundation speaks for itself. Thanks to Matt White for everything he has built. What began as a single-project foundation is now a multi-project home for some of the most critical infrastructure in AI. That did not happen by accident. It is the result of real technical leadership, genuine community investment, and a clear belief in open collaboration. I’m excited to keep that momentum going that will define what’s possible next.”

– Mark Collier, Executive Director, PyTorch Foundation

Thank you

I want to close with an explicit note of appreciation. The PyTorch Foundation’s progress is not the product of any single organization or individual. It is the result of thousands of community members: maintainers, contributors, reviewers, working group participants, event organizers, speakers, educators, and member company teams who consistently choose collaboration over fragmentation and long-term stewardship over short-term advantage.

Thank you for the trust, the effort, and the standards you bring to this community.

I’m excited for what comes next, and I’m particularly looking forward to working with Mark as he steps into the Executive Director role. Please join me in welcoming him and supporting him as he begins this next chapter with us.

We have built something strong. Now we scale it.

Matt White

CTO, PyTorch Foundation
Global CTO of AI, Linux Foundation

On February 7, 2026, the inaugural PyTorch Day India brought the open source AI community to Bengaluru for a full day of technical talks, discussions, and community connection. Co-organized by IBM, NVIDIA, and Red Hat, the event reinforced a clear theme: India is not only adopting AI at scale, it is helping define how production-grade, open AI systems are built.

The in-person event was held in Bengaluru, placing the event at the center of one of India’s most active engineering ecosystems with 460 in-person attendees. The event was emceed by Raghu Ganti, IBM, who guided the day’s flow and helped keep the program cohesive and engaging.

Keynotes that framed the day: open platforms shaping the future of open source AI

A strong keynote trio anchored the event, reflecting the co-organizers’ complementary strengths across enterprise platforms, infrastructure software, and accelerated computing.

• Steve Watt (Red Hat): “Any Model, Any Accelerator, Any Cloud: How Open Source AI Unlocks the World’s Potential”
• Sriram Raghavan (IBM): “The Ubiquitous AI Platform: Lessons from Linux, Vision for PyTorch”
• Niket Agarwal (NVIDIA): “Full Stack AI Innovation: PyTorch + NVIDIA From Edge to Data Center”
  

Taken together, these talks pointed to the operational reality of modern AI, and how platforms like PyTorch and vLLM are laying the foundation for fast innovation from research to production

First, heterogeneous compute has become the default. Teams increasingly mix CPUs, GPUs, and specialized accelerators across cloud and on-premises environments, and they need frameworks and tooling that work consistently across those targets.

Second, AI platforms are increasingly treated as foundational infrastructure. The Linux comparison is instructive because long-lived platforms succeed when they provide stable interfaces, clear governance, and predictable behavior. That stability enables fast iteration above the platform and efficient optimization below it.

Third, end-to-end performance is now a primary product requirement, not an optional enhancement. “Edge to data center” captures the range of deployment patterns that organizations must support, from constrained inference at the edge to large-scale training, fine-tuning, and high-throughput serving in the data center.

What builders came for: kernels, compilers, inference, and real systems work

PyTorch Day India was deliberately technical and builder-oriented. The event emphasized low-level kernel to systems performance work, optimization, training efficiency, inference, and deployment concerns. This reflects where the field is heading: the hardest problems are about making robust and dependable AI systems under real constraints like latency, cost, reliability, security, and governance.

That builder emphasis also showed up in the ecosystem representation and talk topics. For example, Aritra Roy Gosthipaty and Sayak Paul (Hugging Face) highlighted kernel-level work in the Transformers ecosystem, signaling that practical performance engineering is now a first-class conversation for mainstream ML teams.

This focus matches how organizations deploy AI today. Most production AI is not a single model running in isolation. It is a workflow that connects data pipelines, distributed execution, training and evaluation, inference and serving, monitoring, and governance. As these components become more interdependent, open and composable building blocks become essential.

A keynote message worth carrying forward: open source is how AI becomes dependable

In his address, Matt White, PyTorch Foundation CTO and former Executive Director, emphasized a shift that is now common across enterprises. AI is moving from prototype to operational capability. That transition forces teams to prioritize engineering fundamentals, including reproducible training and evaluation, scalable inference, distributed compute and data pipelines, and security and supply-chain hygiene.

He also underscored a broader architectural trend: AI systems are becoming “systems of systems,” where models connect to retrieval, tooling, deployment, monitoring, and governance. In that environment, open source becomes a practical necessity because production adoption benefits from transparency, inspectability, and integration flexibility across complex infrastructure.

Why India matters to the PyTorch Foundation and the global ecosystem

India’s importance to the PyTorch ecosystem is structural.

It has developer scale, talent density, and a strong builder culture that translates research into production systems. It also has broad industry diversity, spanning global capability centers, fast-growing startups, academic institutions, and large enterprises serving both local and international markets. That mix accelerates feedback on what matters most in real deployments.

India also has a mature relationship with open source collaboration. That matters because open ecosystems thrive when communities do more than consume software. They improve it, document it, test it, build extensions, and create learning pathways that expand participation. Events like PyTorch Day India strengthen those pathways by turning knowledge-sharing into sustained contribution.

What comes next: build locally, contribute globally

The most practical takeaway from the inaugural PyTorch Day India is that open source AI maturity is being shaped in many places at once, and India is clearly one of those places. Bengaluru was an appropriate setting, with its dense overlap of research, infrastructure engineering, product development, and startup execution.

For attendees, the next step is straightforward and high leverage: turn one idea from the day into an artifact that others can use. That might be a reproducible benchmark, a tutorial, a bug fix, a performance investigation, a documentation improvement, or a small but meaningful contribution to a project you rely on.

PyTorch Day India 2026 kept the focus where it belongs: on builders, on systems, and on the open technologies that make AI usable across industries and across the world. We hope to launch more PyTorch Day events in India and work together to build a strong, talent-rich, diverse, and cohesive open source AI ecosystem with the community in India.

We’re thrilled to announce that Feast — an open-source feature store for production AI— has officially joined the PyTorch Ecosystem! By aligning Feast with the PyTorch community, we’re combining PyTorch’s modeling excellence with robust data infrastructure practices, enabling seamless transitions from model development to production deployment.

To view the PyTorch Ecosystem, see the PyTorch Landscape and learn more about how projects can join the PyTorch Ecosystem. 

About Feast

Feast (short for Feature Store) is designed to manage data for production-scale AI. It offers a unified API for defining, storing, and serving data (i.e., features), bridging offline (training) and online (serving). 

What makes Feast particularly valuable for PyTorch workflows is its ability to eliminate training-serving skew—ensuring production models receive the exact same feature transformations used during training. At its core, Feast provides:

• Declarative feature definitions – Define features once, use them consistently across training and serving
• Point-in-time correctness  – Prevents data leakage during training by managing historical feature states
• Pluggable architecture – Adapts to your existing data infrastructure without requiring major changes (integrations with Spark, Snowflake, BigQuery, Ray, Kubernetes and cloud-native storage/serving layers)
• Low-latency serving – Pre-computed features stored for sub-millisecond retrieval during inference
• Python-first APIs – Seamlessly integrates with PyTorch workflows and MLOps pipelines
  

Feast isn’t a modeling library — it provides the data foundation that ensures your models perform consistently from development to production. By joining the PyTorch Ecosystem, Feast reinforces its commitment to open, interoperable AI infrastructure that scales with the community’s needs.

By joining the PyTorch Ecosystem, Feast reinforces its commitment to open, interoperable AI infrastructure that scales with the community’s needs.

See It In Action: Sentiment Analysis with Feast + PyTorch

See how Feast works with PyTorch. Try our sentiment analysis demo that showcases real-time feature serving with zero setup.

What you’ll learn:

• How to define and serve features for PyTorch models
• Real-time feature retrieval for model inference 
• Point-in-time correct feature engineering for training

This demo shows how to build a complete sentiment analysis pipeline using Hugging Face transformers, synthetic text data, and Feast’s feature store. You’ll see how Feast manages features consistently from training to real-time inference—all running locally with SQLite, no infrastructure required.

Step 1: Installation and Setup

First, we’ll install the Python package, jump-start the demo, and apply the metadata using the Feast CLI tool.

pip install feast[pytorch]>=0.58.0
feast init pytorch_demo  -t pytorch_nlp

By running feast init, we initiate a template repository with a sentiment embedding transformer. The directory structure will look like this:

> tree
.
├── __init__.py
├── feature_repo
│   ├── __init__.py
│   ├── data
│   │   └── sentiment_data.parquet
│   ├── example_repo.py
│   ├── feature_store.yaml
│   ├── static_artifacts.py
│   └── test_workflow.py
└── README.md

Here’s a brief summary of the purpose of each file:

• README.md – provides a detailed summary of the demo project

• feature_repo/__init__.py – a file needed to recognize the python project

• feature_repo/data/sentiment_data.parquet – sample data for this demo

• feature_repo/example_repo.py – declarative code with all of our features, transformations, and other Feast objects

• feature_repo/static_artifacts.py – this is code used by Feast to load the small sentiment model at build time for better latency

• feature_repo/test_workflow.py – this is an end-to-end demo script that runs through the MLOps pipeline.

The sentiment_data.parquet file provides a set of sample data with labels and a sentiment score. A transposed subsample of the data looks like so:

|                      | 0                    | 1                    |
|:---------------------|:---------------------|:---------------------|
| text_id              | text_0000            | text_0001            |
| user_id              | user_028             | user_059             |
| text_content         | Having an amazing... | Traffic is horrib... |
| sentiment_label      | positive             | negative             |
| sentiment_score      | 0.993                | 0.982                |
| text_length          | 48                   | 59                   |
| word_count           | 9                    | 10                   |
| exclamation_count    | 1                    | 1                    |
| caps_ratio           | 0.021                | 0.017                |
| emoji_count          | 0                    | 0                    |
| event_timestamp      | 2025-12-15 16:38:... | 2025-12-03 15:08:... |
| created              | 2025-12-23 14:40:... | 2025-12-23 14:40:... |
| user_avg_sentiment   | 0.927                | 0.902                |
| user_text_count      | 11                   | 7                    |
| user_avg_text_length | 47.636               | 51.429               |

Next we will change directories into feature_repo where we can store all of our declarative feature code to serve our application. Then we will run feast apply, which will register the declarative code (Entities, Feature Views, and other Feast-specific objects) as metadata to the Feast feature registry, which is used for governance, lineage, and cataloging.

cd pytorch_demo/feature_repo
feast apply

The output will look like the below:

Created entity text
Created entity user
Created feature view text_features
Created feature view user_stats
Created on demand feature view sentiment_prediction
Created feature service sentiment_analysis_v1
Created feature service sentiment_analysis_v2 

Now that we have registered our metadata, we can take our sample data and upload it to our “Online” database to serve for production use cases.

Step 2: Load data to the Online Database

We can upload our data to our online database by using the Feast CLI tool, which supports local file upload via the materialize-incremental command. For this demo, we use SQLite, but Feast supports a wide variety of production-grade enterprise databases.

feast materialize-incremental $(date -u +"%Y-%m-%dT%H:%M:%S")

Step 3: Start and test REST API 

Using the Feast CLI tool again, we can spin up the feature server, which exposes REST API endpoints that allow other services to securely access the data we uploaded in our online database.

feast serve --host 0.0.0.0 --port 6566

We can make a curl request in a separate terminal session:

curl -X POST \
  "http://localhost:6566/get-online-features" \
  -H "Content-Type: application/json" \
  -d '{
    "features": [
      "sentiment_prediction:predicted_sentiment",
      "sentiment_prediction:sentiment_confidence",
      "sentiment_prediction:positive_prob"
    ],
    "entities": {
      "input_text": ["I love this amazing product!", "This service is terrible"],
      "model_name": ["cardiffnlp/twitter-roberta-base-sentiment-latest", "cardiffnlp/twitter-roberta-base-sentiment-latest"]
    }
  }' | jq

And you will see a nicely structured JSON with our feature data, including data that was transformed on the fly (i.e., “on demand”) with Feast! This data can be used for various applications, particularly those running inference for Recommendation Engines, Scorecard models, RAG applications, and other AI use cases.

Step 4: Render UI to see Data Lineage

Finally, we can spin up the UI locally to see the metadata from the registry rendered nicely. The Feast UI is a catalog meant to centralize features to enable cross-team collaboration and reduce feature re-implementation.

You can run the UI using the Feast CLI via and navigate to the lineage page to see the rich visualization.

feast ui

Example of Feast’s Lineage UI

Beyond the demo, Feast supports additional functionality to empower AI/ML teams to ship production grade AI applications.

Compute Engine and Training Dataset Preparation

During feature development and iteration (i.e., training dataset preparation), users typically have to run a batch process to backfill their historical data. Feast supports point-in-time joins to ensure Feature correctness and to avoid leaking future feature information into the training data. To do this, Feast uses  a Compute Engine abstraction that supports multiple providers (local, Spark, Snowflake, Lambda, Flink, and Ray). This flexibility allows our end users to leverage the best of open source while providing a simple SDK that avoids frequently occurring challenges.

Open Telemetry for Observability

Feast supports OpenTelemetry and provides comprehensive monitoring and observability for your feature serving infrastructure. 

Authorization/RBAC and Permissions for Governance

Feast supports both OIDC authentication and Kubernetes RBAC for robust Role Based Access Control. Additionally, Feast supports a Permission system to allow fine-grained permission policies for the online store, offline store, and registry.

How Feast Enhances the PyTorch Experience

Integrating Feast into the PyTorch ecosystem unlocks several critical benefits for practitioners building production AI systems:

• Eliminates Training-Serving Skew – The #1 cause of model performance degradation in production. Feast ensures your model receives identical feature transformations during training and inference, maintaining model accuracy at scale.
• Accelerates Model Deployment – Pre-computed features stored in optimized databases enable the real-time serving of data with sub-millisecond latency for real-time inference. No more waiting for feature computation during inference.
• Enables Feature Reuse Across Teams – Centralized feature definitions prevent redundant work. When one team creates user behavior features for a recommendation model, other teams can reuse them for fraud detection or personalization models.
• Powers Advanced AI Workflows – Feast’s vector store capabilities, combined with PyTorch, enable sophisticated retrieval-augmented generation (RAG) pipelines where document embeddings are retrieved and used to enhance large language model responses.
• Provides Production-Grade Governance – Built-in lineage tracking, access controls, and monitoring ensure your PyTorch models meet enterprise requirements for data governance and compliance.

Community-Proven at Scale

Trusted by organizations like NVIDIA, Shopify, and other companies building production PyTorch systems across industries from e-commerce to financial services.

Real-World Impact

Feast has gained traction across industries, powering AI applications at both startups and enterprises. Consider these use cases:

• Real-time Personalization: E-commerce platforms use Feast to serve up-to-date user behavior features to PyTorch recommendation models, enabling personalized product suggestions with millisecond response times.
• Financial AI: Credit underwriting systems leverage Feast’s point-in-time correctness to ensure PyTorch models for fraud detection aren’t trained with future information, maintaining model accuracy and regulatory compliance.
• RAG Applications: Organizations combine Feast with PyTorch-based language models to implement retrieval-augmented generation, where relevant documents are retrieved from vector stores and used to provide contextually-appropriate responses.

Call to Action

If you’re working with PyTorch (or exploring model deployment or RAG workflows), we invite you to start exploring Feast today:

• Visit the Feast website: https://feast.dev Feast
• Read the docs: https://docs.feast.dev docs.feast.dev
• Check out the GitHub repo: https://github.com/feast-dev/feast GitHub
• Join our community: whether you want to add a new connector, improve documentation, or integrate Feast into your PyTorch stack — contributions are welcome.

Ready to supercharge your PyTorch workflows with Feast? Install Feast with PyTorch support:

pip install feast[pytorch]>=0.58.0

Conclusion

The integration of Feast into the PyTorch Ecosystem represents a significant step forward in making production-ready AI more accessible. By combining PyTorch’s modeling capabilities with Feast’s robust data management, developers can now build end-to-end AI systems that scale from prototype to production with confidence.

This community-driven event focuses on real-world systems, emerging research, and practical lessons from production environments, creating space for technical exchange, collaboration, and learning across the PyTorch ecosystem.

Call for Proposals Is Now Open

The Call for Proposals for PyTorch Conference Europe 2026 is officially open. If you are working with PyTorch and have insights, experience, or ideas to share, now is the time to submit a proposal.

We are looking for talks that offer technical depth and practical value, including work on framework development, performance optimization, training and inference systems, tooling, research breakthroughs, real-world applications, education, and community contributions.

Proposals are due Sunday, 8 February 2026, at 11:59 pm CEST.
Submit a proposal: https://events.linuxfoundation.org/pytorch-conference-europe/program/cfp/

Suggested Topics

Suggested areas of focus include, but are not limited to:

• Responsible AI and compliance, including the EU AI Act, governance, auditability, and sovereign AI

• Security and privacy, including NIS2-aligned controls, threat modeling, and privacy engineering

• Applications and case studies across health, manufacturing, finance, and the public sector

• Frameworks and compilers, including PyTorch internals, deep learning compilers, and kernel authoring

• Training systems, including distributed training, data pipelines, scalability, and pre and post training

• Inference and production, including serving, observability, and LLMOps

• Generative AI and multimodal systems, including LLMs, RAG, and multimodal architectures

• Agents and interoperability, including agent engineering, MCP, and execution environments

Important Dates

• CFP closes: Sunday, 8 February 2026, 11:59 pm CEST

• CFP notifications: Wednesday, 18 February 2026

• Schedule announcement: Thursday, 19 February 2026

• Presentation slides due: Monday, 6 April 2026

• Conference dates: Tuesday, 7 April to Wednesday, 8 April 2026

Sponsorship Opportunities

PyTorch Conference Europe offers organizations an opportunity to engage directly with the PyTorch developer and research community. Sponsorship packages are available for companies looking to support open source AI and connect with practitioners shaping the ecosystem.

Learn more about the event, submit a proposal, or explore sponsorship opportunities:
https://events.linuxfoundation.org/pytorch-conference-europe/

#PyTorchCon

Together, PyTorch, vLLM, DeepSpeed, and Ray reflect how PyTorch Foundation supports a growing set of open source AI projects under neutral governance, while continuing to steward PyTorch as the foundation of the ecosystem.

In all, PyTorch Foundation welcomed three foundation-hosted projects, 14 ecosystem projects, and 16 new members, supported four PyTorch releases (2.6, 2.7, 2.8, and 2.9), and advanced community programs and global events, including the largest PyTorch Conference to date, with more than 3,400 attendees. As we begin 2026, let’s highlight key milestones from 2025 and outline priorities for the year ahead, including insights from Matt White (Executive Director, PyTorch Foundation), Joe Spisak (Product Director, Meta), and Luca Antiga (CTO, Lightning AI and Chair, PyTorch Technical Advisory Council).

PyTorch Foundation Expansion and Foundation-hosted Projects

The PyTorch Foundation’s expansion into an umbrella foundation established a formal governance and support model for open source AI projects used across the ecosystem. This structure enables the Foundation to provide shared infrastructure, neutral governance, and long-term stewardship while supporting a growing portfolio of projects. Further, we welcomed 16 new members, including Snowflake, Dell Technologies, and Qualcomm, reflecting increased industry participation in supporting open source AI under neutral governance.

With the addition of vLLM and DeepSpeed, the Foundation began supporting projects focused on high-throughput inference and distributed training. The addition of Ray extended this support to distributed compute for scalable data processing, training, and inference workflows.

The Linux Foundation’s 2025 Annual Report described this transition as a watershed moment for open source AI, highlighting the importance of aligning training, inference, and distributed compute projects under neutral governance.

Throughout the year, PyTorch Foundation supported the continued evolution of PyTorch through its governance structures, the Technical Advisory Council, and collaboration across member organizations and contributors.

In 2025, the PyTorch project delivered 4 major releases, including PyTorch 2.6, PyTorch 2.7, PyTorch 2.8, and PyTorch 2.9. These releases introduced improvements across compiler technology, distributed training, inference performance, packaging, and hardware support, reflecting ongoing investment in both research and production use cases.

To support transparency and direct engagement with developers, the Foundation hosted live release Q&A sessions and technical webinars throughout the year, including Inside Helion: Live Q&A with the Developers and multiple PyTorch 2.x release Q&As, available through the PyTorch webinars archive.

Looking ahead, the PyTorch Foundation will continue to convene the global community through events in 2026. The hugely successful PyTorch Conference will be expanding to Europe and China, with the inaugural PyTorch Conference EU planned for  April 2026 in Paris and PyTorch Conference China planned for September in Beijing. In October, we will be hosting our landmark PyTorch Conference in San Jose, California, taking place October 19-21 in the middle of Open Source AI Week 2026. This event is expected to draw even larger crowds and promises more diverse content and attendance than our past events. Be sure to mark your calendars! 

PyTorch Days

In 2025, the PyTorch Foundation introduced PyTorch Day events to complement PyTorch Conference with regionally focused, community-driven programming.

PyTorch Day France was held in Paris in May, co-located with GOSIM AI Paris, and featured a focused program spanning inference optimization, distributed training, robotics, and agentic systems.

PyTorch Day China followed in June in Beijing, co-located with BAAI Conference, featuring a full day of technical talks and posters with strong participation across sessions focused on large-scale training, efficient inference, and hardware-aware optimization.

2026 PyTorch Days

PyTorch Day India 2026 will take place on 7 February in Bengaluru, bringing the regional PyTorch community together for a full day of technical talks, discussions, and poster sessions focused on open source AI and machine learning. The event is hosted by PyTorch Foundation and co-hosted with IBM, NVIDIA, and Red Hat.

Learn more and register: https://pytorch.org/event/pytorch-day-india-2026/

Other PyTorch Days are anticipated in Dubai and China.

Ecosystem Growth and Working Group Updates

The PyTorch Foundation continued to support ecosystem growth through clearer processes and increased visibility into project activity. In 2025, the PyTorch Ecosystem Working Group published regular updates highlighting new projects joining the ecosystem and projects under consideration.

The PyTorch Ecosystem Working Group Update and Project Spotlights, Q4 2025, highlighted new ecosystem projects including FlagGems, Kubeflow Trainer, LMCache, DeepInverse, Feast, NeuralOperator, PINA, and verl, reflecting continued growth across AI infrastructure, LLM serving, reinforcement learning, and scientific machine learning. In total, we welcomed 14 ecosystem projects.

Looking Ahead to 2026

As we enter 2026, our focus remains on supporting PyTorch and the Foundation’s growing set of foundation-hosted projects through neutral governance, shared infrastructure, and global community engagement. We will continue to bring in durable, high-value open source AI projects into the Foundation, grow our ecosystem, expand our programs, including training and certification, and grow our events to help educate and empower the PyTorch community. The perspectives below highlight leadership views on priorities for the year ahead.

Matt White: Executive Director, PyTorch Foundation

In 2025, the PyTorch Foundation proved what an open, neutral home for production-grade AI can look like at global scale. Our expansion into an umbrella foundation and the addition of foundation-hosted projects that span core training and inference pathways strengthened the case for durable, community-governed infrastructure across the AI lifecycle. Just as importantly, we paired that technical and governance momentum with programs that kept developers at the center: clearer ecosystem processes, more transparent engagement, and events that brought practitioners, researchers, and maintainers into the same room to share what’s working, what’s emerging, and what needs to be built next.

In 2026, we will build directly on that foundation with a larger, more connected global footprint. We will host three PyTorch Conferences and three PyTorch Days, designed to serve complementary needs: the conferences will provide broad, high-density programming across the full lifecycle (research to production), while PyTorch Days will remain regionally grounded and community-driven, helping local ecosystems grow their contributor networks and practical adoption. Our flagship PyTorch Conference will move to San Jose at the San Jose Convention Center, enabling a larger venue, expanded content tracks, and a more diversified attendee base across industries, geographies, and levels of experience.

We are also investing in structured learning pathways that meet developers where they are. In 2026, the Foundation will launch PyTorch Associate and PyTorch Professional online training and certifications to support skills development that is both accessible and industry-relevant. The intent is straightforward: make it easier for individuals and teams to build competence in PyTorch and the surrounding ecosystem, while giving employers a clearer signal of practical capability. These programs will complement our events strategy, so that learning can start online, deepen through live engagement, and then translate into real contributions and deployments.

Academic engagement will expand as well. We will continue to sponsor and run workshops at leading research venues, including NeurIPS, MLSys, ICML, and UC Berkeley’s AgentX / Agent Beats to ensure PyTorch remains a collaborative substrate for the next wave of research and reproducible systems work. In parallel, we will grow our Academic and OSPO Outreach program to strengthen relationships with universities, research labs, and open source program offices, and we will launch a new cohort of PyTorch Ambassadors, supporting them with resources to run regional events, foster local communities, and create reliable on-ramps for new contributors.

Technically, our priorities remain anchored in openness, interoperability, and practical impact. We will continue focusing on bringing in high-value, proven projects that extend PyTorch across the AI lifecycle, especially in areas that are rapidly becoming foundational, such as RL, agentic scaffolding, and environments. At the same time, we will grow the PyTorch Ecosystem into new domains, including stronger verticals in AI for science and embodied AI, because the community’s long-term relevance depends on being excellent not just at building models, but at enabling responsible, real-world outcomes across disciplines.

The goal for 2026 is clear: make the PyTorch Foundation the go-to foundation for open source AI, a place where researchers, engineers, developers, and learners can find trusted projects, neutral governance, high-quality education, and a global community that welcomes participation. If you are building with PyTorch, extending the ecosystem, teaching others, or simply looking to learn more about modern AI systems, we encourage you to get involved through events, training, working groups, membership, and contributions across the Foundation’s growing portfolio.

Joe Spisak: Product Director, Meta

I view PyTorch’s evolution as a fundamental shift from being the industry’s leading research framework to becoming the connective foundation of a fully open, production-grade AI ecosystem. For me, PyTorch’s strategic value is no longer about being “just” a deep learning library; it’s about anchoring a modular, community-driven, multi-hardware stack that spans the entire AI lifecycle, from kernel authoring and distributed communication to RL post-training, agentic environments, and edge deployment. I believe our differentiation comes from openness and interoperability: a thriving developer community and first-class support for heterogeneous hardware, from Nvidia and AMD GPUs to TPUs or any other accelerator, while maintaining strong guarantees for developer usability.

As I look ahead to 2026, my focus is squarely on accelerating the industry’s transition to agentic AI systems powered by reinforcement learning at real scale. My priorities are to productize a PyTorch-native agentic and RL stack, drive global standardization around open RL environments, and ensure the surrounding infrastructure (e.g., distributed comms, training systems, and inference engines) can meet the demands of frontier model development and edge execution. I pair this technical trajectory with ecosystem growth: deep open-source collaboration, hardware partnerships, and large-scale developer events that reinforce PyTorch as the platform where the next wave of RL-driven, agentic, and personalized superintelligence will be built.

Luca Antiga: CTO, Lightning AI and Chair, PyTorch Technical Advisory Council

The work of the Technical Advisory Council, which I have had the honor to chair for the past 1.5 years, has significantly increased in 2025. Over the last year, the activities of the TAC have consolidated into five distinct Working Groups.

Two of them are dedicated to taking PyTorch CI infrastructure to a place where costs are optimized and, above all, shared across multiple entities and cloud providers. A little-known fact: running PyTorch CI costs north of USD 1.5M per month! These costs are currently borne by a small number of organizations, Meta and AWS being the biggest contributors, followed by NVIDIA, AMD, and others. The TAC is now working to make it possible for more entities to contribute to these efforts across multiple cloud providers.

The Ecosystem Working Group has revamped the PyTorch Ecosystem (PyTorch Landscape), a collection of active, high-quality projects that PyTorch users can benefit from across different domains. Interestingly, we have seen many contributions coming from science verticals, in addition to cutting-edge projects that power modern generative AI. This is a testament to PyTorch’s ability to serve diverse communities, from cutting-edge research to production workloads. It is certainly a good look for the future, whatever form AI may take in one to several years from now.

The Accelerator Integration Working Group has been focusing on providing design guidance and tooling for entities to enable new hardware accelerators in PyTorch (out-of-core) beyond CUDA and ROCm. With the flexibility of eager mode and its compiler support, PyTorch has become the ideal frontend to novel accelerators. This way, users will be able to leverage amazing innovation in the space of accelerated computing through the familiar PyTorch experience.

Last but not least, the recently formed Security Working Group has begun to surface ongoing work on supply chain-related threats, which require continuous attention, and focused on processes for managing CVEs.

In 2026, PyTorch’s footprint is going to grow both wide (training, inference, RL, agentic AI) and deep (out-of-core accelerators, kernel authoring, distributed infrastructure). Keeping this growth organic across all projects (PyTorch, DeepSpeed, vLLM, and Ray) and centered around developers is the primary goal of the TAC. As an immediate step, we will enhance the visibility of development roadmaps across all contributing organizations and provide support for ongoing cooperation among all PyTorch Foundation projects.