Google Release Notes

When editing code in a modern IDE or editor, developers rely on its refactoring features to automate common transformations. Today, we are excited to introduce interactive refactoring in gopls, powered by a new capability we are proposing for the Language Server Protocol (LSP) that brings dynamic, multi-step dialogs directly into your favorite editor. Crucially, we designed this capability (in collaboration with the Dart team) not just for Go, but as an open standard for all programming languages and editor ecosystems. Working support is already available in gopls v0.24.0 and the official Go extension for VS Code v0.56.0.

What is the Language Server Protocol (LSP)?

The LSP is an open standard that decouples language-specific features from specific text editors. As you navigate and edit code, your editor (such as VS Code, Neovim, or Emacs) and a language server (like gopls) engage in a continuous JSON-RPC exchange to provide features like autocomplete, hover documentation, diagnostics, and code actions.

Multi-step code transformation

Today, almost every code transformation in the LSP is like a function of no parameters: you trigger the operation, and the server immediately computes the edits. (Renaming a symbol is the sole exception: because it is a function of one parameter, the desired new name, it required its own dedicated PrepareRename RPC in the protocol.)

The language server must deduce the user’s intent from context alone, namely the cursor position and the enclosing syntax tree. When that context is not enough, the server is forced into one of two choices: apply a one-size-fits-all default, or refrain from offering the transformation altogether. The limitation lies not in gopls’s ability to compute the necessary edits, but in the LSP’s lack of a mechanism for language servers to ask the user for input.

For many transformations, this parameterless model works well. But many others need additional input from the user: which struct tags to add and in what naming convention, which interface to implement, which file to move a declaration to. Without a way to ask, gopls could only guess—“Add struct tags”, for example, always produced json tags in camelCase—or not offer the refactoring at all. With interactive refactoring, language servers can now easily provide new operations with one or more parameters.

Our LSP interactive refactoring proposal solves this by establishing a standard mechanism for language servers to collect user input before computing text edits. For Go developers, this unlocks a suite of long-awaited refactorings, including:

• golang/go#70583: Move Declaration
• golang/go#38028: Change Signature
• golang/vscode-go#1547: Implement Interface
• golang/vscode-go#2002: Modify Struct Tags

among many others.

Interactive refactorings in action

Adding and removing struct tags (gopls v0.23.0)

When configuring serialization formats, developers frequently need custom tags and casing conventions. Previously, running “Add struct tags” unconditionally injected json tags using camelCase formatting.

With interactive refactoring:

1. Place your cursor on any struct definition and select the “Add struct tags” code action.
2. An input dialog appears, pre-filled with json, allowing you to customize any combination of tags (such as json,yaml,db).
3. A second dialog lets you select your desired naming convention (such as camelCase, snake_case, or PascalCase).
4. Gopls generates and applies the formatted struct tags across your type definition.

Here is the before-and-after transformation:

type UserProfile struct {
    ID        int64
    FirstName string
    LastName  string
    EmailAddr string
}

type UserProfile struct {
    ID        int64  `json:"id" db:"id"`
    FirstName string `json:"first_name" db:"first_name"`
    LastName  string `json:"last_name" db:"last_name"`
    EmailAddr string `json:"email_addr" db:"email_addr"`
}

Similarly, “Remove struct tags” now asks you for the specific tag keys you wish to delete (for example, removing only db tags while preserving the json tag), rather than wiping out all struct tags indiscriminately.

Implementing interfaces with dynamic symbol search

When creating a type to satisfy an interface, developers previously had to copy the interface declaration and manually turn it into a set of methods on the receiver type (or rely on external tools like impl by manually typing the receiver and qualifying the name of the interface).

Since gopls v0.23.0, with interactive refactoring:

1. Place your cursor on any concrete type and select the “Add methods to X to implement an interface…” code action.
2. A text entry field appears, inviting you to choose the name of an interface type. It makes dynamic queries to gopls to auto-complete names of types in your workspace and the standard library (for example, maphash.Hasher).
3. If the selected interface has type parameters, gopls asks for a concrete type argument for each type parameter (such as Foo).
4. Gopls generates complete method stubs with appropriate receiver names and instantiated method signatures.

type Foo struct{}

type MyHasher struct{}

// Equal implements [maphash.Hasher].
func (m *MyHasher) Equal(x Foo, y Foo) bool {
    panic("unimplemented")
}

// Hash implements [maphash.Hasher].
func (m *MyHasher) Hash(*maphash.Hash, Foo) {
    panic("unimplemented")
}

Moving declarations across files and packages (preview)

Moving declarations manually by cutting and pasting can easily break references and requires tedious import cleanup across multiple files. While scheduled for an upcoming gopls release, our working implementation already demonstrates how interactive file selection streamlines cross-file and cross-package moves:

1. Place your cursor on any top-level declaration and select the “Move declaration X” code action.
2. A file picker dialog lets you choose an existing destination .go file or specify a new file path.
3. Gopls moves the declaration along with its dependent declarations (such as unexported helpers or methods) while leaving unrelated symbols in place, updates references across your workspace, and cleans up imports in both the source and destination files.

In the example below, we move the type Foo from package from to package to. Its method Print and the unexported constant bar, which only Foo uses, move along with it, while the unrelated function Baz stays behind:

// from/from.go
package from

import (
    "fmt"
    "strings"
)

const bar = "bar"

// Doc comment for Foo
type Foo struct{}

func (f Foo) Print() {
    fmt.Println(bar)
}

func Baz() string {
    return strings.ToUpper("baz")
}

// from/from.go
package from

import "strings"

func Baz() string {
    return strings.ToUpper("baz")
}

// to/to.go
package to

import "fmt"

const bar = "bar"

// Doc comment for Foo
type Foo struct{}

func (f Foo) Print() {
    fmt.Println(bar)
}

Slaying the dragon (gopls v0.24.0)

As a demonstration of multi-step interactive dialogs and a self-contained test case for client editor implementations, gopls v0.24.0 offers a “Slay the dragon” code action when you place your cursor on a package-level variable named dragonSlayer (for example, var dragonSlayer string). Happy hunting!

What’s on the Horizon

Interactive refactoring establishes a foundational capability in gopls, opening up several exciting directions on our roadmap:

• Change signature refactoring (#38028): Adding, removing, or reordering function parameters across a workspace requires input that cannot be deduced from syntax alone, such as the new parameter order or the default argument expression to insert at existing call sites. Interactive forms allow gopls to collect these details before rewriting the declaration and all call sites.
• Interactive conflict resolution: When a code transformation encounters naming collisions, identifier shadowing, or ambiguous references, gopls can ask the user for guidance, such as asking for permission to proceed or offering to rename conflicting symbols on the fly.
• Interactive commands beyond code edits: Because interactivity is modeled at the LSP command layer, it naturally generalizes to non-edit server operations that require user configuration, such as configuring test or benchmark runs with profiling flags (CPU, memory, tracing).

Getting Started and Sharing Feedback

Interactive refactoring is available in gopls v0.24.0 and vscode-go v0.56.0 (with proof-of-concept client integrations also explored for Neovim and Emacs).

We would love to hear your thoughts as we continue refining interactive code actions in gopls:

• For general feedback or feature requests, file an issue on the Go issue tracker.
• To read the full technical specification—including the stateless form protocol design and alternative approaches we explored—or to join the discussion with the broader LSP community, check out the LSP Interactive Code Actions design document and the ongoing conversation in microsoft/language-server-protocol#1164.

(Special thanks to Alan Donovan, Alex Putman, Brian Wilkerson, Danny Tuppeny, Hana Kim, Madeline Kalil, Peter Weinberger, and Robert Findley for their insights, discussions, feedback, and collaboration on this work.)

Happy refactoring!

Google Meet now uses post-quantum cryptography

Calls in Google Meet will use post-quantum cryptography (PQC) for extra protection, starting now with laptop web clients and meeting room hardware, with mobile support coming soon. There are no visible changes, and you can continue using Meet normally. The updated encryption protects your data against potential future quantum computer threats.

Configure Access Management and Access Approvals policies using classification labels with rules in Assured Controls

We’re introducing Assured Controls rules in the Google Workspace Admin Console, giving administrators a more granular, resource-centric way to enforce Access Management and Access Approvals policies on Google Drive files.

Find your routine next steps on the post-meeting screen in Google Meet

We are introducing next steps in Google Meet. Powered by Gemini and Workspace Studio, our new capability allows users to automate repetitive post-meeting tasks directly within Google Workspace. Next steps help you transform meeting discussions into definitive actions, like drafting follow-up emails in Gmail or exporting action items to Google Tasks.

Switch from live stream viewer to contributor in Google Meet on Android

You can now switch from watching a Google Meet live stream to participating with audio and video directly on Android. This feature is available for viewers who have been invited to both the live stream and the main meeting.

An update on the launch of skills in the Gemini app and Workspace

As previously announced, skills in the Gemini app are starting to roll out today, with an expected completion by mid-November. In the coming weeks, we’ll also introduce critical features like the ability to share Gemini app skills and an integration with Google Drive. We’ll post on the Workspace Updates blog as soon as those capabilities start rolling out.

Now generally available: Preview client-side encrypted PDF and image files directly in Google Drive

Google Drive now supports previewing CSE files directly within Drive. Previously, users had to download encrypted non-native files to their local devices in order to see the contents. With this capability, authorized users can preview encrypted content instantly in their web browser without ever leaving Drive.

Gmail’s AI Inbox is rolling out to paid Workspace users

Earlier this year, we launched AI Inbox in Gmail which helps users catch up on what matters most. Starting today, we’re expanding AI Inbox to paid Google Workspace users. By highlighting key actionable to-do’s and summarizing priority work updates across your emails, AI Inbox makes it easier to stay on top of daily business workflows.

Gmail Live is rolling out to paid Workspace users

Following our initial rollout of conversational AI voice capabilities, we are bringing Gmail Live to Google Workspace customers on mobile (Android and iOS). Using our latest Gemini models, Gmail Live delivers a low-latency, inbox-aware voice search experience that lets you ask questions naturally and hear synthesized answers directly from your email inbox.

The announcements above were published on the Workspace Updates blog over the last week. Please refer to the original blog posts for complete details.

Preview: Want to try out bindless rendering? It's now available for early experimentation on Android, Linux, and Windows. Head over to Brandon's blog post to learn how to enable it and see the live demo in action!

WGSL fragment_depth extension

Warning: The fragment_depth WGSL extension is temporarily disabled on all platforms due to shader compilation errors on Windows. See issue chromium:571186739.

In geometry-intensive render passes, early-Z optimizations are developers' best friend. They provide a massive performance boost by letting the GPU discard hidden pixels before running expensive fragment shaders. If a rasterized depth fails the depth test, the GPU skips the fragment shader entirely, provided the shader doesn't have other side effects.

If you want to read into how hardware handles this, MJP has an excellent write-up on When Does Early-Z Have to be Disabled?.

While custom depth manipulation is useful, doing it in your fragment shader comes with a hidden tax. Writing to @builtin(frag_depth) inside a fragment shader typically forces drivers to disable these early-Z optimizations for the entire draw call. This happens because driver heuristics can't guarantee that the shader's calculated output depth matches the depth interpolated by the rasterizer.

To address this performance penalty, the WGSL extension fragment_depth lets you specify a less or greater depth mode name on @builtin(frag_depth) to explicitly state how the written depth compares to the interpolated depth, enabling the GPU to safely apply early-Z optimizations.

This language extension can be feature-detected in JavaScript using navigator.gpu.wgslLanguageFeatures. It's recommended to use a requires-directive to signal the potential for non-portability with requires fragment_depth; at the top of your WGSL shader code. See the following example and intent to ship.

Texture compression unaligned

The "texture-compression-unaligned" GPU feature enables the creation of compressed textures with dimensions that aren't integer multiples of the block size (such as 4x4 for BC, ETC2, and ASTC formats). Previously, WebGPU strictly required texture sizes to align with these block boundaries. By removing the need to pad or scale textures to fit block alignments, this feature preserves original compression fidelity without introducing scaling distortion. See the intent to ship.

The following code snippet checks if the adapter supports texture compression unaligned and, if available, requests a device with it.

Many thanks to external contributor Ignacio Castaño of spark.js for driving this feature, spec and CTS work!

srgb-linear and display-p3-linear color spaces

With the addition of the "srgb-linear" and "display-p3-linear" predefined color spaces, the WebGPU canvas context can now render directly into extended-range linear color spaces to support wide-gamut displays. These color spaces maintain a linear relationship between pixel values and physical luminance. This makes them ideal for physical light rendering in games as well as spatial processing tasks like anti-aliasing, interpolation, and decimation. See the intent to ship and the Particles (HDR) sample PR #574.

Additional snorm10-10-10-2 vertex format

The "snorm10-10-10-2" vertex format is a packed 32-bit format holding four signed normalized values: three 10-bit components (r, g, b) and one 2-bit component (a). With this format, you can efficiently store attributes, like 3D normal vectors with an extra 2-bit scalar, or alignment flag while saving memory bandwidth. See spec PR 6491.

f16 support on Linux for NVIDIA

The optional "shader-f16" feature, which provides support for 16-bit floating-point values in WGSL, is now supported on Linux for recent NVIDIA GPU drivers. See issue chromium:42251215.

Dawn updates

You can now query the LUID of the underlying DXGIAdapter for a given GPU adapter using the WGPUAdapterPropertiesD3D struct. See issue chromium:562849566.

This covers some of the key highlights. Check out the exhaustive list of commits.

What's New in WebGPU

A list of everything that has been covered in the What's New in WebGPU series.

Chrome 155-156

• WGSL fragment_depth extension
• Texture compression unaligned
• srgb-linear and display-p3-linear color spaces
• Additional snorm10-10-10-2 vertex format
• f16 support on Linux for NVIDIA
• Dawn updates

Feature

Gemini Enterprise: Anthropic models are available in the Gemini Enterprise app

Administrators can make Anthropic models—Claude Opus 5.5 and Claude Sonnet 5.5—available to users in the Gemini Enterprise app. After an administrator turns on a model in the Enable third-party models section of the Feature Management tab, users can select the model in the model selector. Claude models are available in the global location and the us and eu multi-regions, and are charged on a pay-as-you-go basis.

This feature is generally available. For more information, see Enable third-party models.

Client-side encryption (CSE) gives organizations ultimate control over who can access their most confidential data, using customer-managed encryption keys that render the data unreadable to unauthorized third parties, including Google. Google Drive now supports previewing CSE files directly within Drive. Previously, users had to download encrypted non-native files to their local devices in order to see the contents. With this capability, authorized users can preview encrypted content instantly in their web browser without ever leaving Drive.

The feature improves productivity and strengthens security by removing the need for unnecessary downloads. At launch, previewing is available only in Drive, and only for:

• Encrypted PDF documents
• Encrypted image file formats

Getting started

• Admins: There is no admin control for this feature.
• End users: This feature will be on by default. Visit the Help Center to learn more.

Rollout pace

• Rapid Release and Scheduled Release domains: Extended rollout (potentially longer than 15 days for feature visibility) starting on October 15, 2026

Availability

• Enterprise: Enterprise Plus
• Education: Education Standard and Plus
• Other Editions: Frontline Plus, Assured Controls, Assured Controls Plus

Resources

• Google Workspace Admin Help: About client-side encryption
• Google Workspace Help Center: Get started with encrypted files in Drive, Docs, Sheets & Slides
• Google Workspace Updates Blog: Preview client-side encrypted PDF and image files directly in Google Drive, now available in beta

Finding critical information on the go often involves sifting through lengthy email threads and switching between multiple messages while your hands are busy commuting or multi-tasking. Following our initial rollout of conversational AI voice capabilities, we are bringing Gmail Live to Google Workspace customers on mobile (Android and iOS). Using our latest Gemini models, Gmail Live delivers a low-latency, inbox-aware voice search experience that lets you ask questions naturally and hear synthesized answers directly from your email inbox. We’ve included sources for users to easily view the emails where the information is being pulled, as well as the following improvements:

• See where the information is coming from: An email source card is now surfaced prominently at every conversational turn.
• Ability to pick the voice of your choice: You can now pick your preferred voice directly from Gmail Live.

Common use cases include:

• “What is the order status for Black Forest Construction Supply?”
• “When is my next mandatory training due?”
• “Show me the latest update from my manager, John.”
• “What gate is my flight leaving from tomorrow?”

Getting started

• Admins: This feature will be ON by default for organizations with Gemini in Workspace access and respects existing smart features and personalization admin settings. Visit the Help Center to learn more.
• End users: On supported iOS and Android devices, tap the Live entry point in the Gmail search bar to begin a voice session. First-time users will be prompted to grant microphone access. Visit the Help Center to learn more.

Rollout pace

• Rapid Release and Scheduled Release domains: Gradual rollout (up to 15 days for feature visibility) starting on October 15, 2026

Availability

• Business: Business Starter, Standard, and Plus
• Enterprise: Enterprise Starter, Standard, and Plus
• Frontline: Frontline Plus
• Nonprofits: Google Workspace for Nonprofits
• Add-ons: Gemini Business, Gemini Enterprise, AI Expanded Access, and AI Ultra Access
• Education Add-ons: Google AI Pro for Education
• Consumer: Google AI Plus, Pro, and Ultra

Note that this feature is currently only available to users in the US with EN-US as their language.

Resources

• Google Workspace Admin Help: Turn Gemini features on or off for users
• Google Help: Talk naturally with Gmail Live
• Google Workspace Updates Blog: Use your voice to get more done in Gmail, Docs, and Keep

Earlier this year, we launched AI Inbox in Gmail which helps users catch up on what matters most. Starting today, we’re expanding AI Inbox to paid Google Workspace users. By highlighting key actionable to-do’s and summarizing priority work updates across your emails, AI Inbox makes it easier to stay on top of daily business workflows.

AI Inbox’s core capabilities:

• Suggested to-dos: Automatically extracts action items, deliverables, and deadlines embedded within email conversations. Teams and business leaders gain clear visibility into critical follow-ups without manual note-taking or scanning through dense threads.
• Topics to catch up on: Delivers clear, context-rich summaries of your most important topics, across multi-message threads and rapid back-and-forth discussions. Users can reference this section to get caught up on the latest key decisions and status changes.

Getting started

• Admins: There is no admin control for this feature.
• End users: Eligible users can access AI Inbox directly within the Gmail desktop client or mobile app menu. Use our Help Center to learn more about AI Inbox.

Availability

• Business: Business Starter, Standard, and Plus
• Enterprise: Enterprise Starter, Standard, and Plus
• Education: AI Pro for Education
• Other Editions: Frontline Plus

Note that this feature is currently only available to users in the US with EN-US as their language.

Rollout pace

• Rapid Release domains: Gradual rollout (up to 15 days for visibility) started on October 12, 2026
• Scheduled Release domains: Gradual rollout (up to 15 days for visibility) starting on October 26, 2026

Note: AI Inbox will rollout later to Starter and Education editions in the coming months.

Resources

• Google Help: Manage to-dos & topics with AI Inbox
• Keyword: Gmail is entering the Gemini era

SDK Releases

The Firebase Android SDK for Cloud Firestore has been updated. For more details, check out the latest Android Release Notes. To get started with Firebase in Android, see Add Firebase to your Android Project.

The Firebase Android BoM (Bill of Materials) has been updated to v35.0.2. Learn how to add SDKs to your app using the Firebase BoM.

The Firebase SDK for Flutter (v5.0.0) is now available. This release includes changes in Cloud Functions, Firebase AI Logic, Core, Firebase In-App Messaging and Cloud Messaging, and bug fixes in several products.

The Firebase SDK for Unity (v14.0.0) is now available. This release includes changes to Authentication, Firebase AI, and Remote Config, as well as other changes.

New antibiotics are urgently needed to help with rising levels of antimicrobial resistance, but searching for new therapeutics is often a slow, labor-intensive process. With Google Antigravity, our agentic development platform, this process can now be made easier.

Google Antigravity provides an agentic science workbench that empowers biologists to discover, structurally evaluate, and prioritize promising targets quickly, compressing what used to be a fragmented search over multiple databases into a single session. It also helps researchers scan through millions of previously uncharacterized proteins in the UniProt database using ProtNLM, a model that predicts biological function from amino acid sequences.

This technical walkthrough shows how biologists used Google Antigravity to uncover a novel antimicrobial peptide candidate which has predicted activity against the pathogens involved in respiratory tract infections. The lead identified here is now undergoing wet-lab validation.

Finding new antimicrobial peptides

Rising antimicrobial resistance is one of the most pressing global health crises of our time and could result in an estimated 10 million annual deaths globally by 2050. To prevent this, we urgently need to discover novel therapeutics. Antimicrobial peptides (AMPs), particularly bacteriocins, offer a promising alternative to traditional antibiotics because they have naturally evolved to target fundamental vulnerabilities in competing bacteria, from cell envelopes to essential intracellular machinery, making it difficult for pathogens to develop resistance.

The exponential growth of genomic and metagenomic sequencing has populated global databases with billions of natural amino acid sequences. This pool of natural data has already produced globally used bacteriocins like Nisin, alongside recent genome-mined breakthroughs such as Darobactin, Dynobactin, and Lariocidin.

Many, however, remain locked within the unannotated "dark matter" of protein databases, with their function uncharacterized because they aren’t similar to known proteins. For example, the world's leading public resource of protein sequence and functional information, UniProt, holds millions of sequences with unknown functionality, transferred directly from genome sequencing projects.

To bridge this gap, Google developed ProtNLM (Protein Natural Language Model), a deep learning model trained to directly read the underlying evolutionary “grammar” of amino acid sequences. This allows the model to predict biological function directly from raw protein sequences, enriching millions of previously unnamed UniProt entries with high-confidence functional labels.

Overview of the ProtNLM pipeline translating raw amino acid sequences into natural-language biological annotations for unreviewed UniProtKB/TrEMBL entries. The functional annotation scope of the system covers protein names, function comments, subcellular locations, and GO terms, in addition to keywords.

Collaborative intelligence

Scientific discovery is rarely a single step process; finding viable candidate proteins requires human intuition and iteration to incorporate new empirical evidence. Working in Antigravity, the researcher and AI agent begin by setting a focused biological goal: find and computationally validate novel AMPs in Streptococcus pseudopneumoniae. During an interactive, multi-turn session the researcher steers the scientific strategy, deciding which questions to ask and what evidence to collect, while the agent handles the heavy lifting of cross-database orchestration, structural analysis, and literature synthesis.

Navigating a vast search space: The agent queries the database and filters millions of entries down to a handful of candidates worthy of attention. Here, the agent finds a bacteriocin (Uniprot ID: A0A0U0D591) with a length of 97 amino acids from the Lactococcin 972 family.

The candidate we uncover in this walkthrough represents a biologically plausible lead backed by structural and genomic evidence but it still requires wet lab validation. What makes this meaningful is how dramatically it lowers the barrier to everyday biological workflows, turning days of fragmented database triage into a single collaborative session. While this session focused on a narrow amino acid window in Streptococcus pseudopneumoniae, researchers can take the conversation in any direction, such as layering in new filtering criteria, exploring different sequence lengths, or targeting other priority pathogens. By broadening the search from human commensals to environmental microbes and beyond, scientists can guide the agent across UniProt to discover novel AMP candidates at scale.

A shared 3D canvas for interactive collaboration

A protein's 3D structure can help us understand its biological function. Examining a candidate’s predicted fold in space is key. To provide this end-to-end workflow in a single workspace, we are introducing the Biomolecular Structure Viewer, a 3D visualization tool embedded directly into Antigravity.

The researcher and agent work together over a shared visual state. As the agent retrieves structures from AlphaFold Database or the scientist’s own predictions, it can dynamically drive the viewer. For instance, it can highlight key functional regions to visually explain its hypotheses. Crucially, this awareness flows both ways: actions like highlighting specific residues or pinning notes directly onto a binding pocket are synchronised back to the agent. A researcher can simply mark a region of interest in 3D space and ask, for example, "How might this β-strand affect Lipid II binding?", allowing the agent to immediately reason over the exact structural context the scientist is looking at.

The Biomolecular Structure Viewer inside Antigravity showing the AlphaFold-predicted structure of the candidate bacteriocin, giving the researcher and agent a shared 3D canvas to inspect and annotate functional regions.

Accelerating Scientific Discovery

Historically, uncovering insights like those in the workflow demonstrated above required fragmented and specialised software: writing custom scripts to query databases, manually exporting files to 3D modelling programs, managing disconnected genomic tools and working with multiple experts to design the wet lab assays. Because wet-lab validation remains resource-intensive, narrowing the search space to only the highest-confidence leads upfront is critical. Using Google Antigravity allows researchers to navigate the vast biological search space efficiently while leveraging accurate protein function predictions from a domain-specific model.

Google Antigravity executes this end-to-end scientific reasoning in one place. This allows scientists to spend more time evaluating high-quality hypotheses, running experiments in the lab and solving research challenges.

Acknowledgements

We would like to acknowledge the contributions of the following team members: Maria Gabriela Cardoso, Victoria Johnston, Lexi Walker, Gena Hong, James King, Richard Green, Filip Radlinski, Artem Sobolev, Michael V. LeVine, Ruijie K. Zhang, Zachary Wu, Luca Schulz, Amy Danson, Tristan Oliver Kwan, Ryan Krueger, Oleg Kovalevskiy, Doug Fritz, Yunhan Xu, Sebastian Nowozin