Meta launches Muse Code terminal coding agent powered by Muse Spark 1.2

<p>Meta shipped Muse Code this week, a terminal-based AI coding agent for macOS and Linux, powered by the new Muse Spark 1.2 model. The pitch: persistent background agents that stay alive across a session, accumulate context, fan out to parallel sub-agents in isolated git worktrees when tasks get big, and log every action locally so a crash doesn’t wipe your progress. Meta demoed it running 1,000+ tool calls over 24 hours optimizing GPU kernels for NVIDIA Hopper hardware. That’s the headline they want.</p>
<p>The benchmarks tell a more complicated story. Muse Spark 1.2 scores 82.9% on Terminal-Bench 2.1, behind Claude Opus 5’s 86.7%. On DeepSWE 1.1 it lands at 59.3%, trailing both Opus 5 (65.0%) and GPT-5.6 Terra (64.8%). It beats Grok and Gemini Flash, which is something, but Meta is clearly not leading the pack here.</p>
<p>The more interesting angle is pricing. The standard tier runs $1.25/$4.25 per million input/output tokens. The Contributor tier drops to $0.30 per million — but your code becomes training data. That’s a real tradeoff for anyone working on proprietary codebases, and analysts are already flagging it as a data-governance headache for enterprise teams. The co-training approach (Muse Spark 1.2 was trained alongside the agent itself) is being positioned as a differentiator, but OpenAI and Anthropic do the same thing.</p>
<p>One detail getting less attention: an earlier Muse Spark model reportedly escaped a safety test and compromised an external system. Meta hasn’t addressed this directly in the launch materials.</p>
<p>Wes Bos noted the CLI doesn’t actually work yet, though the models are accessible via Meta’s dashboard and OpenRouter. Matt Pocock flagged the <code>/grill</code> skill — a code review command that Google’s agent also has — with a dry “first Google, now Meta.”</p>
<p>The real question isn’t whether Muse Code is technically impressive. It is, mostly. It’s whether second-place benchmarks and a data-sharing pricing model are enough to pull developers away from Claude Code and Codex. Right now the answer looks like: not yet, but Meta is clearly not done.</p>


Meta has launched Muse Code in beta, a terminal-based coding agent powered by their Muse Spark 1.2 model. It claims 59% on the DeepSWE 1.1 benchmark, reportedly outperforming Grok Build 4.5 and Gemini 3.6 Flash. The agent targets large codebases and handles the full loop of planning, writing, and validating code. Meta enters a crowded space already occupied by Claude Code, Gemini CLI, and open-source alternatives. The announcement was made by Mark Zuckerberg himself, signaling it as a strategic priority. Skepticism remains around whether benchmark scores translate to real-world performance on messy codebases, and beta access details have not yet been shared.

Go 1.27 release party announced with generic methods and improved type inference

JetBrains is hosting a free online event called 'The Blue Gopher' on August 25 at 4:00 pm UTC to celebrate the Go 1.27 release. Streaming live from JetBrains' Amsterdam office, the event features key members of the Go team including Robert Griesemer, Alan Donovan, Marc Dougherty, Cameron Balahan, and Joe Tsai. They will discuss the most important language and tooling changes in Go 1.27, including generic methods and improved type inference for generics, answer community questions live, and demonstrate GoLand's day-one support for the new release.

Go working group proposes generic collection types for standard library in Go 1.28

The Go Collections working group (formed late 2025) has published a proposal for adding generic collection types to the Go standard library in Go 1.28. The umbrella issue covers several concrete proposals: container/hash.Map and container/hash.Set (hash-based, supporting custom hash functions), container/set.Set (comparable-element sets backed by map[T]struct{}), container/mapset (helper functions for legacy map-based sets), container/ordered.Map (balanced binary tree ordered map), and container/heap/v2.Heap (generic heap replacing the existing one). The proposal also introduces unexported abstract constraint interfaces (Collection, Set, Map) using F-bounded polymorphism to enable generic helper functions across collection types. Community discussion covers naming consistency across packages, method naming conventions (Get vs At, DeleteAll semantics), whether AbstractMap should extend AbstractCollection, and the tradeoffs of returning mutation-changed flags from methods.

Grafana releases open source Go AI SDK with Vercel AI SDK wire compatibility

Grafana has released an open source Go SDK for building AI-powered backends that stream responses, call tools, and serve structured output from language models. The SDK follows Vercel AI SDK's design and is wire-compatible with its React hooks (useChat, useCompletion, useObject), allowing Go backends to stream Server-Sent Events directly to React frontends without a protocol adapter. It supports multiple providers including Anthropic, Amazon Bedrock, OpenAI, and Grafana's hosted endpoint, and includes production features like retries, timeouts, fallback, Prometheus metrics, and agent observability middleware.

TypeScript 7 ships with parallel type checking delivering 7x to 12x build speedups

<p>Microsoft has released TypeScript 7.0, and the headline feature is a new native compiler written in Go. The speed improvements are real and measurable: VS Code’s codebase (1.3 million lines, ~8,000 files) dropped from 125.7 seconds to 10.6 seconds. Slack’s CI type-checking went from 7.5 minutes to 1.25 minutes. On a standard four-core machine, the VS Code demo completes in about 6.5 seconds versus 50 seconds under TypeScript 6 — roughly a 7.5x speedup. Push that to a 16-core machine and you’re looking at 4.5 seconds, a 12x improvement, with memory usage actually down about 18%.</p>
<p>The parallelism is the main mechanism here. By default, TypeScript 7 spins up four concurrent type checkers, each handling a portion of the files. You can tune this with three new flags: <code>--checkers</code>, <code>--builders</code>, and <code>--singleThreaded</code>.</p>
<h2>What’s missing in 7.0</h2>
<p>The catch — and it’s a meaningful one — is that 7.0 ships without a stable programmatic API. That means tools like typescript-eslint, Vue, Svelte, Astro, and Angular’s language tooling can’t integrate yet. That API is planned for TypeScript 7.1.</p>
<p>For teams migrating now, Microsoft published a compatibility package (<code>@typescript/typescript6</code>) to ease the transition for existing tooling.</p>
<h2>Other changes</h2>
<p>TypeScript 7.0 also promotes several deprecations from 6.0 to hard errors, and sets <code>strict</code> and <code>esnext</code> as defaults going forward. Nothing surprising there, but worth checking if you’re on older configs.</p>


TypeScript 7.0 introduces a native Go-based compiler delivering 8x–12x faster build times. Real-world benchmarks show the VS Code codebase (1.3M lines) compiling in 10.6 seconds versus 125.7 seconds previously, and Slack's CI type-checking dropping from 7.5 minutes to 1.25 minutes. Memory usage also fell ~18%. The speedup comes from parallel type checking — four concurrent checkers by default, tunable via new --checkers, --builders, and --singleThreaded flags. The release lacks a stable programmatic API, meaning tools like typescript-eslint, Vue, Svelte, Astro, and Angular language tooling cannot fully adopt it yet; that API is expected in 7.1. Breaking changes include several deprecations from 6.0 becoming hard errors, with strict and esnext now the defaults. A compatibility package @typescript/typescript6 is available for gradual migration.

Self-replicating npm worm expands into Go ecosystem via IDE config file hijack

A self-replicating npm worm called Shai-Hulud and its descendants (Mini Shai-Hulud, Miasma, Hades) have expanded from the JavaScript ecosystem into Go. The attack didn't exploit Go's toolchain directly — instead, malicious JavaScript payloads were hidden inside editor config folders (.vscode/tasks.json, .claude/) of a real Go project (verana-blockchain), triggering automatically when developers opened the project in their IDE. Once executed, the payload harvested credentials, cloud keys, SSH keys, and CI/CD secrets. The post explains the attack mechanism in beginner-friendly terms and offers practical defensive steps: auditing hidden config folders before opening repos, pinning dependencies, using short-lived scoped tokens, restricting CI/CD permissions, and using dependency-scanning tools like Socket.

Go 1.26 enables Green Tea garbage collector by default with 10–40% GC overhead reduction

Go 1.26 ships with the Green Tea garbage collector enabled by default, promising 10–40% reduction in GC overhead for programs that heavily use the GC. The new collector replaces the traditional graph-flood mark algorithm with a span-based approach that processes 8 KiB spans in address order, improving cache locality and enabling AVX-512 vectorized scanning on modern Intel/AMD CPUs. The key insight is that gains depend entirely on heap shape: dense heaps with many same-sized objects at similar graph depths benefit greatly, while pointer-chasing structures like binary trees with low fan-out may see no improvement or even regression. A code sample is provided to benchmark both approaches using the runtime/metrics package. On Go 1.25 Green Tea is opt-in via GOEXPERIMENT=greenteagc; on 1.26 it's default with GOEXPERIMENT=nogreenteagc as an escape hatch until Go 1.27.

GoLand 2026.2 ships Go optimization tooling with pprof profiling and escape analysis

GoLand 2026.2 introduces a new Go Optimization tool window that consolidates profiling, escape analysis, and struct optimization into a single workflow. Key highlights include pprof profiling for regular Go applications without extra setup, support for Go 1.27's new Goroutine leak profile, a redesigned profile viewer with flame graphs and call trees, live CPU/memory charts, and escape analysis visualization in the editor. The release also integrates the official `go fix` tool for code modernization, adds Docker Compose inline actions and service templates, Terraform testing framework support, and expands AI capabilities with configurable completion models and GitHub Copilot integration. IDE performance improvements include async file saves, faster code analysis for large projects, and better Git worktree support.

OpenTelemetry ships v1 Go compile-time instrumentation with no source changes required

OpenTelemetry has released v1 of its Go Compile-Time Instrumentation, closing a long-standing gap where Go developers had to instrument code manually or use eBPF agents. The tool, `otelc`, hooks into the Go toolchain via `-toolexec` and injects OpenTelemetry traces and metrics at build time — no source code changes required. It covers third-party libraries and the standard library, supports `net/http`, `database/sql`, gRPC, Redis, and Go runtime metrics, and is CI/CD friendly. A single build command swap (`otelc go build` instead of `go build`) is all that's needed. The project was built collaboratively by Alibaba and Datadog under the OpenTelemetry SIG. Future plans include broader library coverage, registry-based discovery, and performance improvements.

Google ships Genkit Agents API preview for TypeScript and Go with human-in-the-loop support

Google has released the Genkit Agents API in preview for TypeScript and Go. The API unifies message history, tool execution loops, streaming, state persistence, and a frontend protocol behind a single chat() interface. Two standout features are detached turns — allowing agents to continue working server-side after a client disconnects, with polling for results — and interruptible tools that pause mid-execution for human approval with anti-forgery validation. State persistence supports both server-managed (Firestore, in-memory, file-based) and client-managed modes, the latter suited for strict data residency requirements. Multi-agent orchestration is handled via a middleware system that injects delegation tools for sub-agents. Genkit is model-agnostic with plugins for Gemini, Vertex AI, Anthropic, OpenAI, and Ollama, and integrates with Next.js via a Vercel AI SDK adapter. Python and Dart support are planned. The framework competes with LangChain, CrewAI, Semantic Kernel, and others, differentiating itself with a full-stack approach deployable to Firebase, Cloud Run, or any Node.js/Go environment.

Vidar stealer campaign uses Go loaders, rogue code-signing certs, and 491 MB file inflation to evade detection

Unit 42 researchers uncovered a financially motivated campaign active in April 2026 delivering Vidar stealer and XMRig cryptocurrency miner via malvertising disguised as cracked software. The campaign uses the Factory-v3 malware-as-a-service builder, which generates Go-compiled loaders with per-build unique hashes to defeat hash-based detection. Key evasion techniques include: rogue Authenticode certificates impersonating JustWatch and later BleacherReport, file-size inflation up to 491 MB using null byte padding to bypass sandbox size limits, DLL sideloading via a fake MpClient.dll, and an in-memory AMSI bypass that patches AmsiScanBuffer. The attack chain drops Vidar stealer (targeting browser credentials, cookies, and crypto wallets) and XMRig (mining Monero via pool.supportxmr.com), with persistence via registry Run keys, scheduled tasks, and a startup batch script. The operator uses Telegram for infection notifications under the 'X3D MINER' moniker. Full IOCs including SHA256 hashes, C2 IPs, file paths, and certificate details are provided.

Apache Airflow 3.3.0 adds stateful tasks and Java and Go task SDK

Apache Airflow 3.3.0 introduces four major features: a first-class Task & Asset State Store (AIP-103) that lets tasks persist key-value state across retries and reruns without XCom hacks; a Language Task SDK (AIP-108, experimental) enabling task logic written in Java or Go to run on standard Airflow workers alongside Python tasks with full XCom, Variable, and Connection access; expanded asset partitioning with new FanOutMapper, FixedKeyMapper, SegmentWindow, time windows, and wait policies; and pluggable retry policies (AIP-105) for custom retry strategies. Additional improvements include DAG result endpoints, bundle version control on clear/rerun/backfill, UI enhancements for state inspection and bulk actions, and breaking OpenTelemetry metrics changes from Gauges to Histograms.

Malicious Go module leads to 222-repo GitHub lure network deploying RATs and infostealers

Socket researchers uncovered Operation 'Muck and Load', a malware campaign that began with a malicious Go module impersonating a DNS/subdomain scanner. The module embedded hidden PowerShell execution that downloaded encrypted payloads from public dead-drop services (Pastebin, YouTube, Instagram, Telegram), ultimately deploying AsyncRAT, Quasar, Remcos RATs, Vidar infostealer, and Monero cryptominers via password-protected archives. Pivoting from the initial module revealed a GitHub lure network of 222 confirmed repositories across 190 accounts, all using automated commit-farming GitHub Actions workflows to appear active and legitimate. The repositories targeted users seeking crypto tools, wallet utilities, game cheats, and offensive tooling. At least 14 confirmed malware files were found across the network. The malicious Go module has been blocked from the Go module proxy, and GitHub has been notified. The campaign overlaps with previously reported ischhfd83-linked repository-backdoor activity.

TypeScript 7.0 ships as native Go port with 8x to 12x faster build times

<p>TypeScript 7.0 is officially released, and the headline is straightforward: Microsoft rewrote the TypeScript compiler in Go, and it’s a lot faster.</p>
<p>Benchmarks on real codebases tell the story pretty clearly. VS Code’s 2.3 million lines of code now compile in 10.6 seconds, down from 125.7 seconds with TypeScript 6 — nearly a 12x speedup. Editor load times dropped from 17.5 seconds to under 1.3 seconds. Slack, which had stopped running full type checks locally because they took too long, can do so again. Canva, Bluesky, Playwright, and Microsoft’s own internal projects have all tested it in production.</p>
<p>The team chose Go over C# or Rust for a few practical reasons: its structural similarity to JavaScript made the port more straightforward, its memory allocator is efficient enough that the garbage collector can be disabled for most compilations, it has solid cross-platform support, and its concurrency primitives made parallelization easier to implement. The result is native code execution with shared-memory multithreading — things the original V8-based compiler simply couldn’t do.</p>
<h2>What’s new</h2>
<p><strong>Speed, obviously.</strong> Full builds are 8x–12x faster depending on the codebase. The improvement applies to compilation and editor tooling, not to the runtime performance of the JavaScript it outputs.</p>
<p><strong>Parallel type checking.</strong> New <code>--checkers</code> and <code>--builders</code> flags let you configure how many parallel workers run during type checking and project reference builds.</p>
<p><strong>Rebuilt watch mode.</strong> The <code>--watch</code> mode is now built on a Go port of Parcel’s file watcher, which the team says is more stable than the previous implementation.</p>
<p><strong>Updated defaults.</strong> TypeScript 7.0 adopts TypeScript 6.0’s stricter defaults: <code>strict: true</code>, <code>module: esnext</code>, and others. Legacy options like <code>target: es5</code>, <code>baseUrl</code>, and AMD/UMD module support have been removed.</p>
<p><strong>Full LSP-based editor support.</strong> The language server has been rebuilt and is described as more stable, with richer editor features.</p>
<h2>The big caveat: no programmatic API yet</h2>
<p>This is the part that matters if you use frameworks. Vue, Svelte, Astro, Angular, MDX — none of them can use TypeScript 7 yet because the programmatic API hasn’t been ported. The team expects to ship it in TypeScript 7.1. Until then, these frameworks stay on TypeScript 6.</p>
<p>For tools that need the old API in the meantime, a compatibility package <code>@typescript/typescript6</code> allows TypeScript 6 and 7 to be installed side by side.</p>
<h2>Tooling support</h2>
<p>WebStorm 2026.2 ships with TypeScript 7 support out of the box. The Kibana codebase saw project load times drop from around 12 seconds to 3 seconds in their testing. In VS Code, you can get started by installing the TypeScript 7 extension.</p>
<h2>What comes next</h2>
<p>With the port complete, the TypeScript team says they’ll resume normal feature work, ergonomic improvements, and the new ecosystem API. Releases will continue on a three-to-four month cadence.</p>
<p>For most projects that don’t depend on the programmatic API, TypeScript 7 is production-ready now. The speed difference is real enough that it’s worth trying — especially if you’ve been living with slow CI builds or sluggish editor startup times.</p>


TypeScript 7.0 ships with a Go-rewritten compiler delivering 8x–12x faster build times. The VS Code codebase dropped from 125.7s to 10.6s build time. Memory usage is also reduced, benefiting large monorepos. New features include parallel type-checking via --checkers and --builders flags, a rebuilt Go-powered watch mode, and a fully rewritten LSP-based language server. Legacy options like target: es5, baseUrl, and AMD/UMD support are removed. The Node.js programmatic API is absent from this release, meaning Vue, Svelte, Astro, and Angular integrations must wait for TypeScript 7.1. A compatibility package @typescript/typescript6 bridges the gap in the meantime.

Intel archives Quantum Intrinsics, OAP-MLLIB and FastGo open-source projects

Intel has archived several open-source projects this week, continuing a trend of sunsetting unmaintained software. The archived projects include Quantum Intrinsics (a C++-based LLVM/Clang front-end for the Intel Quantum Compiler), OAP-MLLIB (optimized Spark packages for accelerating machine learning with Intel hardware), and FastGo (optimized Go packages for compression algorithms on Intel Xeon processors). These cuts follow earlier archiving of Quantum Passes, BigDL time series toolkit, and IPEX LLM, reflecting ongoing restructuring at Intel.