Microsoft bringt in Version 1.123 von Visual Studio Code weitere neue Features für den Umgang mit großen Sprachmodellen. Dazu gehören synchronisierte Chat-Sessions über mehrere Geräte hinweg, ein vergrößertes Kontextfenster für spezielle Modelle und die Möglichkeit, multiple Agenten-Fenster parallel zu öffnen.

Synchronisierte (Agenten-)Chats

Als neue Standardfunktion synchronisiert Visual Studio Code nun Chat-Sessions zum GitHub-Account seiner Nutzerinnen und Nutzer, inklusive aller lokalen Agenten-Sessions. Wie Microsoft betont, seien die synchronisierten Chats privat, außer wenn Nutzer sie explizit teilen. Auf github.com erscheinen die Chats im Agents-Tab eines Repositories und lassen sich durchsuchen.

Wer die Synchronisierung nicht nutzen will, setzt die auf Organisationsebene bestehende Einstellung chat.sessionSync.enabled auf false.

Agentenvergleich auf einen Blick

Das Preview-Feature Agents Window hat eine neue Funktion erhalten: Neben einer geöffneten Agenten-Session lässt sich nun eine zusätzliche in „Side by Side“-Ansicht öffnen. Um eine weitere Session zu öffnen, wählen Entwicklerinnen und Entwickler im Kontextmenü einer Session innerhalb der Session-Liste Open to the Side aus, ziehen die gewünschte Session per Drag & Drop in den Sessions-Ansichtsbereich oder wählen sie bei gedrückter Alt-Taste aus.

Dabei ist zu beachten, dass jeweils nur eine der sichtbaren Sessions aktiv ist. Eine neue ausgewählte Session wird automatisch zur aktiven Session View, außer wenn die vorherige Session angepinnt wurde. Das Anpinnen erfolgt über die Pin-Aktion in der oberen rechten Ecke der View.

Ein weiteres Update betrifft das Kontextfenster unterstützter Anthropic- und OpenAI-Modelle: Es kann nun eine Million Token umfassen. Diese Erweiterung soll es Usern ermöglichen, mit deutlich größeren Codebasen zu arbeiten sowie längere Konversationen zu führen, ohne wichtigen Kontext einzubüßen.

Weitere Details zu den Neuerungen in Visual Studio Code 1.123 lassen sich der Ankündigung entnehmen.

Dabei handelt es sich nicht um die einzigen Updates im Bereich KI von Microsoft: Im Rahmen der in dieser Woche stattgefundenen Hauskonferenz Microsoft Build wurde unter anderem eine eigenständige Desktopanwendung für GitHub Copilot vorgestellt.

(mai)

IAsyncEnumerable ist die in .NET Core 3.0 eingeführte asynchrone Variante von IEnumerable. Sie ermöglicht asynchrone Streams: das schrittweise, nicht-blockierende Iterieren über Daten, die asynchron bereitgestellt werden.

LINQ-Operationen auf IAsyncEnumerable erforderten bisher das NuGet-Paket System.Linq.Async. Nun ist diese Funktionalität im Kern von .NET verfügbar.

Folgender Code nutzt Where() und OrderBy() mit IAsyncEnumerable:

namespace NET10_Console.FCL;

using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;

public readonly record struct Kabinettsmitglied(string Name, string Amt);

/// 

/// LINQ auf IAsyncEnumerable erforderte bisher NuGet-Paket System.Linq.Async
/// 
public class FCL10_LINQAsyncEnumerable
{
 public async Task Run()
 {
  CUI.Demo(nameof(FCL10_LINQAsyncEnumerable));

  // Hole Personen im Bundeskabinett
  var datenquelle = new Bundeskabinett().GetAll();

  // Asynchrone Iteration mit LINQ (Filtern und optional Sortieren)
  // Achtung: .OrderBy(x=>x.Name) führt dazu, dass foreach auf das letzte Element warten muss --> Vorteil von async entfällt :-(
  await foreach (var person in datenquelle.Where(x => x.Amt.Contains("ministerin")))
  {
   Console.WriteLine(DateTime.Now.ToLongTimeString() + ": " + person);
  }
 }

 public class Bundeskabinett
 {
  /// 

  /// Liefert alle Mitglieder des Bundeskabinetts (Stand: 21.09.2025) als Async-Stream.
  /// Quelle: Bundesregierung.de (siehe Code-Kommentar).
  /// 
  public async IAsyncEnumerable GetAll(
      [EnumeratorCancellation] CancellationToken cancellationToken = default)
  {
   // Quelle: 
   var daten = new List
        {
            new("Friedrich Merz", "Bundeskanzler"),
            new("Lars Klingbeil", "Bundesminister der Finanzen"),
            new("Alexander Dobrindt", "Bundesminister des Innern"),
            new("Dr. Johann Wadephul", "Bundesminister des Auswärtigen"),
            new("Boris Pistorius", "Bundesminister der Verteidigung"),
            new("Katherina Reiche", "Bundesministerin für Wirtschaft und Energie"),
            new("Dorothee Bär", "Bundesministerin für Forschung, Technologie und Raumfahrt"),
            new("Dr. Stefanie Hubig", "Bundesministerin der Justiz und für Verbraucherschutz"),
            new("Karin Prien", "Bundesministerin für Bildung, Familie, Senioren, Frauen und Jugend"),
            new("Bärbel Bas", "Bundesministerin für Arbeit und Soziales"),
            new("Dr. Karsten Wildberger", "Bundesminister für Digitales und Staatsmodernisierung"),
            new("Patrick Schnieder", "Bundesminister für Verkehr"),
            new("Carsten Schneider", "Bundesminister für Umwelt, Klimaschutz, Naturschutz und nukleare Sicherheit"),
            new("Nina Warken", "Bundesministerin für Gesundheit"),
            new("Alois Rainer", "Bundesminister für Landwirtschaft, Ernährung und Heimat"),
            new("Reem Alabali Radovan", "Bundesministerin für wirtschaftliche Zusammenarbeit und Entwicklung"),
            new("Verena Hubertz", "Bundesministerin für Wohnen, Stadtentwicklung und Bauwesen"),
            new("Thorsten Frei", "Bundesminister für besondere Aufgaben / Chef des Bundeskanzleramtes"),
        };

   foreach (var m in daten)
   {
    cancellationToken.ThrowIfCancellationRequested();
    yield return m;
    await Task.Delay(200); // Simuliere etwas Wartezeit
    await Task.Yield(); // sorgt für echte Asynchronität beim Streamen
   }
  }
 }
}

Ein Praxisbeispiel dazu: Folgender Code zeigt die Ausführung einer Reihe von HTTP-Aufrufen mit asynchroner Ausgabe der Ergebnisse via Task.WhenEach(). Hier ist nun ein Filtern mit Where() oder eine Sortierung mit OrderBy() möglich. Diese blockiert jedoch – wie üblich – die Weiterverarbeitung, bis das letzte Ergebnis vorliegt, und beeinträchtigt damit den Vorteil der asynchronen Ausführung.

public async Task Run()
{
 CUI.Demo(nameof(FCL10_LINQAsyncEnumerable));
 Console.WriteLine($"{DateTime.Now.ToLongTimeString()}: Starte Websiteabfragen...");
 using HttpClient http = new();
 Task t1 = http.GetAsync("
 Task t2 = http.GetAsync("
 Task t3 = http.GetAsync("
 Task t4 = http.GetAsync("
 Task t5 = http.GetAsync("
 Task t6 = http.GetAsync("
 Task t7 = http.GetAsync("
 // Liste aus Tasks
 List> taskList = new() { t1, t2, t3, t4, t5, t6, t7 };
 // WhenEach() gibt es seit .NET 9.0
 IAsyncEnumerable> taskList2 = Task.WhenEach(taskList);
 
 // NEU in .NET 10.0: LINQ auf IAsyncEnumerable
 taskList2 = taskList2.Where(x => x.Result.RequestMessage.RequestUri.ToString().Contains("dot"));
 taskList2 = taskList2.OrderBy(x => x.Result.RequestMessage.RequestUri.Host);

 await foreach (Task t in taskList2)
 {
  try
  {
   Console.WriteLine($"{DateTime.Now.ToLongTimeString()}: {t.Status} {t.Result?.RequestMessage?.RequestUri} = {t?.Result?.StatusCode}"); // Status des HTTP-Aufrufs
  }
  catch (Exception ex)
  {
   CUI.Warning(ex);
  }
 }
}

(rme)

Cloudflare übernimmt VoidZero, das Unternehmen hinter den JavaScript-Werkzeugen Vite, Vitest, Rolldown, Oxc und Vite+. Das gab der Cloud- und Netzwerkdienstleister am Donnerstag in einem Blogbeitrag bekannt. Mit der Übernahme wechselt auch das gesamte VoidZero-Team um Gründer Evan You zu Cloudflare. Zu den finanziellen Konditionen machen beide Unternehmen keine Angaben. Auch zum Zeitplan, zu möglichen behördlichen Genehmigungen und zu weiteren Abschlussbedingungen gibt es bislang keine weiteren Informationen.

Für Entwickler dürfte vor allem die Zukunft der Open-Source-Projekte zählen. Hier betonen Cloudflare und VoidZero explizit, dass Vite, Vitest, Rolldown, Oxc und Vite+ quelloffen, herstellerneutral und community-getrieben bleiben sollen. Die Projekte bleiben demnach wie gehabt Open-Source-Software. Und Anwendungen, die auf Vite aufbauen, sollen sich weiterhin unabhängig von Cloudflare auch auf anderen Plattformen betreiben lassen.

Wer ist VoidZero?

VoidZero stammt von Evan You, der auch das JavaScript-Framework Vue.js entwickelt hat. Das Unternehmen baut eine ganze Reihe von Werkzeugen für moderne Webanwendungen. Dazu gehören das Build- und Entwicklungswerkzeug Vite, das Test-Framework Vitest, der in Rust geschriebene Bundler Rolldown sowie die ebenfalls in Rust entwickelte Toolchain Oxc, die Komponenten zum Parsen, Linten und Formatieren von JavaScript- und TypeScript-Code mitbringt. Mit Vite+ will VoidZero diese Werkzeuge unter einer einheitlichen Toolchain zusammenführen.

Vor allem Vite hat sich in den vergangenen Jahren zu einer zentralen Infrastruktur des JavaScript-Ökosystems entwickelt. Das Werkzeug treibt längst nicht mehr nur Vue-Projekte an, sondern bildet auch die Grundlage zahlreicher Frameworks und Meta-Frameworks wie Nuxt, SvelteKit, Astro, Solid, Qwik oder Angular. Auch mehrere React-basierte Werkzeuge setzen inzwischen auf Vite.

Mehr Ressourcen und ein Millionenfonds

Cloudflare will zusätzliche Ressourcen in die Weiterentwicklung der Projekte stecken. Die Leitung sollen weiterhin Evan You und das bisherige VoidZero-Team übernehmen. Darüber hinaus richtet das Unternehmen einen Fonds über eine Million US-Dollar für das Vite-Ökosystem ein. Damit will Cloudflare Maintainer und weitere Community-Mitglieder unterstützen. Verwalten soll den Fonds das Vite-Kernteam. Ähnlich verfuhr Cloudflare eigenen Angaben zufolge bereits Anfang 2026 beim Web-Framework Astro: Auch dessen Team wechselte zu Cloudflare, ebenfalls unter Beibehaltung der Open-Source-Ausrichtung.

Hinter der Übernahme steckt eine Zusammenarbeit der Unternehmen, die schon länger läuft. Cloudflare und das Vite-Team arbeiten nach eigenen Angaben seit 2024 zusammen, unter anderem an der Environment API. Sie erlaubt es, Server-Code während der lokalen Entwicklung in anderen Laufzeitumgebungen als Node.js auszuführen.

Lokale Entwicklung näher an die Produktion

Damit adressiert die Schnittstelle ein altbekanntes Problem: Viele Anwendungen entstehen lokal unter Node.js, laufen in der Produktion aber in einer anderen Laufzeitumgebung. Genau diese Unterschiede zwischen Entwicklung und Produktion führen immer wieder zu Fehlern. Über die Environment API können Anbieter ihre eigenen Laufzeiten direkt in den lokalen Entwicklungsprozess einklinken. Bei Cloudflare übernimmt das die quelloffene Laufzeitumgebung workerd, die auch den Dienst Cloudflare Workers antreibt.

Die Übernahme soll außerdem die künftige Entwicklerplattform von Cloudflare prägen. Das Unternehmen will seine Werkzeuge stärker an Vite ausrichten. So soll das neue Cloudflare-CLI-Tool cf langfristig auf Vite-Workflows aufsetzen. Lokale Entwicklung, Builds und das Deployment auf die Cloudflare-Plattform würden dadurch enger zusammenrücken.

Vite soll Full-Stack werden

Auch für Vite selbst kündigen die Unternehmen weitergehende Pläne an. Das Projekt soll künftig stärker Full-Stack-Anwendungen unterstützen. Geplant sind unter anderem allgemeine Schnittstellen für Backends, APIs, Deployments und KI-Agenten. Diese Erweiterungen sollen aber plattformneutral bleiben und nicht exklusiv an Cloudflare-Dienste gebunden sein.

(fo)