Nov 3, 2026 – Nov 9, 2026

Improve distributed dataloader handlingPython · 112 + / 27 −

Introduces 4 new declarations in nemo/collections/common/data/lhotse/broadcasting.py.

Adds new core implementation rather than adjusting what was there. Tests changed with it, with code of their own.

nemo/collections/common/data/lhotse/broadcasting.py ↗ · 3 files

@@ -231,5 +254,67 @@ def _resolve_group_and_source(device_mesh, axes: Sequence[str]):      group = sub.get_group()     source_global_rank = int(sub.mesh.flatten()[0].item())-    _GROUP_CACHE[cache_key] = (group, source_global_rank)     return group, source_global_rank+++def _broadcast_packet(packet, group, src: int):+    """Broadcast one pre-serialized protocol packet over ``group``.++    Serializing before the first tensor collective lets the source replace an+    unpicklable data packet with a small error packet while receivers are still+    waiting for the packet size. Failures after a collective begins must be+    handled by the process-group timeout and distributed job teardown.+    """+    is_source = dist.get_rank() == src+    source_error = None+    if is_source:+        try:+            serialized = pickle.dumps(packet, protocol=pickle.HIGHEST_PROTOCOL)+        except Exception as error:+            source_error = error+            packet = _error_packet(error, "batch serialization failed")+            serialized = pickle.dumps(packet, protocol=pickle.HIGHEST_PROTOCOL)+    else:+        serialized = b""++    device = _broadcast_device(group)+    serialized_size = torch.tensor([len(serialized)], dtype=torch.long, device=device)+    dist.broadcast(serialized_size, src=src, group=group)++    if is_source:+        serialized_buffer = bytearray(serialized)

[masking] Fix packed sequences for abitrary mask formsPython · 49 + / 4 −

Introduces 3 new declarations in src/transformers/masking_utils.py.

Adds new core implementation rather than adjusting what was there. Tests changed with it, with code of their own.

src/transformers/masking_utils.py ↗ · 2 files

@@ -186,6 +190,38 @@ def inner_mask(batch_idx: int, head_idx: int, q_idx: int, kv_idx: int) -> bool:     return inner_mask  +def remap_positions_for_packed_sequence(mask_function: Callable, position_ids: torch.Tensor) -> Callable:+    """+    This function remaps the monotonically increasing `q_idx` and `kv_idx` to their actual per-sequence indices when we detect+    packed sequence format, i.e. several sequences inside the same batch dimension.+    Note that it is ensured that `position_ids.shape[1] == q_length == kv_length` here, so we can never have indexing problems here.+    If this was not the case, i.e. q_length < kv_length, we would need to infer the packed kv_position_ids, since the `position_ids`+    in the argument here are the packed query positions. Then we would need to remap q_idx and kv_idx with a different tensor.+    """++    def inner_mask(batch_idx: int, head_idx: int, q_idx: int, kv_idx: int) -> bool:+        return mask_function(batch_idx, head_idx, position_ids[batch_idx, q_idx], position_ids[batch_idx, kv_idx])++    return inner_mask+++def packed_sequence_compatibility_function(+    mask_function: Callable, position_ids: torch.Tensor, packed_sequence_mask: torch.Tensor+) -> Callable:+    """+    This function ensures compatibility of the current `mask_function` with packed sequence format, by making sure each sequence+    stays fully independent of all others, and the `q_idx` and `kv_idx` positions inside each sequence are correctly remapped to+    their actual values.+    Note that it is ensured that `position_ids.shape[1] == packed_sequence_mask.shape[1] == q_length == kv_length`, so we can never+    have indexing problems here.+    """+    # For packed sequences, we need to make sure each sequence are independent, as well as remapping the indices+    return and_masks(+        packed_sequence_mask_function(packed_sequence_mask),+        remap_positions_for_packed_sequence(mask_function, position_ids),+    )

Keep overrides of the deprecated gradient checkpointing methods workingPython · 36 + / 2 −

Introduces 3 new declarations in src/transformers/modeling_utils.py.

Adds new core implementation rather than adjusting what was there. Tests changed with it, with code of their own.

src/transformers/modeling_utils.py ↗ · 2 files

@@ -3129,6 +3129,19 @@ def activation_checkpointing_enable(             activation_checkpointing_kwargs (dict, *optional*):                 Additional keyword arguments passed along to the `torch.utils.checkpoint.checkpoint` function.         """+        # Subclasses and wrappers of the deprecated `gradient_checkpointing_enable` stay the entry point until v6+        if self._is_overridden("gradient_checkpointing_enable"):+            self.gradient_checkpointing_enable(+                gradient_checkpointing_kwargs=activation_checkpointing_kwargs,+                every_n_layers=every_n_layers,+                offload=offload,+            )+        else:+            self._activation_checkpointing_enable(activation_checkpointing_kwargs, every_n_layers, offload)++    def _activation_checkpointing_enable(+        self, activation_checkpointing_kwargs=None, every_n_layers: int = 1, offload: bool = False+    ):         if not self.supports_gradient_checkpointing:             raise ValueError(f"{self.__class__.__name__} does not support activation checkpointing.") 

Add support for the xing4_0 C++ · 884 + / 1 −

Introduces 3 new declarations in src/models/xing4-0.cpp.

Adds new runtime rather than adjusting what was there. Tests changed with it, with code of their own.

src/models/xing4-0.cpp ↗ · 13 files

@@ -0,0 +1,828 @@+#include "models.h"++#include <cmath>+#include <stdexcept>+#include <string>++static size_t xing4_0_elem_offset(const ggml_tensor * t, int64_t i) {+    return ggml_row_size(t->type, i);+}++static ggml_tensor * xing4_0_view_1d(ggml_context * ctx, ggml_tensor * t, int64_t ne0, int64_t i0) {+    return ggml_view_1d(ctx, t, ne0, xing4_0_elem_offset(t, i0));+}++static ggml_tensor * xing4_0_view_2d(+        ggml_context * ctx,+        ggml_tensor  * t,+        int64_t        ne0,+        int64_t        ne1,+        int64_t        i0) {+    return ggml_view_2d(ctx, t, ne0, ne1, t->nb[1], xing4_0_elem_offset(t, i0));+}++// mean over the hyper-connection streams: [n_embd, hc, n_tokens] -> [n_embd, n_tokens]+static ggml_tensor * xing4_0_hc_mean(ggml_context * ctx, ggml_tensor * x) {+    const int64_t hc = x->ne[1];++    ggml_tensor * acc = ggml_view_2d(ctx, x, x->ne[0], x->ne[2], x->nb[2], 0);+    for (int64_t s = 1; s < hc; ++s) {+        acc = ggml_add(ctx, acc, ggml_view_2d(ctx, x, x->ne[0], x->ne[2], x->nb[2], s*x->nb[1]));+    }+    return ggml_scale(ctx, acc, 1.0f/hc);+}

[`Moe`] Fix grouped mm fallbackPython · 36 + / 4 −

Introduces 3 new declarations in src/transformers/integrations/moe.py.

Adds new core implementation rather than adjusting what was there. Tests changed with it, with code of their own.

src/transformers/integrations/moe.py ↗ · 2 files

@@ -233,22 +233,43 @@ def _grouped_mm_fallback_setup_context(ctx, inputs, output):     ctx.offs = inputs[2]  -def _grouped_mm_fallback_backward(ctx, grad_output):-    """Backward pass for `_grouped_mm_fallback`. Computes grad_input and grad_weight per expert group; offs has no gradient."""-    input, weight = ctx.saved_tensors+def _grouped_mm_fallback_bwd(+    input: torch.Tensor,+    weight: torch.Tensor,+    offs: torch.Tensor,+    grad_output: torch.Tensor,+) -> tuple[torch.Tensor, torch.Tensor]:+    """Backward implementation for the grouped matmul fallback."""     grad_input = torch.zeros_like(input)     grad_weight = torch.zeros_like(weight)      start = 0     # single cpu<->gpu sync point here,     # avoids multiple syncs inside the loop-    for i, end in enumerate(ctx.offs.tolist()):+    for i, end in enumerate(offs.tolist()):         if start == end:             continue         torch.mm(grad_output[start:end], weight[i].T, out=grad_input[start:end])         torch.mm(input[start:end].T, grad_output[start:end], out=grad_weight[i])         start = end +    return grad_input, grad_weight+++def _grouped_mm_fallback_backward_fake(+    input: torch.Tensor,+    weight: torch.Tensor,

InterPodAffinity: handle namespaceSelector in assigned-pod queueing hintsGo · 120 + / 23 −

Introduces 4 new declarations in pkg/scheduler/framework/plugins/interpodaffinity/plugin.go.

Adds new systems design rather than adjusting what was there. Tests changed with it, with code of their own.

pkg/scheduler/framework/plugins/interpodaffinity/plugin.go ↗ · 3 files

@@ -162,6 +163,47 @@ func GetNamespaceLabelsSnapshot(logger klog.Logger, ns string, nsLister listersv 	return } +// termsNeedNamespaceLabels reports whether matching any of the terms against+// any of the pods requires the pods' namespace labels. A term that already+// matches the pod namespace via Namespaces, or whose namespace selector is+// empty/nothing, can be evaluated without looking the namespace up.+func termsNeedNamespaceLabels(terms []fwk.AffinityTerm, pods ...*v1.Pod) bool {+	for i := range terms {+		term := &terms[i]+		if term.NamespaceSelector == nil ||+			labels.MatchesNothing(term.NamespaceSelector) ||+			term.NamespaceSelector.Empty() {+			continue+		}+		for _, pod := range pods {+			if pod == nil || term.Namespaces.Has(pod.Namespace) {+				continue+			}+			if term.Selector.Matches(labels.Set(pod.Labels)) {+				return true+			}+		}+	}+	return false+}++// namespaceLabelsForNamespace returns namespace labels, whether the namespace+// was found, and an error. A missing namespace is reported as found=false with+// no error; other lister errors are returned to the caller.+func (pl *InterPodAffinity) namespaceLabelsForNamespace(namespace string, needed bool) (labels.Set, bool, error) {+	if !needed {+		return nil, true, nil

client-go/rest/watch: add concurrent watch event decoderGo · 225 + / 1 −

Introduces 14 new declarations in staging/src/k8s.io/client-go/rest/watch/concurrent_decoder.go.

Adds new systems design rather than adjusting what was there. Tests changed with it, with code of their own.

staging/src/k8s.io/client-go/rest/watch/concurrent_decoder.go ↗ · 6 files

@@ -0,0 +1,208 @@+/*+Copyright The Kubernetes Authors.++Licensed under the Apache License, Version 2.0 (the "License");+you may not use this file except in compliance with the License.+You may obtain a copy of the License at++    http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++package watch++import (+	"fmt"+	"io"+	"sync"++	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"+	"k8s.io/apimachinery/pkg/runtime"+	"k8s.io/apimachinery/pkg/runtime/serializer/streaming"+	utilruntime "k8s.io/apimachinery/pkg/util/runtime"+	"k8s.io/apimachinery/pkg/watch"+)++type rawWatchEventResult struct {+	event *metav1.WatchEvent+	err   error

Improve Request Insights context menus and trace interactionsTypeScript · 356 + / 80 −

Introduces 8 new declarations in packages/next/src/next-devtools/dev-overlay/components/request-insights/request-insights-panel.tsx.

Adds new framework internals rather than adjusting what was there. Tests changed with it, with code of their own.

packages/next/src/next-devtools/dev-overlay/components/request-insights/request-insights-panel.tsx ↗ · 5 files

@@ -696,53 +743,165 @@ function RequestRow({     requestType.type === 'rsc'   )   const clockTime = formatClockTime(request.startTime)-  const bypassesProxy = request.proxyStatus === 'bypassed'    return (-    <button-      aria-label={`${isInstantInsights ? `Instant Insights for ${requestUrl}` : requestUrl}, ${requestType.accessibleLabel}, ${bypassesProxy ? 'Did not match the configured proxy, ' : ''}${formatDuration(request.durationMs)}, ${clockTime}`}-      className="request-insights-row"-      data-internal={isInstantInsights || undefined}-      data-nested={nested || undefined}-      data-page-load={pageLoad}-      data-selected={selected}-      onClick={onSelect}-      type="button"+    <ContextMenu.Root+      onOpenChange={onContextMenuOpenChange}+      open={contextMenuOpen}     >-      <span className="request-insights-status" data-status={request.status} />-      <span className="request-insights-route">-        {nested ? <NestedArrowIcon /> : null}-        <span className="request-insights-route-label">-          {isInstantInsights ? 'Instant Insights' : requestUrl}-        </span>-      </span>-      <span className="request-insights-duration">-        {formatDuration(request.durationMs)}-      </span>-      <span className="request-insights-meta request-insights-row-metadata">+      <ContextMenu.Trigger+        render={+          <button

feat(next/image): add internal image redirects (to match existing external image redirects)TypeScript · 131 + / 72 −

Introduces 3 new declarations in packages/next/src/server/image-optimizer.ts.

Adds new framework internals rather than adjusting what was there. Tests changed with it, with code of their own.

packages/next/src/server/image-optimizer.ts ↗ · 10 files

@@ -100,6 +100,77 @@ export interface ImageParamsResult {   minimumCacheTTL: number } +type ImageUrlParamResult =+  | { href: string; isAbsolute: boolean }+  | { errorMessage: string }++function validateUrlParam(+  url: string | string[] | undefined,+  imageData: ImageConfigComplete,+  isRedirect = false+): ImageUrlParamResult {+  // Note - We intentionally skip validation for local/remotePatterns when+  // validating redirect locations so that we don't break a src img redirect+  // to a new domain (e.g. github.com => githubusercontent.com).+  const { domains = [], remotePatterns = [], localPatterns } = imageData++  if (!isRedirect && domains.length > 0) {+    Log.warnOnce(+      'The "images.domains" configuration is deprecated. Please use "images.remotePatterns" configuration instead.'+    )+  }++  if (!url) {+    return { errorMessage: '"url" parameter is required' }+  } else if (Array.isArray(url)) {+    return { errorMessage: '"url" parameter cannot be an array' }+  }++  if (url.length > 3072) {+    return { errorMessage: '"url" parameter is too long' }+  }+

salm_automodel_ctc_10ms: calibrated 40 ms to 10 ms CTC timestampsPython · 961 + / 108 −

Introduces 23 new declarations in nemo/collections/speechlm2/parts/ctc_timestamp_utils.py.

Adds new core implementation rather than adjusting what was there. Tests changed with it, with code of their own.

nemo/collections/speechlm2/parts/ctc_timestamp_utils.py ↗ · 14 files

@@ -2207,14 +2681,229 @@ def _align_banded_ctc(aligner, prepared):             diarization_frame_seconds=prepared['diarization_frame_seconds'],             diarization_max_speaker_count=prepared['diarization_max_speaker_count'],         )+        calibration = prepared['config'].get('boundary_interpolation')+        if calibration is not None:+            # Use raw DP edges, before any VAD snapping or extending.+            _interpolate_word_boundaries(+                rows,+                ctc,+                record['ctc_step'],+                record['time_offset'],+                record['audio_duration'],+                diarization,+                mapping,+                calibration,+                aligner=aligner,+            )+            result['speaker_word_timestamps'] = aligner._public_word_timestamps(rows)+            result['boundary_interpolation'] = {+                'method': 'calibrated_edge_local_linear_interpolation',+                'estimated_grid_seconds': aligner.boundary_grid_seconds,+                'outside_words': sum(w.get('_outside_diarization', False) for w in rows),+            }         result['speaker_assignment_mode'] = 'token_distribution'         result['alignment_diagnostics']['failed_streams'] = failures         result['alignment_diagnostics']['one_pass'] = True         result['alignment_diagnostics']['banded'] = diagnostics-        results.append(_refine_word_timestamps(result, prepared['config']['max_word_frames']))+        results.append(+            _refine_word_timestamps(+                result,+                prepared['config']['max_word_frames'],+                onset_snap_seconds=aligner.onset_snap_seconds,

Windows unbuffered model loadC++ · 265 + / 35 −

Introduces 3 new declarations in src/llama-mmap.cpp.

Adds new runtime rather than adjusting what was there. Tests changed with it, with code of their own.

src/llama-mmap.cpp ↗ · 3 files

@@ -123,24 +207,159 @@ struct llama_file::impl {         li.QuadPart = offset;         BOOL ret = SetFilePointerEx(fp_win32, li, NULL, whence);         if (!ret) {-            throw std::runtime_error(format("read error: %s", GetErrorMessageWin32(GetLastError()).c_str()));+            throw std::runtime_error(format("seek error: %s", GetErrorMessageWin32(GetLastError()).c_str()));         }     } -    void read_raw(void * ptr, size_t len) {+    void read_raw_unsafe(void * ptr, size_t len) {+        if (len == 0) {+            return;+        }++        const size_t read_offset = tell();+        if (read_offset > size) {+            throw std::runtime_error("unexpectedly reached end of file");+        }++        if (!has_direct_io()) {+            const size_t read_size = std::min(len, size - read_offset);+            size_t bytes_read = 0;+            while (bytes_read < read_size) {+                const DWORD to_read = (DWORD) std::min<size_t>(read_size - bytes_read, MAXDWORD);+                DWORD chunk_read = 0;+                BOOL result = ReadFile(fp_win32, reinterpret_cast<char *>(ptr) + bytes_read,+                                       to_read, &chunk_read, NULL);+                if (!result) {+                    throw std::runtime_error(format("read error: %s", GetErrorMessageWin32(GetLastError()).c_str()));+                }+                if (chunk_read < to_read) {+                    throw std::runtime_error("unexpectedly reached end of file");+                }

model : add Ripple (ricursiveai)C++ · 265 + / 0 −

Introduces 3 new declarations in src/models/ricursive.cpp.

Adds new runtime rather than adjusting what was there. Tests changed with it, with code of their own.

src/models/ricursive.cpp ↗ · 15 files

@@ -0,0 +1,236 @@+#include "models.h"++void llama_model_ricursive::load_arch_hparams(llama_model_loader & ml) {+    ml.get_key(LLM_KV_ATTENTION_LAYERNORM_RMS_EPS, hparams.f_norm_rms_eps);+    ml.get_key(LLM_KV_EMBEDDING_SCALE,             hparams.f_embedding_scale, false);+    // optional: absent or 0 means no clamp (the reference tests `if clamp_threshold:`); a scalar applies to every layer+    ml.get_key_or_arr(LLM_KV_SWIGLU_CLAMP, hparams.swiglu_clamp, hparams.n_layer_all, false);+    for (uint32_t il = 0; il < hparams.n_layer_all; ++il) {+        if (!std::isfinite(hparams.swiglu_clamp[il]) || hparams.swiglu_clamp[il] < 0.0f) {+            throw std::runtime_error(format("ricursive: swiglu_clamp for layer %u must be finite and non-negative, got %g", il, hparams.swiglu_clamp[il]));+        }+    }++    if (hparams.n_embd_head_k() != hparams.n_embd_head_v()) {+        throw std::runtime_error("ricursive: key_length and value_length must be equal");+    }++    // RoPE is only applied on the SWA layers, so a model without SWA would have no positional encoding+    ml.get_key(LLM_KV_ATTENTION_SLIDING_WINDOW, hparams.n_swa);+    if (hparams.n_swa == 0) {+        throw std::runtime_error("ricursive: sliding_window must be > 0");+    }+    hparams.swa_type = LLAMA_SWA_TYPE_STANDARD;+    if (ml.get_arr(LLM_KV_ATTENTION_SLIDING_WINDOW_PATTERN, hparams.is_swa_impl, false)) {+        // load_swa_pattern only bounds the array by LLAMA_MAX_LAYERS: a short one would leave the last layers dense and without RoPE+        uint32_t n_entries = 0;+        ml.get_arr_n(LLM_KV_ATTENTION_SLIDING_WINDOW_PATTERN, n_entries);+        if (n_entries != hparams.n_layer()) {+            throw std::runtime_error(format("ricursive: sliding_window_pattern has %u entries, expected %u", n_entries, hparams.n_layer()));+        }+    } else {+        // default: every 5th layer is global (RicursiveConfig layer_types: full attention iff i % 5 == 4)+        load_swa_pattern(ml, 5);