Welcome to a new edition of "This Week in JavaScript"!

This week, TypeScript 5.9 streamlines developer workflows with minimal configurations and deferred imports, ZhipuAI's GLM 4.5 showcases incredible coding capabilities including building Space Invaders games, and Node.js 22.18 LTS solidifies production reliability while Node.js v24 pushes performance boundaries.

Plus, we've got some powerful new + updated tools for your development workflow!

Can’t read the newsletter? Listen on the go!

TypeScript 5.9: Developer Experience Gets Better

TypeScript 5.9 delivers practical enhancements that directly address common developer pain points, making the development experience smoother and more productive. This release focuses on reducing setup complexity, improving IDE interactions, and optimizing performance for real-world applications.

What's New

• Simplified Setup Removes Onboarding Friction: The redesigned tsc --init generates clean, prescriptive configurations instead of overwhelming comment-heavy files. New developers get modern defaults like "module": "nodenext" and "target": "esnext" without decision paralysis, while experienced teams benefit from stricter type-checking options like noUncheckedIndexedAccess being prominently featured.

• Better Performance Control with Deferred Imports: The new import defer syntax gives developers granular control over when modules execute. Instead of all imports running immediately, you can defer execution until actually needed with import defer * as a feature from "./module.js". This is particularly valuable for large applications where startup performance matters.

• Enhanced IDE Experience: Expandable hovers transform how developers explore type information. The new + and - buttons in tooltips let you drill down into complex types without leaving your current context. Combined with configurable hover lengths, this means less time jumping between files to understand type definitions and more time actually coding.

• Production-Ready Module Resolution: The --module node20 option provides a stable, predictable alternative to nodenext specifically modeling Node.js v20 behavior. Unlike the potentially shifting nodenext, this gives teams a fixed target with consistent --target es2023 compilation, crucial for enterprise applications requiring predictable deployment behavior.

• Faster Compilation Where It Counts: Performance optimizations targeting complex libraries like Zod and tRPC address real-world bottlenecks. Cached instantiations and optimized file checks translate to noticeably faster compilation times, especially valuable for large codebases where build performance directly impacts developer productivity.

TypeScript 5.9 removes common friction points while adding features that enhance both immediate productivity and long-term maintainability, exactly what developers need for modern JavaScript projects.

GLM 4.5 is a Fullstack POWERHOUSE

ZhipuAI's GLM 4.5 represents a breakthrough in open-source AI, specifically engineered for fullstack development automation and complex agentic workflows that rival proprietary models in coding capabilities.

Key Innovations

• Massive Scale with Efficiency: GLM 4.5 features 355 billion total parameters with 32 billion active parameters using Mixture of Experts architecture. This design delivers exceptional performance while maintaining computational efficiency for real-world development tasks.

• Hybrid Reasoning Modes: The model provides both thinking mode for complex reasoning and tool usage, and non-thinking mode for immediate responses. This dual approach ensures optimal performance whether you're debugging complex logic or need quick code suggestions.

• Fullstack Development Excellence: GLM 4.5 excels in both frontend and backend development, making it powerful for building modern web applications. Users can create entire websites with just a few words, then effortlessly add features through multi-turn dialogue, making the coding process smooth and enjoyable.

• Interactive Game Development: The model demonstrates remarkable capabilities by building complete JavaScript games like Space Invaders through natural language interaction. This showcases its understanding of game mechanics, canvas manipulation, event handling, and complex interactive programming patterns that would typically require extensive coding knowledge.

• LLM Whisperer Integration: GLM 4.5's advanced prompt engineering capabilities make it exceptionally skilled at communicating with other AI models, acting as an intelligent intermediary that can optimize prompts, chain multiple AI interactions, and orchestrate complex multi-model workflows for enhanced development automation.

• Superior Coding Benchmarks: With a 64.2% score on SWE-bench Verified and 90.6% tool-use success rate, GLM 4.5 outperforms many leading models in real-world coding scenarios, demonstrating its practical utility for professional development workflows.

GLM 4.5 transforms fullstack development by enabling developers to build complete applications through natural language interaction, from rapid prototyping to production deployment, all while maintaining the flexibility of open-source accessibility.

Node.js 22.18 LTS: Production-Ready Stability

Node.js v22.18.0 establishes the new Long-Term Support baseline with critical performance improvements, security patches, and stability enhancements that make it the recommended runtime for enterprise applications.

What's New

• Long-Term Support Baseline: As the first LTS release of the Node.js 22.x line, this version provides the stability and predictable update cycle that production applications require. Enterprise teams can now confidently adopt Node.js 22 knowing they'll receive security updates and critical fixes through April 2027.

• Enhanced Performance: This release includes significant V8 engine updates, improved garbage collection performance, and optimized module loading that translates to faster startup times and better runtime performance for both server and tooling applications.

• Security Hardening: Multiple security vulnerabilities have been addressed, including improvements to the permission model, enhanced cryptographic operations, and strengthened HTTP/2 implementation for more secure production deployments.

• Developer Experience Improvements: Enhanced debugging capabilities, improved stack traces, and better error messages make development and production troubleshooting more efficient and developer-friendly.

• Node.js v24 on the Horizon: While Node.js 22.18 LTS focuses on production stability, the upcoming Node.js v24 (currently in development) promises even more dramatic performance improvements with the latest V8 engine, experimental features like the Permission Model refinements, and enhanced ECMAScript modules support that will further modernize the JavaScript runtime ecosystem.

Node.js 22.18 LTS represents the mature, battle-tested foundation that production applications need, while Node.js v24 development continues pushing the boundaries of JavaScript runtime performance and capabilities.

Tools & Releases You Should Know About

• Node-RED continues evolving its visual programming capabilities for IoT and automation workflows, providing developers with an intuitive drag-and-drop interface for connecting hardware devices, APIs, and online services into powerful automation systems without requiring extensive coding expertise.

• Ionic 8.7 enhances cross-platform mobile development with improved performance optimizations, enhanced UI components, and better integration with modern web standards, making it easier to build native-quality apps using familiar web technologies and deployment pipelines.

• Storybook 9.1 advances component-driven development with enhanced testing capabilities, improved performance, and better integration with modern frontend frameworks, streamlining the development and documentation of UI component libraries for design systems.

• Ghost 6.0 revolutionizes content management with headless CMS capabilities, advanced membership features, and enhanced developer APIs, providing creators and developers with powerful tools for building modern publishing platforms and content-driven applications.

• Ink 6.1 elevates CLI development by bringing React's component model to terminal applications, enabling developers to build sophisticated command-line interfaces using familiar React patterns, hooks, and modern JavaScript tooling workflows.

And that's it for the forty-sixth issue of "This Week in JavaScript", brought to you by jam.dev—the tool that makes it impossible for your team to send you bad bug reports.

Feel free to share this newsletter with a fellow developer, and make sure you're subscribed to get notified about the next issue.

Until next time, happy coding!

Welcome to a new edition of "This Week in JavaScript"!

This week, GitHub Spark brings true prompt to app coding at scale, Alibaba pushes boundaries with Qwen3-Coder for intelligent automation, and es-toolkit resets the standard for JavaScript utilities.

Plus, we’ve got some powerful new + updated tools for your development workflow!

Can’t read the newsletter? Listen on the go!

GitHub Spark builds Production-Ready Apps in MINUTES

GitHub Spark, currently in public preview, is an AI-powered, comprehensive platform that enables developers to create, refine, and deploy intelligent full-stack applications using natural language, visual controls, or code.

What’s New

• Full Power, No Setup: Start from a single prompt, Spark scaffolds your frontend and backend using trusted frameworks like React and TypeScript. No manual configuration, servers, or SDK installs needed.

• Live Preview and Instant Deploy: Applications can be instantly visualized with Live Preview and deployed to production with a single click. GitHub authentication and managed hosting are provided by default, enabling real time updates via straightforward prompts.

• Integrated GitHub Tools:Each Spark application operates as an independent project, complete with automated GitHub Actions, Dependabot for security, and integrated features for code reviews, collaborative work, and version control.

• AI Feature Integration: Integrate LLM capabilities (chatbots, content generation, automation) from leading providers (OpenAI, Meta, DeepSeek, xAI) effortlessly, requiring no API keys.

• Copilot Harmony: Seamless integration with Copilot is achievable for all coding, whether through VS Code or by employing Copilot Agents for advanced automations, all within the robust Spark environment.

• Flexibility: Spark provides adaptable solutions for diverse applications, encompassing prototypes, SaaS offerings, workflow automation, and utility applications. It integrates effortlessly with established processes and is appropriate for both collaborative teams and individual developers.

Developers can iterate straight from idea to live application while staying anchored in the GitHub ecosystem.Spark facilitates rapid prototyping and delivery, enabling developers to ship smarter, faster, and with less friction. It allows for seamless iteration from concept to live application, all while remaining integrated within the GitHub ecosystem.

Alibaba’s Qwen3-Coder is INSANE

Alibaba’s Qwen3-Coder-480B-A35B-Instruct is a cutting-edge, open source code model and agentic platform, built for real development automation and cross-codebase reasoning.Alibaba's cutting-edge open-source code model, Qwen3-Coder, is designed to enhance the capabilities of software engineers. It offers advanced automation, the ability to reason across different codebases, and seamless integration with various developer tools.

Key Innovations

• Agentic Workflow Engine: Outperforms earlier models at handling complex, multistep software engineering tasks.Generate code, refactor large projects, or execute procedural workflows, all via prompt or CLI.

• 480B Parameters (35B Active): Leveraging Mixture of Experts, it manages large, diverse tasks with high efficiency, and supports native 256K-token context (scalable to 1M for ultra-large codebases).

• Trained for Engineering: Qwen3-Coder learns from 7.5T tokens (70% code), using advanced reinforcement learning to develop true coding intuition and context awareness,ideal for repository wide analysis.

• Command-Line and API Ready: Qwen provides developers with excellent integration possibilities, including command-line interface (CLI) and API access, as well as compatibility with IDEs and CI/CD pipelines.

• Easy Setup and Broad Availability: Available in multiple variants on GitHub, Hugging Face, and ModelScope. Installing or using Qwen Code is straightforward for developers familiar with modern JavaScript tooling (Node.js v20+ supported for CLI workflows)

• Broad Multilingual Coding Support: Handles 358 programming languages, making it suitable for diverse software stacks, teams, and global projects

• Open Source and Community Driven: Qwen3-Coder is fully open source, inviting contributions and adoption by teams and enterprises seeking transparency and state-of-the-art AI coding capabilities.

Qwen3-Coder is an open-source artificial intelligence coding solution developed for software engineers encountering intricate engineering automation challenges. It demonstrates proficiency in comprehensive code analysis, refactoring, and tool integration, thereby establishing itself as an essential collaborator in surmounting complex programming obstacles.

Modern Utilities for the Fast JavaScript Stack

es-toolkit is a state-of-the-art, high-performance JavaScript utility library designed to help developers build, iterate, and optimize codebases with maximum efficiency and minimal overhead.

What’s New

• Efficient by Design: Delivers better performance than legacy libraries and reduces JavaScript bundle size by up to 97%. Every delay, chunk, sum, pick, and more is implemented for speed and modularity, perfectly suited for modern, performance-focused projects.

• Seamless Migration: Includes a Lodash compatibility layer (es-toolkit/compat) for effortless migration. Replace Lodash in existing projects without rewriting code, enabling quick transitions to more modern, lightweight tooling.

• TypeScript Excellence: Features strong, built-in type annotations and advanced type guards like isNotNil, enabling safer, predictable development with robust TypeScript integration.

• Battle-Tested Reliability: 100% test coverage ensures every function is production-ready from day one. es-toolkit is trusted by popular open-source projects including Storybook, Recharts, ink, and CKEditor.

• Universal Compatibility: Runs anywhere JavaScript does Node.js, browsers, Bun, Deno offering true universality without tradeoffs.

• Developer Tooling Ecosystem: Community has already built migration tools including es-toolkit-webpack-plugin for Webpack 5 and vite-plugin-es-toolkit for Vite, showing strong ecosystem support for production adoption.

es-toolkit empowers developers to simplify code, accelerate development, and maintain high standards of reliability and performance across any JavaScript environment.

Tools & Releases You Should Know About

• React Native Reanimated 4.0 ushers in a major rearchitecture that delivers lightning-fast, silky-smooth animations for mobile apps. It’s fully compatible with the latest React Native releases, making it easier than ever to craft complex layout animations and even bring these capabilities to the web.

• Oxlint 1.8 stands out as a new generation, high-speed linter developed in Rust, offering rapid one-pass linting for JavaScript and TypeScript. It exceeds ESLint in performance and integrates easily into development pipelines.

• Jasmine 5.9 continues to be a trusted staple for JavaScript testing, elevating reliability for both CI/CD workflows and browser or Node.js environments. With Jasmine, teams can feel confident about rigorous automated testing.

• npq further enhances your package management workflow by automatically scanning for vulnerabilities with Snyk before any npm package is installed. This proactive security ensures that only safe dependencies are added to your project, reducing the risk of introducing known issues.

• ApexCharts 5.3 equips developers with powerful tools to create interactive, visually appealing JavaScript data charts for the web. The latest version adds features that streamline both customization and responsiveness, enabling sophisticated data visualizations with less effort.

• vue-multiselect 3.3 is purpose-built for Vue 3 applications, delivering a robust and flexible select and tagging component. It supports advanced data structures, complex selection logic, and asynchronous loading for large datasets.

• Bun v1.2.19 continues to make waves as an all-in-one JavaScript runtime, delivering major speed improvements, reliable dependency management, and powerful CLI tools to supercharge modern development.

And that's it for the forty-fifth issue of "This Week in JavaScript", brought to you by jam.dev—the tool that makes it impossible for your team to send you bad bug reports.

Feel free to share this newsletter with a fellow developer, and make sure you're subscribed to get notified about the next issue.

Until next time, happy coding!

Welcome to a new edition of "This Week in JavaScript"!

This week, Moonshot AI’s Kimi K2 arrives as a powerful open-weight coding model, Next.js 15.4 makes Turbopack production-ready, Vue 3.6 alpha introduces Vapor Mode for high-performance apps, and Nuxt 4.0 brings big improvements to the developer experience, and more.

Plus, we’ve got some powerful new+updated tools for your development workflow!

Can’t read the newsletter? Listen on the go!

Kimi K2 is the BEST coding agent

Could models like Claude, GPT-4, or Gemini Pro be losing their top spot? Moonshot AI’s Kimi K2 is making waves across the developer community, offering open access, strong benchmarks, and real-world coding power—right when it matters most.

• Agentic Mastery Beyond Code Suggestions: Kimi K2 moves far beyond being just another code-completion AI. It executes, tests, debugs, and iteratively improves full software projects—demonstrated by automating complex tasks like developing Minecraft mods in JavaScript. It can handle rendering, run and debug multiple test cases, capture logs on failure, and refine solutions until all tests succeed.

• Built for Scale and Depth: With a Mixture-of-Experts architecture (32 billion activated parameters from a trillion total), Kimi K2 processes entire repositories thanks to a 128,000-token context window. This enables deep, cross-file project reasoning and robust documentation.

• Benchmark-Leading Results: Kimi K2 achieves 65.8% on SWE-Bench and leads LiveCodeBench v6, showcasing its capabilities in end-to-end coding, debugging, and realistic project workflows.

Open Access and Developer Control

• Ready for Any Workflow:

  • Kimi-K2-Base: Start with a model designed for custom research, innovation, and fine-tuning in-house solutions.

  • Kimi-K2-Instruct: Unlock a production-ready chatbot or agent—perfect for IDE, CI, or documentation automation.

• Developer-Friendly Deployment: Everything you need—deployment tools and open inference code—are available on GitHub, so you can start building advanced, transparent AI workflows without vendor lock-in.

Kimi K2 is helping developers not only generate code but also manage advanced automation, debug large projects, and streamline end-to-end engineering tasks—all within an accessible open-source framework.

Next.js 15.4 brings a sneak peek to Next.js 16

The Next.js 15.4 release is a game-changer for developer productivity. The headline feature is that Turbopack is now production-ready. Developers can enable it with next build --turbopack to see a dramatic reduction in build times.

• Production-Proven Speed: Turbopack is officially powering major sites like vercel.com, passing over 8,000 integration tests and delivering tangible reductions in build and deploy times. For developers working on large codebases or maintaining rapid CI/CD cycles, this means less waiting, more iterating, and shipping features faster.

• Developer-First Improvements: The release isn’t just about raw speed—quality-of-life fixes are everywhere. With smarter server-side path generation, enhanced error handling, the new onInvalidate option for router prefetch, and detailed debug tooling, routine workflows become smoother and less error-prone. Expect smaller server bundles—and a more robust App Router—out of the box.

• Glance at the Future—Next.js 16: The roadmap lights up with features like unified Cache Components (beta) to streamline data-fetching and caching logic, stable Node.js Middleware for consistent routing and security, and optimized client-side navigation. Enhanced DevTools are coming too, prepping Next.js for AI-powered debugging and even more developer clarity.

• Zero-Hassle Upgrades: Migration headaches are minimized with automated commands (like npx @next/codemod@canary upgrade latest) and thoughtful deprecation guidance for Node.js 18 and AMP. Adopters of prior Turbopack alphas will immediately notice the leap in stability and performance.

Developers have been waiting for a practical, reliable performance leap—and with Turbopack finally production-ready in Next.js 15.4, that leap is here. It’s the perfect moment to revisit your stack and experience what modern React builds should feel like.

Vue 3.6 Alpha: Optimize Performance with Vapor Mode

Imagine boosting a single Vue component’s speed—no full rewrite, no confusing migration, just pure, surgical performance when you need it most. That’s exactly what Vue 3.6.0-alpha.1 delivers with its new Vapor Mode, now shaking up how devs approach frontend bottlenecks.

What makes Vapor Mode exciting?

• Drop the V-DOM baggage: With Vapor Mode, your templates are compiled straight into super-efficient vanilla JavaScript that updates the DOM directly—no diffing or middlemen, just instant UI updates.

• Instant optimization, zero churn: Need a lightning-fast data grid or real-time chart? Add <script setup vapor> to your SFC, and that’s it. No more spinning your wheels trying to squeeze out performance gains across your whole app.

• Mix and match: No need to bet the farm! Use Vapor Mode on just those heavy components, while the rest of your project keeps humming along in standard Vue. The vaporInteropPlugin means you get the best of both worlds—legacy and futuristic, side by side.

• Less code, more speed: Benchmarks show near-native DOM speeds and smaller bundles—the stuff frontend dreams are made of.

• Smart, modern reactivity: Under the hood, the core’s been upgraded for leaner computed properties and snappier state management, so even your non-Vapor code benefits.

• A real migration path: Vapor Mode isn’t for everything—yet. It’s perfect for new projects, perf-sensitive features, or greenfield micro frontends. Plus, features like SSR hydration and transitions are on the way.

How do you try it out?

• Just add the vapor option to your <script setup> block and build as usual. Then watch as that sluggish component turns into a speed demon—no codebase rewiring or framework gymnastics required.

With Vapor Mode, Vue gives developers direct control over where performance matters most—unlocking a whole new way to build fast, efficient interfaces with the tools you already know and love. If you’re ready to see how “fast” Vue can really be, it’s never been easier to jump in and push your next UI feature to new heights.

Nuxt 4.0: A Major Overhaul for Developer Experience

Nuxt 4.0 is here after a year of real-world testing, focused on stability and making setup, coding, and upgrades more intuitive for developers. It introduces carefully considered changes aimed at cleaner workflows and easier project maintenance, with backwards compatibility and a smooth upgrade path.

Cleaner Project Organization

• The biggest visible change: your app now lives in an app/ directory by default. This makes project structure clearer, file watchers faster, and helps IDEs better recognize what’s client, server, or shared code.

• Don’t want to migrate? No problem—Nuxt 4 detects old layouts and works as before.

Redesigned Starter Templates, Error, Home, and Loader Pages

• Based on PR #27843, Nuxt 4 introduces all-new, modern UI branding for its starter templates—including a refreshed home page, a more accessible layout, a polished error page (error.vue at the project root), and a visually improved loader page. There’s a new logo, better focus outlines, a well-structured <main> for accessibility, and updated favicon and title defaults for SEO and professionalism.

• These updates mean every new project starts with a cleaner look, improved accessibility, and an easier base to build on for teams and solo developers alike.

Smarter Data Fetching by Default

• useAsyncData and useFetch are now more intelligent: components using the same key share data automatically, reactively refetch when keys change, and clean up after themselves. That means less boilerplate and fewer duplicated network requests out of the box.

• More flexibility is coming to the data layer as development continues.

Enhanced TypeScript Experience

• Nuxt 4 separates TypeScript projects for app, server, and shared code, providing more accurate type inference, less confusion across code contexts, and smoother, more reliable editor support.

• Your root tsconfig.json is now set up for you, and TypeScript integration is more robust across the board.

Faster CLI & Dev Server

• The CLI sees upgrades with socket-based communication, native file watching, and v8 compile cache reuse—resulting in faster cold starts and less resource usage, especially on Windows.

Upgrade Path & Migration Tools

• Upgrading is straightforward. Use npx nuxt upgrade --dedupe for a safe update and deduped lockfile, or the Codemod migration tool to automate many common steps.

• Detailed guides cover major breaking changes and help you fix any module or type errors.

Looking Ahead

• Nuxt 3 will continue to get maintenance through January 2026.

• Next up: Nuxt 5 with Nitro v3, h3 v2, the new Vite Environment API, and other developer-focused enhancements—plus SSR streaming, built-in fetch caching, multi-app support, and more in the pipeline.

Nuxt 4.0 isn’t about hype—it’s about everyday developer wins: faster starts, simpler structure, smarter defaults, and even better TypeScript. If you want a modern, production-grade Vue framework, this is a great time to upgrade.

Tools & Releases You Should Know About

• Tiptap v3: The popular headless rich text editor framework gets a major v3 update focused on developer experience. It now supports unmounting and remounting editors (ideal for dynamic UIs), custom component views for text segments with 'Markviews', and an SSR mode, making it easier than ever to build powerful editing experiences.

• Hyper Fetch: A powerful, framework-agnostic data-fetching library inspired by Axios and TanStack Query. It offers a type-safe API for both browser and server, with advanced features like request lifecycle management, real-time communication, progress tracking, and even code generation from OpenAPI specs.

• Astro 5.12: Astro continues to be the go-to framework for content-heavy sites that need to be incredibly fast. This release further improves its content collections API, making it easier to build blogs, portfolios, and marketing sites. Its "island architecture" is perfect for building internal dashboards or tools, like an AI-powered code review interface.

• Upyo: A simple, cross-runtime email library that gives you a unified, type-safe API for sending emails. It supports both traditional SMTP and modern HTTP-based providers like SendGrid or Amazon SES, simplifying a common backend task.

• OpenPGP.js 6.2: Adding client-side encryption to your web app can be complex, but OpenPGP.js provides a robust, open-source solution. This version introduces faster key generation and improved compatibility with modern browser APIs for secure, end-to-end encrypted features.

And that's it for the forty-fourth issue of "This Week in JavaScript", brought to you by jam.dev—the tool that makes it impossible for your team to send you bad bug reports.

Feel free to share this newsletter with a fellow developer, and make sure you're subscribed to get notified about the next issue.

Until next time, happy coding!

Welcome to a new edition of "This Week in JavaScript"!

This week, Grok 4 steps up as a coding assistant for web developers, PlanetScale launches its blazing‑fast Postgres platform, Vercel welcomes NuxtLabs into the fold, and TypeScript 5.9 Beta brings deferred module evaluation, and more.

Plus, we’ve got some powerful new+updated tools for your development workflow!

Can’t read the newsletter? Listen on the go!

Is Grok 4 a Good Coding Assistant?

xAI’s Grok 4 isn’t just a benchmark star, it’s showing real promise as a coding assistant built for ambitious developer workflows. While the dedicated Grok 4 Coding Agent is still in development, the core model already delivers features that rival and, in some cases, surpass established tools.

With a 128K token context window (256K via API), native web search, and an integrated code execution sandbox, Grok 4 can handle entire codebases, generate structured multi-file solutions, and even run your code to identify bugs or test logic.

It already excels at:

• Code generation & scaffolding: From React components to Express routes, Grok 4 produces runnable, modular code. Thanks to its huge context window, it understands cross-file dependencies and refines outputs through iterative feedback, making it ideal for large, modern web projects.

• Debugging with tool use: Grok doesn’t just read your code, it runs it. It reproduces bugs in a sandbox, looks up the latest Stack Overflow or GitHub issues via live search, and suggests clear, actionable fixes. While its deep reasoning sometimes adds a bit of latency, the trade-off often results in more reliable solutions.

• Code explanation & documentation: Paste in thousands of lines of legacy code and get back plain-English summaries, line-by-line breakdowns, or high-level overviews. Its real-time web access means it can explain even the newest framework features, versions, and APIs accurately.

• Advanced problem-solving: With “Heavy” mode (not publicly available yet), Grok 4 uses multi-agent reasoning. Think of it as a team of AI reviewers debating and validating a solution. This gives it an edge in algorithmic problems, architecture planning, and performance tuning. It is also the first model to break 15% on ARC-AGI 2.0, a benchmark known for testing true general intelligence.

Compared to GitHub Copilot’s speed or ChatGPT’s versatility, Grok 4 trades a bit of polish for raw intelligence and autonomy. It’s not flawless. Some early users have noted bugs and slower responses, but it’s a powerful foundation. For developers who want an AI that can reason through messy bugs, understand full-stack apps, and adapt to fast-evolving tech, Grok 4 is already a strong start, and the coding agent hasn’t even launched yet.

PlanetScale for Postgres: the world’s fastest Postgres hosting platform

PlanetScale’s private preview of Postgres hosting brings their Metal‑powered performance and rock‑solid reliability to the Postgres ecosystem.

Highlights include:

• Benchmark leadership: Outperforms Aurora, AlloyDB, Neon, Supabase, and more, even when competitors run on 2× resources.

• High availability & uptime: Automatic failovers, query buffering, connection pooling via PSBouncer, and zero‑downtime version upgrades.

• Local NVMe SSDs: Locally attached storage delivers unrivaled performance/cost ratios for relational workloads.

• Nova (Vitess for Postgres): A from‑scratch sharding solution inspired by Vitess, currently in development with early access for high‑scale users.

Built on real Postgres v17 and supporting imports from v13+, PlanetScale for Postgres combines enterprise‑grade security, mature sharding, and the “boring” engineering that keeps your apps running.

Vercel Acquires NuxtLabs

NuxtLabs joins Vercel to fuel the future of the Nuxt ecosystem. Under MIT license and community‑driven governance, Nuxt and Nitro will continue evolving with:

• Nuxt UI v4 free‑for‑all: All Pro components and Figma kits open‑sourced.

• Self‑hostable Nuxt Studio: Edit Nuxt Content sites with a first‑class admin interface.

• NuxtHub agnosticism: Seamless integration with Vercel Marketplace add‑ons like Postgres and Redis.

Vercel’s track record, Next.js, Turborepo, Svelte, shadcn, means Nuxt’s roadmap, transparency, and community focus only get stronger, without sacrificing independence or open governance.

TypeScript 5.9 Beta

TypeScript 5.9 Beta brings features designed to streamline setup, boost performance, and align with upcoming ECMAScript specs:

Streamlined tsc --init
A minimal, prescriptive tsconfig.json now defaults to "module": "nodenext", "target": "esnext", jsx: "react‑jsx", and an empty types array, reducing friction and encouraging modern best practices.

import defer
Support for the deferred module evaluation proposal via import defer * as ns from "./mod.js". Modules initialize only when you first access a namespace property, improving startup performance and controlling side‑effects.

Stable --module node20
A fixed Node.js v20 resolution strategy (--module node20) models Node 20 behavior predictably, unlike the evolving nodenext, and implies --target es2023 by default.

Enhanced editor & performance

• Smarter hovers: Interactive “expandable” Quick Info and larger default hover lengths, no more truncated type details.

• Type‑checking optimizations: Cached instantiations for mappers (faster Zod/tRPC checks) and leaner file existence checks, yielding up to an 11 % speed‑up in large codebases.

TypeScript 5.9 refines the core developer experience while paving the way for next‑gen language features.

Tools & Releases You Should Know About

Foresight.js

Foresight.js hooks into standard mouse and keyboard events to build a real‑time model of user intent. By analyzing cursor velocity, hover duration, scroll position, and key navigation patterns, it can anticipate which link, button, or section a user is heading toward. Developers can then:

• Prefetch critical assets (images, scripts, API calls) just before they’re needed, slashing load times and perceived latency.

• Warm up heavy modules (e.g. code-splitting bundles or WebAssembly) in the background, so expensive downloads complete before the user clicks.

• Trigger early analytics or personalization workflows, enabling real‑time A/B tests or custom UI tweaks without delay.

With its lightweight core and easy API, Foresight.predict(element).then(…), you can retrofit Foresight.js into existing projects or integrate deeply into single‑page apps to make every interaction feel instantaneous.

Driver.js

Onboarding and feature discovery become frictionless with Driver.js. This library lets you walk users step‑by‑step through your UI, highlighting elements, dimming the background, and displaying custom tooltips. Key benefits for developers:

• No heavy dependencies, just include the Driver.js script and CSS.

• Declarative tour definitions, an array of steps specifying target selectors, popover text, and positioning.

• Event hooks for start, next, prev, and complete: integrate analytics, consent checks, or dynamic steps based on user state.

• Theming & styling, override default CSS or supply custom templates for a branded look.

Whether you’re launching a new dashboard feature or guiding new users through form workflows, Driver.js ensures your first‑time user experience is clear, concise, and code‑driven.

JSONRepair

When third‑party APIs, logs, or legacy systems produce malformed JSON, pipelines can grind to a halt. JSONRepair solves this by:

• Automatically detecting common syntax errors, missing commas, stray trailing characters, unquoted keys, mismatched brackets.

• Applying heuristic corrections while preserving as much original content as possible.

• Offering both CLI and programmatic interfaces, so you can plug it into build scripts (jsonrepair input.json > fixed.json) or call repair(jsonString) in Node.js.

• Reporting a summary of fixes applied, helping you trace and diagnose recurring data issues.

For developers building ETL jobs, log parsers, or front‑end apps that fetch unpredictable data, JSONRepair eliminates manual debugging and keeps data flowing smoothly.

Claude Code in a Single Executable

Installing and managing Node versions, Bun releases, and native addons can derail AI coding workflows. Josh Sumner’s bundled executable changes that by:

• Packaging Claude Code, Node.js, Bun, and all native modules into one self‑contained binary.

• Ensuring consistent behavior across Windows, macOS, and Linux, no more “it works on my machine” headaches.

• Supporting direct execution of JavaScript and TypeScript code with AI assistance, without extra script or dependency setup.

• Enabling offline or air‑gapped usage, since all runtime components are embedded.

Developers can drop the binary into a project, run claude-code start, and immediately interact with Claude’s code generation, refactoring, and debugging features, accelerating prototyping and minimizing setup friction.

And that's it for the forty-third issue of "This Week in JavaScript", brought to you by jam.dev—the tool that makes it impossible for your team to send you bad bug reports.

Feel free to share this newsletter with a fellow developer, and make sure you're subscribed to get notified about the next issue.

Until next time, happy coding!

Welcome to a new edition of "This Week in JavaScript"!

This week, deno bundle made an insane comeback, GitHub Copilot Chat gets open-sourced, Someone made Minecraft with CSS, and PNG receives updates too.

Plus, we’ve got some powerful new+updated tools for your development workflow!

Can’t read the newsletter? Listen on the go!

Deno 2.4: deno bundle is Back

Deno 2.4 reintroduces the long-requested deno bundle command, enabling single-file JavaScript or TypeScript bundles for both server and browser environments. With support for npm and JSR dependencies, plus automatic tree-shaking and minification via esbuild, this marks a major leap forward for Deno’s developer experience.

Previously deprecated due to complexity, deno bundle now uses esbuild under the hood and is here to stay. Future plans include exposing a runtime bundling API and plugin support for customizable builds , making it more flexible than ever.

Beyond bundling, Deno 2.4 introduces several notable features that enhance both DX and spec-alignment:

• Importing text and binary files directly into modules, useful for assets like markdown, icons, or binary blobs. Instead of loading assets at runtime, developers can now import them statically in a spec-friendly way, aligning with the direction of the Import Attributes proposal.

• Stable OpenTelemetry support is now built into Deno, enabling structured observability without extra setup.

• A new --preload flag allows you to modify the Deno runtime environment before executing scripts, useful for injecting setup code or instrumentation.

• deno update simplifies dependency management by keeping everything fresh with one command.

• Script coverage can now be collected via deno run --coverage, making it easier to track test quality and identify untested logic.

• Additional changes include:

• Support for DENO_COMPAT=1 mode for better Node compatibility

• Conditional exports in package.json

• XML and SVG support in deno fmt

• Expanded support for local npm packages

• Better tsconfig.json handling

• Simplified Node global handling

• Improvements to the Language Server Protocol (LSP)

Deno 2.4 is one of the most substantial releases yet, tightening the runtime's alignment with modern standards while improving bundling, observability, and ergonomics across the board.

GitHub Copilot Chat Is Now Open Source in VS Code

Microsoft has officially open-sourced the GitHub Copilot Chat extension for Visual Studio Code under the MIT license, marking its first major milestone toward building an open-source AI-powered code editor. This move opens up a fully transparent look into how Microsoft implements agent-based AI coding inside VS Code.

You can now explore how context is passed to LLMs, how system prompts are structured, and how AI interactions are embedded into the editor interface , directly in the public repo. Everything from the telemetry capture to the prompt engineering logic is visible and modifiable.

The release is part of a broader effort to promote community-driven innovation in AI tooling. By open-sourcing Copilot Chat, Microsoft hopes to replicate the success of VS Code’s open model while advancing trust, extensibility, and insight into AI integration.

Developers can:

• Study how agent mode works under the hood

• Learn from Microsoft’s implementation of multi-step task handling and chat-based programming

• Contribute directly to the extension or file issues

• Use Copilot’s own chat capabilities to navigate and understand the codebase itself

Long term, Microsoft aims to integrate the Copilot Chat extension directly into VS Code core. While the original Copilot inline-completion engine remains closed source for now, Microsoft has stated that future iterations of that functionality may also move to the open-source Copilot Chat foundation.

This release supports full chat interaction inside the editor, from multi-turn conversations to AI-driven edits, method refactoring, and error handling, across dozens of languages like Python, JavaScript, Go, and C++.

With full integration into the VS Code UI, Copilot Chat updates alongside every VS Code release. To access the latest capabilities, users must stay on the most recent VS Code version.

This open-sourcing step strengthens transparency, improves community trust, and gives developers fine-grained control over how AI tools are embedded into their workflows. Microsoft’s commitment is clear: AI-first development should be open by design.

Minecraft... in Pure CSS?!

Yes, it’s real: someone recreated Minecraft using only HTML and CSS, no JavaScript, no WebGL. You can build blocks, break them, rotate the world, and explore, all with just CSS selectors, radios, and some wild creativity.

This project pushes CSS to its absolute limits, using a mix of :has(), radio inputs, and label mechanics to simulate interactive 3D state changes , essentially turning the browser into a voxel engine using pure style rules.

At its core:

• The game uses over 35,000 <label> elements and nearly 6,000 <input type="radio"> elements to store state.

• Each cube in the 3D grid is represented using combinations of these inputs, allowing CSS to "track" block types and positions.

Changing blocks works by selecting different radio inputs. The associated label targets use for attributes to update visible styles, changing textures or removing blocks based on which input is checked.

Rendering and interactivity are handled through:

• CSS-only animations that run on interaction using the :active and animation-play-state trick. Holding a movement button (like "up" or "down") triggers smooth transforms and rotates the world.

• 3D transforms and perspectives, including pixelated rendering of textures for that authentic Minecraft look.

• A precompiled 46,000-line HTML file with just 480 lines of actual CSS (generated via SCSS templates) orchestrates the entire experience.

What makes it possible:

• Clever use of :has() and :checked selectors allows input states to trigger DOM changes without JavaScript.

• image-rendering: pixelated ensures clean visual fidelity for block textures.

• Layered container elements track perspective and axis-based movement in 3D.

It’s not just a visual demo, it’s fully interactive. You can dig, place blocks, rotate, and explore a miniature CSS world. While not built for production or scalability, the engineering behind it is astonishing.

This is a stunning example of how far native web technologies have come , and how much is possible when you're willing to explore the boundaries of CSS.

PNG Gets Its First Major Update in Over 20 Years

The PNG image format just received its first major spec update in two decades, and it’s a big one. With contributions from Adobe, Apple, Google, the BBC, W3C, and more, PNG is now officially modern again, ready to compete with cutting-edge image formats in HDR workflows, animation, and metadata.

So what’s new?

• True HDR Support
  PNG now supports High Dynamic Range color with just 4 extra bytes per image (plus chunk overhead). This brings vivid, wide-gamut color support to a format previously limited to SDR , and it’s designed to be future-proof. The new color encoding is well documented and already supported in major browsers and image tools.

• Animated PNGs (APNGs) Are Now Official
  Long supported unofficially in Firefox and later Chrome and Safari, APNGs are now formally part of the spec. This codifies their place in modern image workflows and clears the way for broader adoption.

• Embedded EXIF Metadata
  PNG now supports embedding EXIF data , including GPS, copyright, and camera settings , just like JPEG. This improves compatibility across photo and archival applications, while reducing reliance on sidecar files.

• Spec Cleanup and Clarifications
  The update also includes long-needed housekeeping: clearer documentation, resolved errata, and harmonized interpretations of key features.

Why Now?

This update was sparked by a need for HDR support in subtitling workflows from the W3C Timed Text Working Group. What began as a narrow technical proposal gained rapid momentum, drawing interest from a who's-who of media and platform giants.

Backers of the new spec include:
Adobe, Apple, BBC, Comcast/NBCUniversal, Google, MovieLabs, and W3C.
With this kind of institutional backing, PNG is not just updated , it’s accelerating.

Already Supported- The updated PNG spec is already implemented in:

• Browsers: Chrome, Firefox, Safari

• Operating Systems: iOS, macOS

• Tools: Photoshop, DaVinci Resolve, Avid Media Composer

Broadcast workflows are also adopting it. So the next time you see an HDR news ticker or sports graphic, there’s a good chance it’s running on this modernized PNG.

Tools & Releases You Should Know About

Rspack 1.4: High-Speed Web Bundling , Now in the Browser

Rspack is a Rust-based web bundler designed to be a faster, drop-in replacement for Webpack.

It compiles modern JavaScript, TypeScript, CSS, and other frontend assets with lightning speed, and is fully compatible with existing Webpack configs , making migration seamless for large codebases.

Version 1.4 takes a bold step forward: Rspack can now run inside the browser, thanks to WebAssembly. This unlocks use cases like online code editors, playgrounds, and instant previews without server roundtrips. For teams building DX tools or educational platforms, Rspack’s new in-browser capabilities offer fast, portable builds where traditional tooling can’t reach.

Electron 37.0: Build Cross-Platform Desktop Apps with Web Tech

Electron is the go-to framework for building desktop apps using web technologies like HTML, CSS, and JavaScript. It packages Chromium and Node.js together, giving developers full control over UI and system-level features in a single codebase.

Electron 37.0 includes the latest Chromium and Node updates, performance improvements, and better compatibility across operating systems. Whether you’re building productivity apps, developer tools, or internal utilities, Electron lets you reuse your frontend skills to ship native-feeling apps across macOS, Windows, and Linux.

ESLint 9.30.1: Cleaner Linting for TypeScript Imports

ESLint is the industry-standard linter for JavaScript and TypeScript projects, helping developers catch bugs early, enforce style guides, and maintain consistent code across teams.

Version 9.30.1 is a patch release, but includes a notable fix for TypeScript users: the no-duplicate-imports rule now allows default and named type imports to coexist from the same module. This resolves a long-standing friction when using TypeScript with strict linting rules, and ensures cleaner, conflict-free import statements without workarounds.

Babel 7.28.0: TypeScript Native, and Ready for the Future

Babel is a widely-used JavaScript compiler that allows developers to use next-gen JavaScript features today by transpiling them to widely supported syntax. It’s essential for large codebases that want to stay modern without sacrificing browser compatibility.

In version 7.28.0, Babel introduces native support for TypeScript config files (babel.config.ts and babel.config.mts), eliminating the need for additional tooling. It also enables ES2026’s explicit resource management by default (using using statements), supports the discard binding proposal (useful for ignoring values in destructuring), and adds a new sourceType option to better handle CommonJS modules.

These upgrades make Babel more capable, ergonomic, and future-ready for modern JS projects, especially in hybrid codebases mixing ESM, CJS, and TypeScript.

And that's it for the forty-second issue of "This Week in JavaScript", brought to you by jam.dev—the tool that makes it impossible for your team to send you bad bug reports.

Feel free to share this newsletter with a fellow developer, and make sure you're subscribed to get notified about the next issue.

Until next time, happy coding!

Welcome to a new edition of "This Week in JavaScript"!

This week, we’re tracking the latest ECMAScript proposals in motion, looking at Angular’s plans to bring LLMs into the developer workflow, unpacking the long-awaited release of Vite 7.0, and exploring V8’s cutting-edge WebAssembly optimizations. Plus, we’ve got some powerful new tools for your development workflow!

Can’t read the newsletter? Listen on the go!

TC39 Moves 9 JavaScript Advancements Across 4 Stages

At the 108th TC39 meeting, nine new proposals moved through the four official standardization stages — showing how fast JavaScript is evolving across performance, safety, and usability.

Stage 1 explores early ideas, Stage 2 defines their shape, Stage 3 signals implementation readiness, and Stage 4 finalizes them for the JavaScript standard.

• Stage 4 now includes three finalized features. First is Explicit Resource Management, which introduces using and await using—declarations that automatically clean up resources like file handles or streams when their block ends. Inspired by patterns from C# and Python, this brings safer and more predictable memory handling to JavaScript. Alongside this, Array.fromAsync offers a clean way to collect async iterable values into an array by returning a promise, making asynchronous data handling more intuitive. Finally, Error.isError lets you reliably check if a value is truly an error object, even across realms or subclassed types—filling a long-standing gap in error-checking behavior. All three are already supported in Chrome 134, Node 22, and Deno 2+.

• Stage 3 brings Immutable ArrayBuffer, a proposal that introduces two methods—transferToImmutable() and sliceToImmutable()—which allow binary data to be frozen and safely shared between threads or runtimes. Once a buffer is made immutable, it can’t be detached or modified, which helps prevent accidental changes and improves performance in scenarios like streaming, file writing, or HTTP responses.

• Stage 2 focuses on predictability and precision. Random.Seeded lets developers create deterministic sequences of random values using a seed, solving long-standing issues in reproducible simulations, tests, and procedural content generation. Meanwhile, Number.prototype.clamp adds a simple and expressive way to restrict any number within a defined min and max range, avoiding the verbosity of Math.min(Math.max(...)) patterns.

• Stage 1 introduces early drafts of three forward-looking ideas. Keep Trailing Zeros adds fine-grained control over how formatted numbers display trailing decimal places—useful in financial apps or when consistency matters. Comparisons proposes a standardized, cross-environment way to print JavaScript values, making test outputs and debugging logs more uniform. Lastly, the proposed Random namespace would unify a range of utilities—like Random.int, Random.sample, Random.shuffle, and more—into a consistent, safer API for generating random numbers and selecting data.

These updates signal a thoughtful evolution of JavaScript balancing power, safety, and simplicity while giving developers better tools to write cleaner, more predictable code.

2. Angular’s Official AI Prompting Standards Are Here

As AI-generated code becomes more common, frameworks like Angular are stepping up to guide it in the right direction. Angular’s team has now introduced a dedicated set of LLM instructions, prompt templates, and context files to help large language models generate code that actually follows Angular best practices.

• It starts with the basics: Angular now provides a system prompt that defines what good Angular code should look like. This includes TypeScript best practices like avoiding any, using strict type checking, and preferring type inference. On the Angular side, the prompt encourages standalone components over NgModules, NgOptimizedImage for image performance, and signals for local state management. Even in templates, native control flow constructs like @if and @for are recommended over their structural directive equivalents. There’s also a push to avoid common anti-patterns like ngClass and ngStyle, instead using class and style bindings directly.

• Beyond prompts, Angular now supports rules files tailored for specific editors and AI IDEs — including Copilot, Cursor, Firebase Studio, JetBrains IDEs, and even Windsurf. These rules help fine-tune LLM behavior inside your development environment by setting guardrails that align with Angular’s evolving standards.

• And to tie it all together, the Angular team is experimenting with llms.txt, a proposed web standard designed to expose structured resources that LLMs can use to better understand a site or framework. Think of it like robots.txt, but for AI models instead of crawlers. There’s a base version that points to prompt files and references, and an extended llms-full.txt with deeper documentation on Angular’s inner workings.

Taken together, these changes don’t just help LLMs write better Angular — they also signal that AI-assisted coding is being treated seriously by framework maintainers.

Vite 7 Is Out With Major Internal Upgrades

Vite 7 marks a major milestone in the evolution of modern frontend tooling. Over the past five years, Vite has grown into a foundational part of the JavaScript ecosystem, powering many frameworks and tools. With over 31 million downloads per week — up by 14 million in just seven months — the growth reflects its central role in enabling faster, modular frontend development.

• One of the most impactful changes in this release is the introduction of a new Rust-based bundler, now available as a drop-in replacement through a separate package. Built to eventually become the default, this bundler significantly improves build performance, especially for large-scale applications. It’s part of a broader effort to modernize the internal architecture and push toward a faster, more efficient toolchain.

• Vite 7 also updates its browser target defaults to a new standard called baseline-widely-available. This shift ensures better compatibility with features that have been supported across major browsers for at least 30 months. With this update, minimum versions are now Chrome 107, Firefox 104, Safari 16.0, and Edge 107 — offering more predictability for future browser support.

• On the Node.js compatibility side, Vite now requires Node 20.19 or 22.12 and drops support for Node 18, which has reached its end of life. These newer versions allow ESM-only distribution while maintaining interoperability with CommonJS modules, simplifying API usage and resolving long-standing compatibility issues.

• The experimental Environment API continues to evolve. Vite 7 introduces a new buildApp hook to help plugins better coordinate environment setup during build processes. While still in review, the API is already showing potential in runtime-specific tooling and integrations. Developers are encouraged to test it out and provide feedback as it moves toward stabilization.

• For testing setups, Vite 7 is fully compatible with the latest versions of Vitest. The update also removes deprecated features like the Sass legacy API and splitVendorChunkPlugin, aiming to keep the codebase lean while preserving backward compatibility for most projects.

• Upgrading to Vite 7 should be relatively straightforward for anyone already on Vite 6. Migration guides are available to help smooth the process, and the complete changelog documents all updates in detail.

V8 Gets Smarter: Speculative Inlining & Deoptimizations

V8 team has rolled out two major performance upgrades for WebAssembly: speculative inlining and deoptimization support — now shipping in Chrome M137. Together, they significantly improve execution speed, especially for apps compiled from higher-level languages like Dart, Java, or Kotlin using the WasmGC model.

• Previously, inlining was limited to direct or well-known function calls. But with call_indirect — where the callee is only determined at runtime — inlining was tricky. Now, V8 uses runtime profiling to identify likely targets at hot call sites and speculatively inlines them. If a function is called frequently via call_indirect, V8 tracks the target using feedback vectors and replaces the call with inlined code for up to four targets. This reduces call overhead and opens the door for further compiler optimizations like constant folding and dead code elimination.

• Speculative optimizations rely on assumptions — and when those assumptions break, V8 needs a safe fallback. That’s where deopts come in. If the inlined assumption is wrong (for example, a different target function is called), V8 exits the optimized path and jumps back into baseline (unoptimized) code without breaking execution. This new deopt support for WebAssembly mirrors what’s long been used in JavaScript JITs and is now a key foundation for even deeper optimizations in future WasmGC workloads.

• Combined, these changes show big wins. On Dart microbenchmarks, V8 saw over 50% speedups, and real-world WasmGC apps (like databases and UI engines) saw 1 to 8% performance boosts. More importantly, this brings WebAssembly performance optimization closer to what we've long had with JavaScript — making Wasm a truly competitive target for modern web and app development.

Tools & Releases You Should Know About

Transformers.js Adds Gemma 3n, Qwen3 Embeddings, and Llava-Qwen2

Transformers.js now supports several new models across NLP, vision, audio, and multimodal tasks. The biggest update is Gemma 3n — a local-first model built for multimodal inputs (text, images, audio, video), optimized to run efficiently with only a 2B footprint despite its 6B parameter design. It also introduces MatFormer, allowing model nesting and custom sub-models via mix-and-match. The Qwen3 Embedding models are also live, purpose-built for dense, multilingual embeddings and reranking. Llava-Qwen2 support is in progress, pairing vision with Qwen2’s language backbone.

zx 8.6: Write Shell Scripts in JavaScript

zx simplifies writing shell scripts using JavaScript, offering a cleaner alternative to bash. Version 8.6 brings improved defaults, cross-platform behavior, and less boilerplate for scripting tasks. Perfect for developers who want to script automation without leaving the comfort of Node.js.

Node.js 22.17.0 LTS Brings Clarity to APIs

The latest Node LTS version discourages instantiating core HTTP classes like IncomingMessage without new, aligning with standard JavaScript expectations. Setting options.shell to an empty string now warns, urging explicit configurations. HTTP/2’s prioritization API is deprecated due to poor ecosystem support. Also stabilized: assert.partialDeepStrictEqual(), a handy utility for partial object testing.

SVGO Continues to Optimize the Web

SVGO remains a trusted tool for minimizing SVG file sizes without affecting rendering. Whether via CLI or Node.js API, SVGO strips away unnecessary metadata and default values. It's widely integrated into tools like PostCSS, webpack, and Docusaurus, helping teams deliver lighter and faster web experiences by default.

And that's it for the forty-first issue of "This Week in JavaScript", brought to you by jam.dev—the tool that makes it impossible for your team to send you bad bug reports.

Feel free to share this newsletter with a fellow developer, and make sure you're subscribed to get notified about the next issue.

Until next time, happy coding!

Welcome to a new edition of "This Week in JavaScript"!

This week, we’ll be lookin into Biome's game-changing v2 release, celebrate the baseline availability of JSON modules across modern browsers, explore Astro's move toward dynamic content, and review some exciting tool releases from Hono, MockRTC, and more.

Can’t read the newsletter? Listen on the go!

Biome v2 is coming for ESLint and Prettier

Biome v2, codenamed Biotype, is officially out and it's big news. For the first time, a JavaScript and TypeScript linter can offer type-aware rules without relying on the TypeScript compiler. This reduces the need for TypeScript as a dependency, improving performance while preserving advanced linting capabilities.

One standout feature is the noFloatingPromises rule, which already detects 75% of the issues caught by typescript-eslint, but at a fraction of the performance cost. This is powered by Biome's newly introduced multi-file analysis and custom type inference engine.

Biome 2.0 also introduces Assist actions, such as import organization and attribute sorting, without diagnostics. Support for monorepos is now significantly better with nested config files, and a new HTML formatter (still experimental) can now handle .html files, bringing Biome closer to supporting Vue and Svelte templates in the future.

Migrating is simple with a built-in migrate command:

npm install --save-dev --save-exact @biomejs/biome

npx @biomejs/biome migrate --write

With Vercel backing the type inference work, Biome is signaling its intent to compete seriously with ESLint and Prettier.

JSON Module Scripts Are Now Baseline in All Major Browsers

The long-requested feature to import JSON as a module is now finally supported across all modern browsers, enabled via import attributes. This marks a big step for standard module behavior on the web, making it easier than ever to work with structured data directly inside JavaScript.

Instead of fetching and parsing JSON manually, you can now write:

import data from './foo.json' with { type: 'json' };

This feature comes from the Import Attributes proposal, which enables passing metadata alongside imports to tell the JavaScript engine how to treat the file. It was split from the original proposal into a separate track to speed up adoption, and now JSON modules are the first to become baseline.

Security concerns around MIME type mismatches led to this explicit declaration approach, ensuring that modules like JSON or CSS don't execute arbitrary code. Future extensions may include support for CSS and HTML modules using the same mechanism. Dynamic imports and re-exports also support the new syntax:

import("./config.json", { with: { type: "json" } })

This change enhances interoperability and simplifies frontend workflows by aligning the module system more closely with what developers expect from modern toolchains like Vite and Webpack.

9 New JavaScript Features in ES2025

ES2025 introduces nine powerful JavaScript features that streamline data manipulation, regular expressions, module imports, and numerical operations. Here’s a quick breakdown of what’s coming:

1. RegExp.escape() - A new static method to safely escape user-inputted strings for use inside regular expressions.

const escaped = RegExp.escape("Hello.");

const re = new RegExp(escaped, 'g');

2. Float16Array - A new typed array that enables 16-bit floating-point operations. Perfect for GPU work, color processing, and memory-sensitive applications.

3. Promise.try() - A more ergonomic way to safely wrap sync or async functions and handle errors immediately.

Promise.try(() => mightThrow()).then(...).catch(...);

4. Iterator Helpers - Additions like .map(), .filter(), .reduce(), .toArray() on native iterators make them much more powerful and array-like.

5. JSON Modules - Now standardized and handled via import attributes, allowing JSON imports to behave predictably and securely.

6. Import Attributes - A syntax improvement to pass metadata along with module imports, like the type of file being imported.

import data from "./file.json" with { type: "json" };

7. RegExp Pattern Modifiers - Support for enabling or disabling regex flags inline within subpatterns.

const re = /^(?i:[a-z])[a-z]$/;

8. New Set Methods - Mathematical operations like .union(), .intersection(), .difference(), and .isSubsetOf() bring power-user capabilities to sets.

9. Duplicate Named Capturing Groups - JavaScript will now support using the same named capture group in multiple parts of a pattern without throwing an error.

These improvements make JavaScript more powerful and expressive for data-heavy, UI-rich, and performance-sensitive applications.

Astro 5.10: Live Content Collections and Stable Responsive Images

Astro 5.10 ships with an exciting new experimental feature: live content collections. Unlike static content that gets compiled at build time, live collections fetch data at runtime. This means your content can now reflect real-time updates, user preferences, or dynamic filters.

This feature is ideal for sites where data changes frequently or is user-specific. Instead of rebuilding your site for every change, live collections let you serve fresh content on demand, improving flexibility without sacrificing performance when static data is sufficient.

Also now stable are Astro's responsive images. These automatically generate optimized image variants and srcsets, helping you reduce layout shifts and improve Core Web Vitals. This is especially useful for performance-focused builds and image-heavy layouts.

Additional updates include CSP improvements, a customizable Cloudflare Workers entrypoint, and enhanced error handling for live content collections using predictable result objects.

Bun v1.2.16: File Routing and Memory Leak Fixes

Bun 1.2.16 introduces support for returning files directly in route handlers using Bun.serve. This allows developers to easily serve static files without manually reading or buffering them.

The update includes 73 bugfixes, memory leak patches, and over 100 additional Node.js compatibility tests. Notably, memory leaks in N-API handle scopes and piped stdio from Bun.spawn have been fixed, improving stability in long-running processes. A new hashing API, Bun.hash.rapidhash, also debuts, promising faster hash computations.

Additional updates include support for vm.SyntheticModule, HTTPParser bindings, and improvements to the bun outdated command, making Bun more versatile for modern web app workflows.

Tools & Releases You Should Know About

LogTape: Structured Logging Across All Runtimes

LogTape is a zero-dependency logging library that works seamlessly in Node, Deno, Bun, browsers, and edge runtimes. It supports structured logging, redaction of sensitive data, template literals for log formatting, and a hierarchical category system for fine-grained log levels.

Its standout feature is the ease of extending it with custom sinks, allowing you to ship logs wherever you want. Whether building a logging solution for a library or a full-stack application, LogTape provides a flexible and consistent API.

Hono: A Lightning-Fast Web Framework That Runs Anywhere

Hono is a tiny and ultrafast web framework built on Web Standards. It works everywhere - Cloudflare Workers, Deno, Vercel, Node, Bun, and more.

With first-class TypeScript support, Hono offers batteries-included middleware, blazing-fast RegExp routing (no linear scans), and a delightful developer experience. Its hono/tiny preset weighs in at under 12kB, making it one of the most lightweight full-featured frameworks out there. If you're building edge-native apps or APIs, Hono is definitely worth a look.

MockRTC: Mock and Test WebRTC Like a Pro

MockRTC gives developers the power to intercept and mock WebRTC connections for testing, debugging, or simulating failure conditions. It can capture traffic, inject behaviors, and even hook into live WebRTC sessions without modifying production code.

You can simulate real peers, automate tests, or create proxy layers for transformation or monitoring. MockRTC's hook functions make integration seamless, and its assertion capabilities help verify edge-case behaviors with confidence. It's a must-have for teams working on real-time communication platforms.

And that's it for the fortieth issue of "This Week in JavaScript", brought to you by jam.dev—the tool that makes it impossible for your team to send you bad bug reports.

Feel free to share this newsletter with a fellow developer, and make sure you're subscribed to get notified about the next issue.

Until next time, happy coding!

Welcome to a new edition of "This Week in JavaScript"!

This week, we’re unpacking Safari 26 Beta’s game-changing WebKit updates, pnpm 10.12’s performance leaps, and Oxlint 1.0’s blazing-fast linting. As always, we’ll also talk about some powerful tools to elevate your development workflow.

Can’t read the newsletter? Listen on the go!

WWDC 2025 & Safari 26 Beta: WebKit in SwiftUI, WebGPU, and CSS Anchor Positioning

Apple’s Safari 26 Beta, released this week, introduces 67 new features and 107 improvements, with WebKit stealing the show. The star is a brand-new WebKit API tailored for Swift and SwiftUI, making it seamless to integrate web content into apps across iOS, iPadOS, macOS, and visionOS. Let’s break down the key additions.

WebView and WebPage: A New Era for Web Integration

• The WebView type, a native SwiftUI View, simplifies displaying web content. With just a URL, you can embed a webpage in your app:

  struct ContentView: View {
  
  var body: some View {
  
  WebView(url: URL(string: "https://www.webkit.org"))
  
  }
  
  }

• WebView supports a suite of view modifiers like webViewScrollPosition, webViewMagnificationGestures, and findNavigator, allowing fine-grained control over the user experience. For advanced use cases, connect WebView to WebPage, a new Observable class designed to manage web content. WebPage enables loading, controlling, and communicating with web content, even without displaying it directly. Its observable properties and functions make reacting to changes effortless, especially in SwiftUI’s reactive paradigm.
  
  For example, you can build a dynamic article viewer:

  struct ArticleView: View {
  
  @Environment(ArticleViewModel.self) private var model
  
  var body: some View {
  
  WebView(model.page)
  
  navigationTitle(model.page.title)
  
  }
  
  }

• The URLSchemeHandler protocol leverages Swift Concurrency to handle custom schemes, enabling local resource loading with an AsyncSequence. Meanwhile, WebPage.NavigationDeciding and WebPage.DialogPresenting protocols let you customize navigation policies and JavaScript dialog presentations, offering unparalleled control over web interactions in your app.

• This API empowers web developers to leverage their JavaScript and HTML skills to create native Apple apps, bridging the gap between web and native development. Whether you’re building a news reader or a web-enhanced dashboard, these tools make integration smoother than ever.

WebGPU: GPU-Powered Computing on the Web

• Safari 26 Beta introduces WebGPU, a JavaScript API that revolutionizes GPU programming. Unlike WebGL, which was built on OpenGL and required heavy translation to modern GPUs, WebGPU maps directly to Apple’s Metal framework, reducing overhead and boosting performance. It supports graphics rendering and introduces compute shaders for general-purpose GPU computations—a first for the web.

• WebGPU uses the WebGPU Shading Language (WGSL, pronounced “wig-sill”), a safe, verifiable language designed for the web. WGSL avoids risks like unchecked bounds accesses, ensuring security without sacrificing power. After over a year in Safari Technology Preview, WebGPU is now stable in Safari 26 Beta across Apple platforms.

• Frameworks like Babylon.js, Three.js, Unity, and Transformers.js already support WebGPU, delivering stunning visuals and complex computations in the browser. For developers, WebGPU’s streamlined validation minimizes performance hits, approaching native app speeds.

CSS Anchor Positioning: Smarter Layouts

• Anchor positioning, a new CSS layout mechanism, simplifies anchoring elements to one another. Paired with the popover attribute (introduced in Safari 17.0), it’s perfect for responsive menus, tooltips, and overlays. The position-area syntax makes layouts intuitive:

  .thing-that-gets-anchored-to {
  
  anchor-name: --profile-button;
  
  }
  
  .item-that-pops-up {
  
  position-anchor: --profile-button;
  
  position: absolute;
  
  top: anchor(bottom);
  
  left: anchor(left);
  
  }

• The anchor() function, combined with absolute positioning, offers pixel-perfect control, ideal for animated anchors or multi-anchor layouts. This feature enhances the web’s layout capabilities, making complex designs more accessible. Safari 26 Beta’s CSS improvements cement its position as a developer-friendly browser.

pnpm 10.12: Near-Instant Installs and Enhanced Catalogs

• pnpm 10.12.1, released this week, supercharges JavaScript package management with an experimental global virtual store and a revamped version catalog system. These updates make pnpm a top choice for developers managing monorepos or large projects.

• The global virtual store slashes install times by linking dependencies to a shared <store-path>/links directory, where packages are stored in folders named after their dependency graph hashes. This NixOS-inspired approach lets multiple projects reuse dependencies without redownloading, delivering near-instant installs on warm caches. Enable it with:

  pnpm config -g set enable-global-virtual-store true
  
  Or add to pnpm-workspace.yaml:
  
  enableGlobalVirtualStore: true

• pnpm auto-disables this in CI environments to avoid slowdowns on cold caches. A YouTube demo shows the speed, and PR #8190 details the tech. Zoltan Kochan, pnpm’s maintainer, highlights its graph-based isolation for robust performance.

• The version catalog system gains flexibility with catalogMode settings: strict enforces catalog versions, prefer allows fallbacks, and manual (default) skips auto-additions. New CLI options --save-catalog and --save-catalog-name=<name> save dependencies to pnpm-workspace.yaml and package.json with catalog: specifiers (PR #9425). The pnpm update command now supports catalog protocols, streamlining dependency updates.

• Minor tweaks include semantic version sorting for pnpm patch, clearer error messages for mismatched specifiers (PR #9598), and a ci setting to flag CI environments. A semi-breaking change updates side-effects cache keys, requiring a new cache (PR #9605). Check the release notes for more.

Oxlint 1.0: Redefining Linting Performance

• Oxlint 1.0, the first stable release of the Rust-powered JavaScript and TypeScript linter, delivers 50–100x faster performance than ESLint. Supporting over 500 rules with zero-config setup, it’s adopted by Shopify, Airbnb, and Mercedes-Benz, transforming linting workflows.

• Oxlint processes 10,000 files per second, linting 264,925 files in 22.5 seconds on 10 threads. Airbnb lints 126,000+ files in 7 seconds with rules like no-barrel-file, where ESLint fails. Mercedes-Benz cut lint times by 71–97%, and Shopify uses it in its admin console. Benchmarks show Oxlint at 615.3ms (multi-thread) versus ESLint’s 33.481s. Open-source projects like Bun and Preact also benefit.
  
  Start linting with:

  npx oxlint@latest

• Customize via .oxlintrc.json, based on ESLint v8’s flat config. The oxlint-migrate tool converts ESLint configs, and eslint-plugin-oxlint supports hybrid setups. Rules include ESLint, TypeScript-ESLint, and plugins like eslint-plugin-react, plus unique Oxlint rules like bad-comparison-sequence. Editor support covers VS Code, IntelliJ, and Zed. See the installation guide.

• Oxlint’s semantic versioning ensures stability, with minor releases adding rules that may affect CI. Review the versioning guide. With maintainer Cameron and a growing team, Oxlint is set to evolve rapidly.

Tools & Releases You Should Know About

Jest 30: Faster, Leaner, Better

Jest 30 brings faster test runs and lower memory usage, with up to 37% speed improvements and 77% less memory in large projects. It drops Node 14/16/19/21 support, upgrades jsdom to v26, and requires TypeScript 5.4+. New features include expect.arrayOf for array validation, test.each with a %$ placeholder, and jest.advanceTimersToNextFrame() for animation testing. Configurable retries and jest.unstable_unmockModule() enhance control. Check the migration guide for breaking changes.

Orange ORM: Seamless Database Integration

Orange ORM is a powerful Object-Relational Mapper for Node.js, Bun, and Deno, supporting TypeScript and JavaScript. Its intuitive querying and Active Record pattern simplify database interactions without code generation. It works in browsers via an Express.js plugin, ensuring secure credential handling. Ideal for developers needing flexible, typed database solutions.

Vue Equipment: Frontend Toolkit

Vue Equipment offers unstyled, typed plugins and composables for Vue and Nuxt apps. With a clean API, it reduces complexity using CSS variables, grouped options, and exposed state via data attributes. It’s perfect for developers building modern web apps without reinventing common solutions.

darkmodejs: Easy Dark Mode

darkmodejs simplifies dark mode on the web using the prefers-color-scheme media query and matchMedia API. It supports macOS 10.14+, iOS 13+, and Windows 10+, with v2+ using addEventListener for modern compatibility. A lightweight utility for theme-aware sites.

And that's it for the thirty-ninth issue of "This Week in JavaScript", brought to you by jam.dev—the tool that makes it impossible for your team to send you bad bug reports.

Feel free to share this newsletter with a fellow developer, and make sure you're subscribed to get notified about the next issue.

Until next time, happy coding!

Welcome to a new edition of "This Week in JavaScript"!

This week, we’re hyped about Cursor 1.0’s release and how it might make VS Code obsolete, Rolldown’s lightning-fast Vite builds, TC39’s bold JavaScript advancements, and WebStatus.dev’s game-changing web insights. As always, we’ll also talk about some powerful tools to elevate your development workflow.

Can’t read the newsletter? Listen on the go!

Forget VS Code, Cursor 1.0 Is Finally Here

Cursor 1.0 has landed, bringing AI-driven coding to new heights with BugBot for automated pull request reviews, Background Agent for remote coding tasks, Memories for contextual intelligence, Jupyter Notebook integration, and one-click MCP setup. It’s a must-have for JavaScript devs looking to automate and accelerate their workflows.

• BugBot enhances code quality by automatically reviewing pull requests on GitHub, identifying bugs and potential issues, and providing detailed comments. It includes a “Fix in Cursor” button that directs you to your editor with a pre-filled prompt to address the issue.

• Background Agent enables developers to execute remote coding tasks efficiently. You can activate it using Cmd/Ctrl+E or the cloud icon in the chat interface. If you enable privacy mode, Cursor will soon provide full support to ensure secure workflows. Developers who adopted Background Agent early praised its efficiency, and now all users can utilize it to generate React components or optimize Node.js APIs.

• Memories, currently in beta, transforms how Cursor understands your projects by storing project-specific facts for each user and project. You can manage these facts through Settings → Rules, allowing Cursor to recall details like your preferred state management approach, which results in more accurate suggestions.

• For data science professionals, Cursor’s Jupyter Notebook support allows the Agent to create and edit multiple cells directly, significantly improving productivity. This feature, available only with Sonnet models, makes Cursor ideal for crafting JavaScript-driven data visualizations or machine learning pipelines.

• Cursor simplifies server authentication with one-click MCP installations and OAuth support. A curated list of official MCP servers is available at docs.cursor.com. The chat interface now supports richer responses, the redesigned Settings and Dashboard provide a polished user experience, offering analytics on tool and model usage, which helps teams optimize their workflows.

This JavaScript Bundler Is FAST AF

Rolldown, a next-generation bundler built in Rust, is revolutionizing the core of Vite. The rolldown-vite package serves as a drop-in replacement for Vite, delivering exceptional performance improvements for JavaScript applications. As a technical preview, Rolldown leverages Oxc, a high-performance JavaScript toolkit that handles parsing, transforming, resolving, and minifying, setting new benchmarks for speed and efficiency.

• By replacing Vite’s dependency on esbuild with Oxc, Rolldown achieves build time reductions ranging from 3 to 16 times faster and reduces memory usage by up to one hundred times. For example GitLab’s build time decreased from 2.5 minutes to 40 seconds, Excalidraw’s from 22.9 seconds to 1.4 seconds, Appwrite’s from over 12 minutes to 3 minutes, and Particl’s from over a minute to 6 seconds, outperforming Vite by nearly ten times and Next.js by twenty-nine times. Even this blog post, built using VitePress with Rolldown Vite, completed in just 1.8 seconds on Netlify. To integrate Rolldown Vite, you can alias Vite in your package.json:

{

"dependencies": {

"vite": "npm:rolldown-vite@latest"

}

}

• For projects using VitePress or meta-frameworks, you can use overrides to replace vite with rolldown-vite. Most Vite plugins and frameworks are compatible, though some incompatibilities exist, which you can review in the migration guide. As a standalone package, rolldown-vite allows rapid iteration, though patch versions may introduce breaking changes, which are documented in its changelog. Once stabilized, Rolldown will integrate into Vite’s main codebase, phasing out the separate package.

• Rolldown Vite is a must-try for developers building performance-critical JavaScript applications.

Upcoming JavaScript Features From TC39

The 108th TC39 meeting advanced nine JavaScript proposals, with three,Array.fromAsync, Error.isError, and Explicit Resource Management,reaching Stage 4, positioning them for inclusion in the ECMAScript specification. These developments enhance JavaScript’s capabilities for asynchronous workflows and resource management.

• The Array.fromAsync proposal, simplifies the handling of asynchronous iterables, eliminating the need for manual for await...of loops. It serves as a native alternative to libraries like it-all, which sees 50,000 weekly downloads, and supports asynchronous iterables, synchronous iterables with promises, and array-like objects.

  For example:

async function* asyncGen(n) { for (let i = 0; i < n; i++) yield i * 2; }

const arr = await Array.fromAsync(asyncGen(4)); // [0, 2, 4, 6]

This feature is particularly valuable for unit tests, command-line applications, or streaming data processing in Node.js, offering optional mapfn and thisArg parameters for added flexibility.

• The Error.isError proposal, introduces a reliable method for detecting errors across different realms, resolving inconsistencies with instanceof Error in environments like iframes or Node.js virtual machines. This improvement is crucial for debugging, serialization tasks in platforms like RunKit, or structured cloning operations.

• The Explicit Resource Management proposal, introduces using and await using declarations, supported by DisposableStack and AsyncDisposableStack, to ensure deterministic cleanup of resources such as file handles, streams, or locks. Inspired by C#’s using and Python’s with statements, it reduces boilerplate code significantly.

  For instance:

using handle = acquireFileHandle(); // Automatically disposes at block end

const stack = new DisposableStack(); // Manages multiple resources

stack.use(resource1); stack.use(resource2); // Ensures reverse-order cleanup

• This approach mitigates common errors, such as omitting try/finally blocks or mismanaging multiple resources, in Node.js applications that handle files or streams. These advancements collectively empower JavaScript developers to build robust asynchronous APIs and resource-intensive systems.

The Ultimate Web Platform Dashboard

WebStatus.dev has undergone a massive evolution, now tracking over 1000 web platform features,nearly 100% coverage,with mobile browser data, usage timelines, and deep insights to guide JavaScript apps toward Baseline interoperability. It’s an indispensable tool for front-end developers.

• Sourced from the W3C’s web-features project, involving all major browser vendors, WebStatus.dev provides Chrome usage data since 2012, complete with adoption timelines for nearly all features.

• Mobile browser support highlights Baseline gaps, enabling smarter progressive enhancement strategies for React or Vue apps. Powerful sorting and filtering let you query specific scenarios, like API landing in Safari in the last 12 months that were already in Chrome and Firefox, sorted by usage. Shareable dashboards streamline team workflows, letting you create custom views for Web UI APIs or project-specific needs.

• This helps devs like you plan adoption of cutting-edge APIs. WebStatus is a must for building cross-browser JavaScript apps with confidence.

Tools & Releases You Should Know About

• @platformatic/php-node: This innovative Node.js runtime seamlessly integrates PHP into your Node.js applications, allowing PHP to function as a high-performance request processor. Developed using Rust and napi.rs, it employs a language-agnostic lang_handler system to route requests to multi-threaded PHP workers within Node.js’s worker pool, significantly reducing latency by eliminating network calls.This tool is perfect for developers who seek a unified development environment for JavaScript and PHP, simplifying workflows and boosting application performance.

• Starry Night v3.8: This open-source syntax highlighter replicates the functionality of GitHub’s closed-source PrettyLights, supporting over 600 programming languages with TextMate grammars, which deliver exceptional quality, as used in editors like VS Code, SublimeText, and Atom. Starry Night generates abstract syntax trees (ASTs) for versatile rendering, such as ANSI sequences for command-line interfaces or React/Preact for virtual DOM applications, and supports CSS-driven themes for effortless dark mode integration. Unlike shiki, which uses inline styles, Starry Night’s CSS class-based approach simplifies theming, making it a top choice for developers building code-rich platforms.

• ngx-vflow: This Angular library empowers developers to create node-based applications, ranging from static diagrams to fully interactive visual editors. Built on Angular signals for outstanding performance, ngx-vflow simplifies complex interactions like dragging, zooming, and curve rendering through an intuitive API. Whether you are visualizing JavaScript application architectures or debugging Angular-based pipelines, ngx-vflow provides robust, scalable solutions for building interactive development tools.

• Docusaurus 3.8: This powerful React-based documentation platform boosts build performance with Docusaurus Faster, leveraging Rspack’s persistent cache and Node.js worker threads for 2–5x faster rebuilds and 2x quicker static site generation. New Future Flags prepare your site for Docusaurus 4, while optimizations like SVG sprites and macOS startup tweaks enhance efficiency. Perfect for JavaScript devs crafting sleek, high-performance documentation sites for React or Node.js projects.

And that's it for the thirty-eighth issue of "This Week in JavaScript", brought to you by jam.dev—the tool that makes it impossible for your team to send you bad bug reports.

Feel free to share this newsletter with a fellow developer, and make sure you're subscribed to get notified about the next issue.

Until next time, happy coding!

Welcome to a new edition of "This Week in JavaScript"!

This week, we’re hyped about Angular v20’s lightning-fast features, Remix’s game-changing framework overhaul, and the future of JavaScript. We’ve also got an updated list of tools supercharge your development workflow, as always

Can’t read the newsletter? Listen on the go!

Angular v20 Is Now 35% Faster

At Google I/O on May 21, 2025, the Angular team announced Angular v20, scheduled for release on May 29. This version significantly enhances server-side rendering (SSR), signals, and authoring capabilities, providing an improved developer experience and optimized application performance.

Zoneless Angular (Developer Preview)

• Zone.js is now optional: Angular supports running without Zone.js by leveraging signals for precise change detection.

• Efficient UI updates: Developers can use markForChange or signal state awareness to trigger targeted change detection.

• Example of enabling zoneless mode:

  typescript
  
  bootstrapApplication(App, {
  
  zoneless: true
  
  });
  
  Manual change detection invocation:
  
  typescript
  
  import { markForChange } from '@angular/core';
  
  markForChange();

Signal Ecosystem Enhancements

• Signals and Computed are stable: Recommended for reactive state management.

• LinkedSignal (stable in v20): Supports writable signals with access to previous state values.

  typescript
  
  const count = signal(0);
  
  const double = computed(() => count() * 2);
  
  const history = linkedSignal([], (prev, next) => [...prev, next]);

• Resource and HTTPResource: Simplify asynchronous data fetching; StreamingResource supports real-time UI updates.

  typescript
  
  const user = resource(async () => await fetchUser());
  
  const posts = httpResource('/api/posts');

Server-Side Rendering (SSR) Improvements

• Route-level render mode APIs: Enable hybrid rendering strategies, allowing SSR, static site generation, and client-side rendering on a per-route basis.

  typescript
  
  export const routes: Routes = [
  
  { path: '', component: HomeComponent, renderMode: 'ssr' },
  
  { path: 'about', component: AboutComponent, renderMode: 'client' }
  
  ];

• Incremental hydration: Allows deferring component hydration using Angular’s defer block, reducing initial JavaScript bundle size.

• Event replay: Captures and replays user interactions during JavaScript loading to prevent missed events.

Authoring Experience Improvements

• Standalone components as the default: Simplifies development by reducing reliance on NgModules.

• Introduction of let syntax: Provides a cleaner way to declare template variables.

  xml
  
  <ng-container *let="user of userSignal()">
  
  {{ user.name }}
  
  </ng-container>

• Untagged literals for dynamic styling: Enables direct binding of dynamic class and style objects.

  xml
  
  <div [class]="{ active: isActive }"></div>

• Hot Module Replacement (HMR): Maintains application state during development reloads, enhancing developer productivity.

New Integrations and Tooling

• Experimental Vite support for testing: Offers faster and modernized development workflows.

• Custom Angular track in Chrome DevTools: Flame charts now include color-coded frames for Angular change detection and TypeScript execution.

• Firebase App Hosting: Provides streamlined deployment for SSR applications.

Additional Highlights

• AI portal launch: angular.dev/ai introduces AI-driven workflows to assist Angular developers.

Angular v20 delivers substantial improvements across SSR, reactive programming with signals, authoring, and developer tooling, reinforcing its position as a robust framework for enterprise-grade applications.

Remix v3 And The Breakup With React

Remix v2 powers React Router v7 with robust server-side rendering capabilities, enabling fast, scalable applications used by Shopify, GitHub, and over 11 million projects worldwide. Its architecture is well suited for e-commerce platforms, blogs, and other content-driven sites, providing a reliable full-stack React framework experience.

Following the close integration and eventual merging of Remix into React Router v7, as detailed in the merging announcement, Remix v2 had become a thin wrapper around React Router. This consolidation allowed React Router to inherit many of Remix’s strengths, including server-side rendering and React Server Components (RSC) support, creating a stable, battle-tested platform with long-term support.

Remix v3 marks a significant departure from this model. It replaces React with the lightweight Preact library and embraces a model-first, low-dependency, web API-centric approach. This reimagining minimizes reliance on heavy build tools by favoring runtime execution, making it ideal for AI-driven applications, lightweight websites, and modern web development workflows.

Key features of Remix v3

• Web API-Centric Design: Leveraging web standards and native browser APIs reduces complexity and shortens the learning curve, allowing developers to focus on building rather than framework-specific abstractions.

• Minimal Dependencies: Adhering to a “no dependencies” philosophy, Remix v3 frees developers from external package roadmaps and increases project control.

• Modular Architecture: Bundled components such as database connectors and a revived Reach UI library simplify setup and customization. Single-purpose modules enable easy swapping or upgrading of parts.

• Composability and Flexibility: The framework encourages mixing and matching tools, providing a scalable developer experience suitable for both small and large projects.

• Performance and Reliability: Google’s use of Preact underscores the framework’s stability and efficiency. Runtime optimizations and reduced bundle sizes contribute to faster load times and smoother user experiences.

• Developer Experience: Drawing from years of web-building expertise, Remix v3 focuses on simplicity, clarity, and productivity, aiming to make development intuitive and enjoyable.

Overall, Remix v3 represents a bold evolution toward leaner, faster web applications by reimagining the framework’s foundations around modern web standards and minimalism. It is poised to reshape how developers build scalable, high-performance web apps with a fresh, streamlined approach.

The BIGGEST JavaScript Change?

The Temporal API, a modern replacement for JavaScript’s legacy Date object, has been in development for several years and is now enabled by default in Firefox 139, with broader runtime support expected soon. This API addresses long-standing issues with date and time handling, offering a more reliable, precise, and developer-friendly approach.

Key improvements and features

• Comprehensive Time Zone Support: Unlike the traditional Date object, Temporal supports full IANA time zones, enabling accurate handling of local times worldwide.

• Immutability: All Temporal objects are immutable, preventing unintended side effects and making date/time manipulation safer.

• Consistent Parsing and Formatting: Strict adherence to ISO 8601 standards ensures reliable parsing and serialization across environments.

• Fine Precision and Extended Range: Supports nanosecond precision and a wider range of dates, suitable for high-precision and historical applications.

• Clear Separation of Date/Time Concepts: Multiple specialized classes such as PlainDate, PlainTime, PlainDateTime, ZonedDateTime, and Duration allow developers to work precisely with the data they need without confusion.

Example

typescript

const date = Temporal.PlainDate.from("2025-05-23");

const oneWeekLater = date.add({ days: 7 }); // 2025-05-30

const dt = Temporal.PlainDateTime.from("2025-12-31T23:30");

const nextHour = dt.add({ hours: 1 }); // 2026-01-01T00:30

The Temporal API’s introduction marks a significant evolution in JavaScript date/time handling, eliminating many pitfalls of the old Date object such as DST bugs, mutability, and inconsistent parsing. Its rollout in Firefox 139 signals readiness for wider adoption, promising developers a robust, standardized toolset for all date and time needs in modern web applications.

Tools & Releases You Should Know About

Let’s speed-run through some of the other big tool updates this week!

• ReactJust.dev is a minimal, zero-config React starter kit focused on simplicity and performance. It provides a clean, lightweight foundation with minimal dependencies, enabling fast project setup without complex tooling. Designed for developers who want to quickly bootstrap React apps, it supports modern React features and best practices out of the box. Ideal for prototypes, small projects, or learning React fundamentals, ReactJust.dev streamlines development by eliminating boilerplate and unnecessary complexity, helping you focus on building your app efficiently.

• Bun v1.2.15: Delivers bun audit to catch dependency risks and bun pm view for package insights, fixing 11 issues with 261 upvotes. New BUN_OPTIONS and node:vm support enhance Node.js compatibility, ideal for secure APIs or microservices.

• Ink 6.0: Brings React-style UI building to command-line apps with Flexbox layouts, using Yoga for CSS-like designs. It’s perfect for crafting interactive CLI tools or scripts, with full React feature support.

• JSPM 4.0: Simplifies ESM workflows with import maps, TypeScript stripping, and zero-config builds for web-standard apps. Its focus on native modules makes debugging easy and keeps projects future-proof.

• Faker 9.8: Creates realistic fake data like names, addresses, and crypto details across 70+ locales for testing or prototyping. From job titles to product names, it’s a quick way to mock up robust datasets.

And that's it for the thirty-seventh issue of "This Week in JavaScript", brought to you by jam.dev—the tool that makes it impossible for your team to send you bad bug reports.

Feel free to share this newsletter with a fellow developer, and make sure you're subscribed to get notified about the next issue.

Until next time, happy coding!

Welcome to a new edition of "This Week in JavaScript"!

This week, we’re buzzing about Angular v20’s blockbuster reveal at Google I/O, Anthropic’s Claude 4 revolutionizing coding, TypeScript’s lightning-fast native compiler, and ESLint’s v9.0 milestone reflections. Plus, a killer lineup of tools, including Astra and Defuddle, to supercharge your development workflow.

Can’t read the newsletter? Listen on the go!

Angular v20 Previewed at Google I/O 2025

At Google I/O on May 21, 2025, the Angular team dropped a bombshell, unveiling Angular v20, set to launch May 29. This release turbocharges server-side rendering (SSR), signals, and authoring, delivering a slicker developer experience and blazing-fast apps.

• Zoneless Angular (Developer Preview): Ditches Zone.js for precise change detection using signals, slashing unnecessary DOM checks. Use markForChange or signals’ state awareness for targeted updates.

• Signal Ecosystem Overhaul: Signal and Computed are now stable, with LinkedSignal (stable in v20) enabling writable, state-dependent signals that access prior states. Resource and HTTPResource streamline async data fetching, with StreamingResource for real-time UI updates.

• SSR Enhancements: Route-level render mode APIs allow hybrid rendering (SSR, static site generation, client-side). Incremental hydration defers component hydration via defer blocks, reducing initial bundle sizes. Event replay captures user interactions during JS loading, ensuring no missed clicks.

• Authoring Improvements: Standalone components are default, with let syntax for template variables and untagged literals for dynamic class/styling. Hot module replacement (HMR) preserves app state during dev.

• New Integrations: Experimental Vite support for testing, a custom Angular track in Chrome DevTools’ flame chart (color-coded for change detection, TypeScript), and Firebase App Hosting for seamless SSR deployments.

Angular v20 is a powerhouse for enterprise apps, with a new AI portal (angular.dev/ai) for LLM-driven workflows. Tune in to the v20 event on May 29 at 9 AM Pacific on YouTube!

Anthropic’s Claude 4: A Coding Revolution

Anthropic unveiled Claude 4 (Opus 4 and Sonnet 4) on May 23, 2025, setting a new bar for coding AI. With 72.5% (Opus) and 72.7% (Sonnet) on SWE-bench, these models power Claude Code and top-tier coding agents, transforming JavaScript workflows.

• Opus 4’s Coding Edge: Leads with 43.2% on Terminal-bench, excelling in long-running tasks (e.g., 7-hour open-source refactors). Creates “memory files” for local file access, boosting task coherence (e.g., generating a Pokémon “Navigation Guide”).

• Sonnet 4’s Efficiency: Balances performance and cost, with enhanced steerability for precise implementations. Reduces navigation errors from 20% to near zero, ideal for multi-file edits and autonomous app development.

• Agentic Improvements: 65% less shortcut behavior, with parallel tool execution and memory enhancements. Thinking summaries (using a smaller model) condense long thought processes, with full chains available via Developer Mode.

• Claude Code SDK: Now generally available, integrates into VS Code/JetBrains (beta extensions) for inline edits. The SDK enables custom agents, with a GitHub beta for PR feedback and CI error fixes.

• Use Cases: Cursor praises Opus 4’s codebase understanding, Replit lauds multi-file precision, and GitHub integrates Sonnet 4 into Copilot for agentic scenarios.

Claude 4 is a JavaScript developer’s dream, automating complex tasks with surgical precision.

ECMAScript 2026: The Future of JavaScript

The ECMAScript 2026 Language Specification, the 17th edition, is shaping up to evolve JavaScript further. Building on ECMAScript 2025’s pattern matching and JSON module imports, it’s set to enhance web, server, and embedded apps.

• Proposed Features: New Set methods (union, intersection, difference) for robust data manipulation. Enhanced regex with potential duplicate named capturing groups.

• Performance Focus: Optimizations for reactive systems and async operations, building on Promise.try and RegExp.escape from 2025.

• Ecosystem Impact: Aims to streamline state management and improve interoperability with frameworks like React and Angular.

ECMAScript 2026 keeps JavaScript at the cutting edge, powering tomorrow’s apps.

ESLint v9.0.0: Lessons from a Landmark Release

On May 21, 2025, Nicholas C. Zakas reflected on ESLint v9.0’s April 2024 release, which introduced the flat-config system, streamlining linting for JavaScript developers.

• Flat-Config System: Replaces eslintrc with a single eslint.config.js, simplifying rule setups. Supports ESLint#calculateConfigForFile for dynamic configs.

• New Features: Config inspector (--inspect-config) visualizes rule setups. Enhanced Node.js version handling for better compatibility.

• Challenges: Breaking changes caused migration hurdles, with lessons for smoother transitions in v10.

Trusted by Microsoft and Netflix, ESLint v9.0.0 remains a code quality cornerstone.

Tools & Releases You Should Know About

Let’s speed-run through some of the other big tool updates this week!

• Astra: This CLI tool compiles JavaScript into standalone Windows executables, bundling Node.js apps into single .exe files without external dependencies. Supports custom icons and metadata for branded apps. Ideal for desktop utilities or distributing CLI tools, with a lightweight footprint and fast startup. Perfect for developers targeting Windows users with zero-hassle installs.

• Defuddle: A JavaScript library for extracting clean, readable content from web pages by stripping clutter like ads and sidebars. Uses heuristic parsing and DOM traversal to isolate main content, with options to customize extraction rules. Great for scraping, content aggregation, or building reader modes, with minimal setup and high accuracy on complex sites.

• Crosspost: A CLI tool for cross-posting content from one blogging platform to another, built with Node.js. Supports platforms like Dev.to, Hashnode, and Medium, with configurable mappings for markdown, frontmatter, and metadata. Handles authentication via API tokens and batch processing for bulk posts. Perfect for JavaScript developers managing multiple blogs, saving time on content syndication.

• Peggy: A parser generator for JavaScript that creates fast, customizable parsers from PEG (Parsing Expression Grammar) definitions. Generates standalone or module-based parsers with zero dependencies, supporting complex grammars for DSLs, compilers, or data formats. Features error reporting, tracing, and TypeScript compatibility. Ideal for devs building language tools or processing structured data in JavaScript.

And that's it for the thirty-sixth issue of "This Week in JavaScript", brought to you by jam.dev—the tool that makes it impossible for your team to send you bad bug reports.

Feel free to share this newsletter with a fellow developer, and make sure you're subscribed to get notified about the next issue.

Until next time, happy coding!

Welcome to a new edition of "This Week in JavaScript"!

Today, we're exploring OpenAI's groundbreaking Codex system, JavaScript's new resource management capabilities, and Basecoat's framework-agnostic UI components, plus five exciting new tools to code and develop faster!

Can’t read the newsletter? Listen on the go!

OpenAI Codex is Finally Here

Codex is OpenAI’s software engineering agent that helps developers, especially web and JavaScript developers-automate coding tasks, boost productivity, and handle multiple tasks securely. Each task runs in its own cloud sandbox environment, preloaded with your repository.

Built for developers:
Codex excels in JavaScript and frameworks like React, Node.js, and TypeScript. It can generate, refactor, debug code, write tests, and help understand codebases for both frontend and backend projects.

Technical details:
Powered by the codex-1 model and trained via reinforcement learning on millions of coding tasks, Codex runs in secure, isolated cloud containers. It takes natural language or code prompts, generates code, and runs tests and linters automatically until passing.

Parallel task handling:
Codex can manage multiple tasks at once, such as adding features, fixing bugs, and running tests, speeding up development and reducing interruptions.

Use cases:

• Prototyping React components with accessibility

• Migrating JavaScript to TypeScript

• Automating Node.js CI/CD pipelines

• Enhancing test coverage and debugging

• Helping non-developers with small fixes

• Supporting large refactors in companies like Cisco

Security and compliance:
Runs in sandboxed environments without internet access, protecting sensitive data and including automatic vulnerability scanning.

Limitations & future plans:
Some tasks take up to 30 minutes; no visual design or real-time collaboration yet. Future updates include browser-based execution, Figma integration, and multi-agent coordination.

JavaScript’s New Superpower: Explicit Resource Management in V8 v13.8

The V8 engine now introduces Explicit Resource Management (ERM) — a feature long requested by developers seeking more control over resource cleanup. Traditionally, JavaScript relied on garbage collection, making resource disposal non-deterministic. ERM changes that.

• using Blocks: Wrap resources like file handles or streams in using/await using blocks for automatic cleanup.

• Custom Disposable Protocol: Objects can implement a [Symbol.dispose]() or [Symbol.asyncDispose]() method to define how they release external resources.

• Synchronous + Async Support: This covers both sync and async resource management needs.

This gives developers more deterministic control — especially for scenarios involving file handles, streams, sockets, or GPU resources — all without waiting for GC to catch up.

Deno Fresh is (Still) Here, with a v2 Upgrade

The Deno team just dropped a major update on Fresh, their edge-first full-stack web framework built for performance and simplicity. With V1.6 and beyond, Fresh is moving into a more mature phase of development.

• New Build System: Fresh now uses a faster Rust-based builder (Island Builder) to speed up dev experience and production builds.

• Improved DX: A simplified CLI, better error messages, and smarter routing improve developer onboarding and iteration speed.

• New Plugin Architecture: Official support for plugins and integrations, starting with Tailwind and Deno KV.

Focused on "island-based" rendering, Fresh delivers fast pages by sending minimal JavaScript to the client — ideal for edge environments like Deno Deploy. Fresh is increasingly becoming a strong choice for those who want performance without giving up on Developer Experience.

Node.js Released Critical Security Updates

Heads up, Node.js developers! Critical security patches are out for multiple versions — including v24.0.2, v23.11.1, v22.15.1, and v20.19.2. If you’re running on Node, this one’s important.

• Cryptographic Fix: Resolves crashes during TLS and encryption operations, essential for secure data handling.

• HTTP Header Bug: Prevents request manipulation and protects against accidental data leaks.

• Memory Leak Patch: Improves performance for long-running servers and background services.

If you’re on an LTS version, this is a must-do update. Don’t skip it!

Tools & Releases You Should Know About

Let’s speed-run through some of the other big tool updates this week!

• diff v8.0.1: The popular text diffing library now offers improved performance for large datasets, better error handling, and an updated online demo—perfect for JavaScript-based CLIs or code editors.

• React Aria Components v1.3: Enhanced accessibility for React apps with new components for modals and tooltips, plus better keyboard navigation—ideal for building inclusive user experiences.

• UnJS Nitro v2.9: This server toolkit now offers even faster cold starts, enhanced TypeScript support for stricter type safety, and improved middleware handling—perfect for JavaScript server-side projects.

• Tamagui v1.126.13: A UI library for React Native and web, now with improved performance for complex layouts, new adaptive components for responsive design, and enhanced theming options—your cross-platform UI just got even better.

And that's it for the thirty-fifth issue of "This Week in JavaScript", brought to you by jam.dev—the tool that makes it impossible for your team to send you bad bug reports.

Feel free to share this newsletter with a fellow developer, and make sure you're subscribed to get notified about the next issue.

Until next time, happy coding!

Welcome to a new edition of "This Week in JavaScript"!

Today, we're covering major VSCode improvements, the long-awaited k6 1.0 release, Node.js 24 features, and a roundup of essential tools you should know about!

Can’t read the newsletter? Listen on the go!

Node.js 24: More Power, More Features

Node.js 24 has landed with significant improvements across the board:

Major Updates:

• V8 13.6: Adds support for Float16Array, explicit resource management, and RegExp.escape.

• npm 11: Improved performance and enhanced security features.

• AsyncLocalStorage Overhaul: Now uses AsyncContextFrame by default for more efficient context tracking.

• URLPattern Goes Global: Available without explicit imports.

• Permission Model Improvements: Flag simplified from --experimental-permission to just --permission.

• Test Runner Enhancements: Automatically waits for subtests to finish.

This release will enter long-term support in October, offering a solid foundation for your production applications.

Visual Studio Code 1.100: AI Gets Personal

Visual Studio Code just hit version 1.100, and it's a game-changer for AI-assisted coding:

Key Highlights:

• Custom Instructions: Create .instructions.md files to set personal guidelines for the AI model – think code style preferences and framework choices.

• Reusable Prompts: Save common chat requests with .prompt.md files for repetitive tasks.

• Faster Agent Mode: Dramatic speed improvements for large files with new editing formats from both OpenAI and Anthropic.

• Multi-Window Support: Enhanced experience when working with chat and editors across multiple windows.

This release transforms how the AI assistant understands your coding style, making it feel like it's truly part of your development team.

k6 Hits 1.0: JavaScript Load Testing Grows Up

After years of development, k6 has officially reached version 1.0, offering a mature solution for realistic load testing:

What Makes It Special:

• Tests as Code: Write load tests in JavaScript that can be version-controlled and integrated with CI pipelines.

• Powerful Performance: Built on Go for efficiency, but with a familiar JavaScript API for web developers.

• Multi-Protocol Support: Works with HTTP, WebSockets, gRPC, Browser interactions, and more.

• Realistic Traffic Simulation: Generate significant load even on modest hardware.

Perfect for ensuring your applications can handle real-world traffic patterns before issues arise in production.

Tools & Releases You Should Know About

Let's speed-run through some of the other big tool updates this week!

• ESLint v9.26.0: Your linter just got superintelligent with AI integration! The new Model Context Protocol server lets GitHub Copilot run linting commands directly in your workflow, while new protection against globalThis shadowing eliminates those weekend-ruining bugs that plague JavaScript developers.

• Mapbox GL JS 3.12: Transform boring maps into breathtaking 3D masterpieces with experimental road intersections and shadow rendering for elevated lines. With butter-smooth pattern transitions and performance improvements, your users might spend more time admiring your maps than using your app!

• Relay v19: The GraphQL type-safety guardian angel you never knew you needed! Required @alias directives on conditional fragments save you from mysterious runtime errors, while the included codemod automatically fixes your existing code while you grab coffee.

• Electron 36: Making web devs feel like native app wizards with Chromium 136, V8 13.6, and Node 22.14.0 in one powerful package. The showstopper? macOS Writing Tools integration that gives your desktop apps spell-checking capabilities that would make Grammarly jealous.

• Mantine 8.0: The React UI library that finally fixed time zones! Featuring deeply nested menu submenus, a TimePicker component that makes dealing with time actually enjoyable, and string-based date values that finally end those timezone headaches that had you considering a career change.

And that's it for the thirty-fourth issue of "This Week in JavaScript", brought to you by jam.dev—the tool that makes it impossible for your team to send you bad bug reports.

Feel free to share this newsletter with a fellow developer, and make sure you're subscribed to get notified about the next issue.

Until next time, happy coding!

Welcome to a new edition of "This Week in JavaScript"!

This week, we've witnessed a seismic legal victory that changed the app development landscape forever, groundbreaking performance boosters for JavaScript engines, and incredible tools going completely free.

Can’t read the newsletter? Listen on the go!

This Google Chrome Feature Makes JavaScript Run Faster

Chrome's V8 team just dropped a game-changing feature that makes JavaScript blazingly fast!

Key Features:

• Explicit Compile Hints let developers control which functions compile at startup

• Simple magic comment (//# allFunctionsCalledOnLoad) tells V8 what to prioritize

• Average load time improvements of 630 milliseconds across major websites

• Zero refactoring required - just add comments and watch performance soar

This isn't just an incremental update—it's a turbo boost for web applications with minimal developer effort.

GSAP is now Free

In a stunning move, Webflow has acquired GSAP and made EVERYTHING completely free!

What's Included:

• All premium plugins (SplitText, MorphSVG) now available to everyone

• SplitText 3.13 completely rewritten: 50% smaller with 14 new features

• Perfect accessibility, responsive layouts, and emoji support

• New feature: animate TO CSS variables for dynamic theming

The animation ecosystem just democratized overnight, putting professional-grade tools in every developer's hands.

The JavaScript Hack No One Talks About

Converting values to a string in JavaScript might sound like a small task, but it is surely very complicated. Here's the developer lifesaver you didn't know you needed!

The Problem:

• Most string conversion methods fail on symbols and null-prototype objects

• Different approaches crash on different types

• Your code randomly explodes with certain values

The Solution:

• Object.prototype.toString.call(value) handles everything perfectly

• Works with symbols, null-prototypes, and all edge cases

• It's like having a universal translator for JavaScript values

Tools & Releases You Should Know About

Let's speed-run through some of the other big tool updates this week!

• Deno 2.3: Compile your apps into single files with everything included, install packages 2x faster, and automatically clean up memory leaks with the new ‘using’ keyword. Perfect for building standalone executables that work anywhere without requiring users to install Deno or dependencies.

• Prisma 6.7: Ditched Rust for TypeScript to run faster, split your database models into separate files for better organization, and now supports JavaScript-native SQLite out of the box. The new architecture makes Prisma feel like a native JavaScript library, eliminating the binary overhead that slowed down previous versions.

• Electron 36: Upgraded browser engine and Node.js, Windows apps now have rounded corners that look native, code signing is built-in so Microsoft trusts your apps, and smooth animations without performance caps. The new ServiceWorkerMain API lets you control background workers from the main process, opening up new possibilities for desktop app architecture.

• Koa 3.0: A tiny web framework (under 3MB) from the Express team that handles caching, errors, and content negotiation automatically - perfect for building lightweight APIs. Unlike heavier frameworks, Koa gives you just what you need without bloat, making it ideal for microservices and serverless deployments.

• PGlite 0.3: Run a full PostgreSQL database in your browser (3MB size), works offline with IndexedDB storage, supports AI vector search, and ideal for testing or edge computing apps. Now upgraded to PostgreSQL 17.4, bringing all the latest database features to client-side applications without external dependencies.

And that's it for the thirty-third issue of "This Week in JavaScript", brought to you by jam.dev—the tool that makes it impossible for your team to send you bad bug reports.

Feel free to share this newsletter with a fellow developer, and make sure you're subscribed to get notified about the next issue.

Until next time, happy coding!

Welcome to a new edition of "This Week in JavaScript"!

This week, we’ve got a major release for creative coders, groundbreaking React experimental features, and reflections on a decade of SolidJS—plus exciting new tools you won't want to miss!

Can’t read the newsletter? Listen on the go!

P5.js 2.0: JavaScript Takes Art to the Next Level

P5.js, the beloved creative coding library, has reached version 2.0 with impressive upgrades for artists and developers alike!

Key Improvements:

Variable Fonts & Advanced Typography: Animate font weight, width, and slant with full variable font support. New utilities like textToContours() and faster textToPoints() (3.5x speed boost) make text manipulation smoother.

JavaScript Shaders (No GLSL Needed): Apply GPU-accelerated shaders directly in JavaScript to strokes, fills, and images using simple functions like strokeShader(). No GLSL knowledge required.

Expanded Color Spaces & HDR Canvases: Work with LAB, LCH, OKLab color spaces, and HDR outputs like Display P3—perfect for richer color workflows and modern displays.

Unified Pointer Events: Handle mouse, touch, and pen inputs with a single event system for seamless interactivity across devices.

Performance Boosts:

• Faster text rendering

• Efficient 3D line drawing with linesMode(SIMPLE)

• Asynchronous asset loading via async setup()

Modular & Modern:

• Full ES Module support

• Improved npm package with modern tooling

This update solidifies p5.js as the premier tool for anyone wanting to blend art with code. Whether you're a seasoned creative coder or a beginner looking to start, p5.js 2.0 offers an accessible entry point into generative art and interactive visualizations.

React Labs: View Transitions and Activity Component

React Compiler may have hit Release Candidate status, but that's not even the most exciting React news this week!

Some amazing updates in React:

View Transitions: A new experimental component that makes UI animations dramatically simpler

• Easily animate between page navigations, expanding elements, and UI state changes

• Leverages browser's native capabilities for better performance

• Available now in react@experimental

Activity Component: Revolutionary approach to UI state management

• Hide and show UI elements while intelligently preserving their state

• Perfect for tabbed interfaces, modals, and complex navigational flows

• Reduces performance costs compared to traditional unmounting

These features represent significant advancements in how React applications can handle animations and state management, making previously complex implementations straightforward.

A Decade of SolidJS: Reactive Revolution

SolidJS creator Ryan Carniato has shared thoughtful reflections on a decade of developing the project, four years after reaching version 1.0.

Key Highlights:

• Fine-grained reactivity goes mainstream: SolidJS pioneered a signal-based reactivity model that minimizes runtime overhead and maximizes performance. This model has reshaped frontend architecture and been adopted by major frameworks like Angular (Signals), Vue (Vapor), and Svelte (Runes).

• From niche to standard: What started as a side project inspired by Knockout.js evolved into a blueprint for how modern frameworks handle state updates efficiently—without the need for virtual DOM diffing.

• Industry-wide impact: The signal-based approach has become the de facto standard for reactive programming in frontend development, with SolidJS playing a key role in sparking this shift.

Carniato's persistence has transformed how front-end frameworks approach reactivity, demonstrating the long-term impact of innovative architectural thinking in JavaScript.

Tools & Releases You Should Know About

Let's speed-run through some of the other big tool updates this week!

• jsvu 3.0: Install modern JS engines without compilation headaches, now with improved Node.js v18+ compatibility and support for V8, SpiderMonkey, JavaScriptCore across major operating systems.

• SmallJS 1.6: Smalltalk-inspired library now with multi-provider AI support for OpenAI, Deepseek, Google AI, and Anthropic, featuring a new demo chat app and improved compiler performance.

• Scala.js 1.19.0: WebAssembly output now runs 15% faster than JavaScript for computation-heavy code, with native async/await support and compatibility with Firefox 131+ and Safari 18.4+ without flags.

• ESLint v9.25.1: Fixes directive detection in no-unused-expressions rule to support projects publishing code for both ES3 and ES5+ environments, along with other important bug fixes.

• Spectacle: Create React-powered presentations with JSX syntax, featuring live code demos, clickable elements, and polished visual effects for standout technical presentations.

And that's it for the thirty-second issue of "This Week in JavaScript", brought to you by jam.dev—the tool that makes it impossible for your team to send you bad bug reports.

Feel free to share this newsletter with a fellow developer, and make sure you're subscribed to get notified about the next issue.

Until next time, happy coding!

Welcome to a new edition of “This Week in JavaScript”!

Today, we're exploring OpenAI's groundbreaking new models, important TC39 decisions, and a new high-performance JavaScript engine—plus exciting tool updates you won't want to miss!

Can’t read the newsletter? Listen on the go!

GPT-4.1, o3 and o4-mini, and Codex CLI: OpenAI’s Smartest Developer Tools

Together, these models and tools mark a shift from passive code suggestions to active, tool-using AI assistants that understand codebases, generate clean diffs, analyze logs, and even operate within the terminal.

For JavaScript, full-stack, and backend developers, the implications are huge.

GPT-4.1: Smarter, more precise, and built for real codebases

GPT-4.1 introduces major upgrades that solve long-standing pain points in coding workflows:

• A 1 million token context window allows the model to work with entire codebases, multi-file apps, or full project documentation in a single go.

• On the SWE-bench benchmark, GPT-4.1 hits 54.6% accuracy—a jump from GPT-4’s 33%. That means it solves far more real-world engineering tasks out of the box.

• The model is trained for diff-style editing, which means instead of rewriting entire files, it returns clean, minimal code changes that can be reviewed or merged directly.

o3 and o4-mini: Agents that Think, Plan, and Act

The o-series models add a layer of intelligent behavior that goes beyond code generation.

These models can:

• Browse the web to fetch documentation or troubleshoot errors

• Analyze uploaded files, logs, or datasets using Python

• Understand screenshots and generate matching code or visuals

• Create and manipulate images using DALL·E—all within the same conversation

What makes them stand out is agentic behavior: the ability to reason through a problem, choose the right tools, and take action across multiple steps.

For development use cases, this means:

• Generating a custom Express backend with route logic and middleware

• Analyzing error logs from production and returning structured insights

• Translating hand-drawn wireframes into deployable front-end layouts

This level of coordination turns the models into powerful assistants across the full software workflow.

Codex CLI: AI Agent in the Terminal

Codex CLI is a lightweight coding agent that runs locally in the terminal and connects to the user’s file system. It uses GPT-4.1 or o3 to interact with files, execute commands, and edit code through natural language instructions.

Key capabilities include:

• Writing new features with natural prompts

• Searching and summarizing code across large projects

• Running scripts and interpreting outputs

• Generating tests, documentation, and config files with minimal input

Codex CLI is fully open-source, and OpenAI is supporting its growth with a $1 million fund for projects built on top of it.

Why This Matters

This launch moves AI tools from reactive helpers to active collaborators. Instead of suggesting code in isolation, the models now understand context, plan across multiple steps, and even execute tasks locally via Codex CLI.

The improvements in accuracy, reasoning, and usability make it possible to:

• Build faster

• Debug with fewer mistakes

• Create more consistent, production-ready outputs

For developers working in JavaScript, TypeScript, Python, or mixed stacks, this release offers a toolkit that integrates directly into existing workflows—and makes AI a far more practical part of daily development.

JavaScript Records and Tuples are Dead

At this month’s TC39 meeting, a major proposal was officially withdrawn: Records and Tuples, a long-running effort to bring deeply immutable data structures to JavaScript, has been shelved after several years of exploration.

But while one door closes, several new ones open.

Records and Tuples: Proposal Withdrawn After Stalling at Stage 2

The Records and Tuples proposal aimed to introduce new primitive types for immutable values using special syntax like #{ x: 1 } and #[1, 2, 3 ]. It promised value-based equality and structural sharing—features developers often reach for when modeling data.

But the core idea faced growing concerns:

• It introduced new primitive types to the language

• It required new syntax that many found awkward

• It posed challenges for developer tooling and interop

Despite years of refinement, the proposal failed to gain enough support to progress beyond Stage 2. As a result, it’s been withdrawn entirely.

The functionality it aimed to deliver may return in a different form through Composite Keys, which offer value-based equality using regular JavaScript objects.

Enums: TypeScript-Style Enums Enter Stage 1

A new Enum proposal has entered Stage 1, with the goal of bringing built-in enum support to JavaScript. The idea is to introduce a native enum syntax that aligns closely with TypeScript’s existing enum feature.

This could mean:

• Cleaner declaration of constant sets

• Better runtime compatibility with TypeScript enums

• Easier modeling of state machines, role types, or status codes

While the exact design is still evolving, the proposal advancing to Stage 1 signals serious interest in making enums part of the language natively.

Deferred Re-exports: More Efficient Module Loading

JavaScript modules may soon get a performance upgrade. The Deferred Re-exports proposal has reached Stage 2 and introduces the ability to selectively lazy-load re-exports.

This means developers could write:

export defer { heavyTool } from './expensive.js';

export { fastTool } from './light.js';

With this syntax, expensive.js will only load if heavyTool is actually imported. This opens the door to better tree-shaking, faster startup times, and smarter bundling strategies, especially in large libraries and frameworks.

Map Upsert: Cleaner and Faster Key Management

The Upsert proposal is nearing Stage 3 and would give developers a long-awaited method:

Map.prototype.getOrInsert

This pattern:

if (!map.has(key)) {

map.set(key, defaultValue);

}

return map.get(key);

Could become a single line:

map.getOrInsert(key, () => defaultValue);

It’s more concise, avoids repeated lookups, and mirrors behavior found in other languages like Python and Rust. Great for caches, counters, and any scenario where maps are used as dynamic stores.

Composite Keys: Value-Based Equality Without New Primitives

Stepping in as a spiritual successor to Records and Tuples, Composite Keys have now entered Stage 1. They offer a new way to create objects that behave like value types—meaning two objects with the same structure and values will be considered equal.

const one = Composite({ x: 1, y: 2 });

const two = Composite({ x: 1, y: 2 });

Composite.equal(one, two); // true

These can be used as Map or Set keys with value-based comparison, something that’s currently impossible with standard objects. If successful, this proposal could finally give JavaScript a clean and efficient way to model compound keys without resorting to stringification hacks.

What This Means for Developers

The withdrawal of Records and Tuples may seem like a setback, but the momentum around Enums, Upsert, Composites, and smarter module loading shows TC39 is still actively evolving JavaScript toward more ergonomic, high-performance patterns.

Many of these changes align closely with TypeScript workflows, making the future of JavaScript feel more familiar, more efficient, and more expressive.

Keep an eye on these proposals. If they hit Stage 3 or 4 in the coming months, they could soon land in browsers, Node, or your next bundler release.Battle-Tested Node.js Testing Playbook

Backend testing doesn’t have to be painful—and this GitHub repo proves it. Written like a no-fluff manual, it compiles over 50 hands-on strategies from real-world consulting work into one actionable playbook.

What’s inside:

• Reliable patterns for mocking, Dockerized databases, flaky queue simulations, and message brokers

• Test structures built around API routes and behavior-driven outcomes

• A showcase Node.js app with 40+ tests (yes, including the DB) that all run in under five seconds

If you're tired of flaky test suites and want a setup that runs fast and scales cleanly, this guide is gold.

Hako: A High-Performance JavaScript Engine in a 800KB Box

Hako is a new JavaScript engine focused on portability, performance, and security. Forked from PrimJS (an optimized QuickJS), it’s designed for embedding into any application with minimal overhead and maximum control.

Key highlights:

• WebAssembly-first architecture: Hako compiles to WASM, making it platform-agnostic and embeddable in any environment that supports WebAssembly. No need for native builds or complex bindings.

• Built-in sandboxing and resource control: Runs securely within a WASM sandbox, with support for memory limits, execution quotas, and fail-fast controls to prevent abuse or denial-of-service scenarios.

• Compact and fast: Weighs in at just ~800KB, starts quickly, and supports spinning up hundreds of lightweight VM instances. Ideal for plugins, serverless functions, and edge runtimes.

• 28% faster than QuickJS: Thanks to an improved interpreter and true garbage collection, Hako outperforms QuickJS in key benchmarks while retaining similar language coverage.

• Modern JavaScript support: Supports ES2019+ features like modules, async/await, generators, BigInt, and more. Runs most modern JS code without issues.

• Built-in debugging tools: Offers Chrome DevTools Protocol (CDP) support, allowing remote debugging via Chrome or VS Code. Rare among lightweight JS engines.

Hako is best suited for developers building plugin systems, secure code sandboxes, lightweight REPLs, or cross-platform applications where running modern JS safely and efficiently is essential, and is faster than QuickJS, safer than Duktape, far lighter than V8, and more portable than Hermes.

Tools & Releases You Should Know About

Let's speed-run through some of the other big tool updates this week!

• Astro 5.7: Introduces an experimental Fonts API supporting Google, Fontsource, and local files, plus a now-stable Sessions API for server-side data storage without cookies. SVG files can now be used directly as components.

• WebStorm 2025.1: JetBrains' first major release of the year brings Claude model support to their AI Assistant, local model connections through Ollama, and improved Angular 17.2 signal query support.

• tldts 7.0: This URL parsing utility now processes domains in microseconds with full Unicode compatibility, while adding email parsing and IPv6 detection.

• Redux Toolkit 2.7: Adds Standard Schema validation support for RTK Query endpoints and fixes several bugs with infinite queries.

• Babylon.js 8.3: Graphics improvements include native copy texture protocol and new post-processes like FXAA and film grain.

• Bun v1.2.10: A mind-blowing performance boost for setImmediate (74 seconds → 4 milliseconds) makes Next.js builds 10% faster on macOS.

And that's it for the thirty-first issue of "This Week in JavaScript", brought to you by jam.dev—the tool that makes it impossible for your team to send you bad bug reports.

Feel free to share this newsletter with a fellow developer, and make sure you're subscribed to get notified about the next issue.

Until next time, happy coding!

Welcome to a new edition of “This Week in JavaScript”!

From Google's ambitious new AI workspace to Microsoft clamping down on VS Code forks, plus serious upgrades to JavaScript itself, there's a lot to unpack.

Can’t read the newsletter? Listen on the go!

JavaScript in 2025: New Features You Should Know

JavaScript in 2025 is more powerful, expressive, and efficient than ever.

Here’s what’s worth learning:

• Iterator Helpers give you map, filter, and flatMap on iterables—great for transforming large streams or datasets efficiently

• structuredClone offers native deep-copying for objects with circular references or complex types

• Promise.withResolvers lets you create externally controlled promises, making async flow less clunky

• Array .at(-1) makes grabbing the last element easier and cleaner

• Set operations now support union, intersection, and difference natively—no more third-party libs

• Tagged Templates let you intercept and manipulate strings dynamically, useful for sanitization or internationalization

If you're still relying on old patterns, now’s the time to upgrade.

Google Launches Firebase Studio

Google is coming in hot with Firebase Studio—a fully AI-powered dev environment that runs entirely in the browser. Gemini is baked in from the start, helping with debugging, testing, documentation, and refactoring.

Highlights:

• Import projects from GitHub, GitLab, Bitbucket, or local machines

• Prototyping agents convert sketches and plain English into runnable code

• Real-time previews, Android emulators, and one-click deploys to Firebase or Cloud Run

Think of it as Google’s answer to Cursor or v0, but natively integrated into the Firebase ecosystem.

Battle-Tested Node.js Testing Playbook

Backend testing doesn’t have to be painful—and this GitHub repo proves it. Written like a no-fluff manual, it compiles over 50 hands-on strategies from real-world consulting work into one actionable playbook.

What’s inside:

• Reliable patterns for mocking, Dockerized databases, flaky queue simulations, and message brokers

• Test structures built around API routes and behavior-driven outcomes

• A showcase Node.js app with 40+ tests (yes, including the DB) that all run in under five seconds

If you're tired of flaky test suites and want a setup that runs fast and scales cleanly, this guide is gold.

Microsoft's Lockdown on VS Code Forks

Microsoft quietly enforced licensing restrictions on popular language extensions (C++, Python, .NET), blocking their use in editors like Cursor and Windsurf.

What’s changing:

• Extensions are now restricted to official environments (VS Code, Visual Studio, Azure DevOps)

• Cursor is pivoting to Open VSX and OSS alternatives

• Comes amid Microsoft’s expansion of Agent Mode and MCP in VS Code

The developer ecosystem is splintering. This move might redefine the editor landscape in the age of AI-first tooling.

Tools & Releases You Should Know About

Let's speed-run through some of the other big tool updates this week!

• TypeSpec 1.0-RC: Design your API once, and TypeSpec generates OpenAPI specs, JSON Schema, server code, and client libraries across languages. It's a language for API contracts, letting you build API-first with less drift, more consistency, and scalable architecture baked in from day one.

• Prisma ORM 6.6: Adds ESM support via a new client generator, Early Access migrations for Cloudflare D1 and Turso, and a new MCP server that connects to AI tools. Developers can now spin up Postgres workflows via AI prompts like "make a DB for a habit tracker."

• React Native 0.79: Boosts Android startup by avoiding JS bundle compression and brings major Metro bundler improvements. Swift-native module registration on iOS is now possible, and Remote JS Debugging has officially been removed for good.

• Tailwind CSS 4.1: Text-shadow utilities finally arrive, along with powerful new masking features, pointer-aware variants, and legacy browser fallbacks. The update makes layouts more expressive while improving accessibility and responsiveness across devices.

• Next.js 15.3: Turbopack enters alpha for production builds, offering up to 83% faster performance. Adds new routing hooks, instrumentation APIs, and support for Rspack as a community bundler, pushing forward Next.js as the go-to meta-framework.

And that's it for the thirtieth issue of "This Week in JavaScript", brought to you by jam.dev—the tool that makes it impossible for your team to send you bad bug reports.

Feel free to share this newsletter with a fellow developer, and make sure you're subscribed to get notified about the next issue.

Until next time, happy coding!

Welcome to this week's edition of "This Week in JavaScript"!

Today, we're covering React's powerful new debugging tools, a revolutionary JavaScript runtime, the legal battle for the JavaScript name, and Safari's most impressive update yet—plus exciting new tools you won't want to miss!

Can’t read the newsletter? Listen on the go!

React 19.1: Debug Smarter, Render Smoother

React 19.1 is here with some powerful dev-focused additions and performance polish.

• Owner Stacks: A dev-only tool to trace which components rendered what. It gives you more visibility than Component Stacks and is super useful for debugging complex trees.

• Suspense Upgrades: Boundaries now play nicer across the client, server, and hydration stages—plus better GC handling and fewer unnecessary renders.

• React Server Components: A new experimental unstable_prerender API plus streaming support in edge environments.

• React DOM Fixes: Toggle events, better image preloading, and weird DOM edge cases got cleaned up too.

React 19.1 isn’t flashy—but it’s smooth, powerful, and developer-first.

Bare: A Minimalist Runtime for Max Flexibility

Think Node.js, but leaner. Bare is a new JavaScript runtime built on V8 and libuv, but without a standard library. You assemble your own runtime from modular userland packages.

Highlights:

• Full ESM + CommonJS support

• Native addon and multithreaded mobile support

• Works with multiple JS engines (V8, QuickJS, JavaScriptCore)

• Built for mobile, embedded, peer-to-peer, and experimental environments

If you're tired of bloated runtimes or want complete control over your runtime stack, Bare might be what you’re looking for.

Deno vs Oracle: The Battle for "JavaScript"

Yes, Oracle still owns the trademark for “JavaScript.” And no, they haven’t built or maintained it in years.

Here’s what’s happening:

• Deno filed a petition to cancel the trademark, arguing the term is now generic and that Oracle hasn’t used it in commerce.

• Oracle responded... by submitting a Node.js screenshot (which they don’t own) as proof of use.

• The next few weeks are key. If the fraud claim is allowed, Oracle may have to explain that submission.

The outcome could impact how we use the word “JavaScript” publicly—whether in conferences, products, or dev tools. Deno’s pushing to #FreeJavaScript, and the industry is watching closely.

Safari 18.4: WebKit Gets Wild

This might be Safari’s most packed update ever. Here’s the highlight:

• Declarative Web Push: Notifications without Service Workers. It’s simpler, faster, and more battery-friendly.

• Iterator Helpers: map, filter, some, reduce, and more are now native in JS.

• Faster JSON Parsing: Thanks to SIMD, JSON.parse and stringify just got snappier.

• Error.isError: Better native error detection.

• CSS Goodies: shape(), text-autospace, sideways writing modes, scroll-linked animations for <details>, and responsive design tools.

• Media & Web APIs: WebM, Opus, AV1, WASM JIT fallback, and CHIPS for cookie partitioning.

• Also, Web Extensions get a massive update, and WebKit's dev tools just got a lot more capable across iOS, macOS, and visionOS.

Tools & Releases You Should Know About

Let's speed-run through some of the other big tool updates this week!

• Express v5.1: JavaScript's classic server framework is back as the default on npm after years of modernization. It brings a migration codemod from v4, updated docs, a clear LTS strategy, and support for Uint8Array in res.send(). This is Express's biggest refresh in over a decade.

• React Email 4.0: Your email's new personal assistant with a built-in linter for links and images, SpamAssassin-powered spam scoring, and compatibility checking across email clients. With responsive previews and eight new components, building marketing-ready emails with React just got dramatically easier.

• zx 8.5: Now fully modular with a lightweight @lite version that's 7x smaller. Available everywhere—npm, GitHub, Docker, and JSR—with support for fetch().pipe(), enhanced globbing, better CLI flags, and cleaner stack traces. Perfect for scripting across Deno, Docker, or Node environments.

• Anime.js 4.0: Transform your browser into a motion design playground with this all-in-one animation engine. Now supports scroll observers, shape morphing, draggable elements, and timeline orchestration through a clean API. Perfect for animating anything from DOM elements to SVGs with buttery smooth performance.

• TinyBase 6.0: Future-proofs your stack by going fully ESM-only and dropping CommonJS and UMD. Adds support for React 19, modernizes testing, and updates demos to use import maps and esm.sh. The CLI is gone, but the core is leaner and more aligned with where frontend development is heading.

And that's it for the twenty-ninth issue of "This Week in JavaScript", brought to you by jam.dev—the tool that makes it impossible for your team to send you bad bug reports.

Feel free to share this newsletter with a fellow developer, and make sure you're subscribed to get notified about the next issue.

Until next time, happy coding!

Welcome to a new edition of "This Week in JavaScript"!

Today, we're covering a critical Next.js security patch you can't afford to miss, OpenAI's revolutionary 4o Image Generation, and Vue.js's impressive growth stats—plus exciting new tools that'll supercharge your development workflow!

Can’t read the newsletter? Listen on the go!

Next.js Middleware Security Vulnerability

Next.js just patched a critical vulnerability (CVE-2025-29927) affecting all self-hosted applications with output: 'standalone'.

Why It Matters:

• Authentication Bypass: Attackers could completely skip middleware-based authorization checks

• All Versions Affected: Every major version prior to the patches requires updates

• Simple Exploit: Using a spoofed header allows bypassing all security middleware

If you're running a self-hosted Next.js app, update immediately to the patched versions:

• 15.x: fixed in 15.2.3

• 14.x: fixed in 14.2.25

• 13.x: fixed in 13.5.9

• 12.x: fixed in 12.3.5

OpenAI's 4o Image Generation

OpenAI has integrated their most advanced image generator directly into the GPT-4o language model. However, as of now, this feature is not publicly available through the API but is expected to be rolled out gradually in the near future.

Key Features:

• Native Integration: Built directly into the language model, not a separate tool

• Text Rendering: Perfect for creating diagrams, charts, and text-heavy visuals

• Multi-turn Refinement: Natural conversation to improve images incrementally

• Knowledge-Backed Generation: Leverages the model's understanding for accurate visuals

This isn't just about pretty pictures—it's about creating useful visuals that communicate meaning effectively through simple conversation.

Use Cases in JavaScript & Web Development:

• AI-Generated Assets in Web Apps: React/Vue-based UIs can dynamically generate images based on user input.

• Game Development & WebGL: AI-powered textures and procedural assets for Three.js, Babylon.js, and PlayCanvas.

• Generative Art & Design: AI-assisted image manipulation in p5.js or Processing.js.

• AI-Powered E-commerce & Marketing: Dynamic product visuals and personalized ads.

• Automated Data Visualization: AI-generated infographics and reports in D3.js or Chart.js.

• Web-Based Image Editing Tools: AI-enhanced photo editing and filters using the Canvas API & TensorFlow.js.

• Interactive Learning Platforms: AI-created diagrams and illustrations for educational web apps.

State of Vue.js Report 2025

The latest Vue.js report shows impressive growth and ecosystem shifts that every frontend developer should know about.

Striking Statistics:

• 93.4% Developer Loyalty: Up from 90% in 2021 planning to use Vue for their next project

• 80% Pinia Dominance: The state management landscape has completely transformed

• 38.4% Vuex Usage: The former champion has seen a dramatic decline

• TypeScript Explosion: Usage surged from 38% (third place) to 82% (first place)

This dramatic shift shows Vue's continued momentum and the JavaScript community's growing embrace of type safety.

Tools & Releases You Should Know About

Let's speed-run through some of the other big tool updates this week!

• Bun v1.2.7: Introduces a new CookieMap API for simplified cookie handling, improved TypeScript declarations removing Node.js/DOM conflicts, and includes 35 bug fixes improving stability and compatibility.

• pnpm 10.7: Now lets you patch dependencies by version ranges for granular control, adds environment variables support in workspace config, and enhances configuration visibility across workspace files.

• Babel 7.27.0: Brings default support for correct import attributes syntax, better alignment with standard JavaScript and tooling, and improved TypeScript preset behavior.

• Babylon.js 8.0: Delivers Image-Based Lighting shadows for realistic rendering, Area Lights for movie-set style lighting effects, a Node Render Graph for complete pipeline customization, and a Lightweight Viewer for minimal 3D embedding.

• Lexical 0.29: Meta's extensible text editor framework featuring accessible, cross-platform design (web and iOS) and a minimalist approach with plugin-based expansion.

And that's it for the twenty-eighth issue of "This Week in JavaScript", brought to you by jam.dev—the tool that makes it impossible for your team to send you bad bug reports.

Feel free to share this newsletter with a fellow developer, and make sure you're subscribed to get notified about the next issue.

Until next time, happy coding!

Welcome to a new edition of "This Week in JavaScript"!

Today, we're covering OpenAI's controversial pricing model, the heated Next.js vs TanStack debate, and game-changing tool releases- plus optimization techniques you won't want to miss!

Can’t read the newsletter? Listen on the go!

Next.js vs TanStack: The Framework Showdown

Kyle Gill recently shared why he's abandoning Next.js for TanStack, and many developers are following suit.

Why Developers Are Switching:

• Simplicity vs. Complexity: Next.js offers high-scale optimization but with a steeper learning curve

• Practical Abstractions: TanStack provides cleaner APIs that feel more intuitive

• Framework Fatigue: Do you really need SSR, ISR, PPR, and other acronyms for most projects?

• Development Experience: TanStack paired with Vite delivers faster compile times

The tradeoff? You lose some of Next.js's built-in performance optimizations, but gain code that's easier to reason about.

Rsdoctor 1.0: Build Analysis Reimagined

Rsdoctor 1.0 has officially launched, revolutionizing build analysis for Rspack and Webpack users.

Standout Features:

• Full Transparency: Visualize your entire build process with detailed breakdowns

• Deep Inspection: See exactly what each loader is doing to your files

• Performance Boost: New Rust integration makes analysis up to 20% faster

• Smart Scanning: Automatically detect duplicate packages and compatibility issues

If you've ever been frustrated by webpack slowdowns or mysterious build issues, this tool is your new best friend.

OpenAI's o1 Pro: Powerful But Pricey

OpenAI's o1 Pro model is making waves in the JavaScript community, but at what cost?

Key Points:

• Astronomical Pricing: 136 times more expensive than other AI options

• Problem-Solving Beast: Can tackle complex coding challenges that stump other models

• User Experience Issues: Random failures and UI quirks plague the experience

• Better Alternatives: For most everyday tasks, the cheaper o3 mini delivers superior results

Is the hefty price tag justified? For most developers, probably not – unless you're tackling those one-in-a-million programming puzzles.

CKEditor Case Study: Lightning-Fast Loading

The team behind CKEditor shares how they achieved remarkable performance improvements:

How They Did It:

• 80-95% Faster: Loading times reduced dramatically without major architecture changes

• Smart Optimization: Improved model-view conversion process eliminated redundant operations

• Large Document Handling: Specialized approach for content with excessive formatting

For anyone working with rich text editors, their methodology offers valuable lessons in optimization.

Tools & Releases You Should Know About

Let's speed-run through some of the other big tool updates this week!

• Parcel v2.14.0: Beta support for React Server Components, new CLI for scaffolding projects, native HTML import maps for better browser caching, and first-class MDX support built in Rust. Includes an automated migration script for Create React App users.

• Ionic 8.5: Enhanced form controls with helper text and error messaging, new expandToScroll property for sheet modals, full React 19 support, and improved RTL language handling for seamless cross-platform development.

• React Router 7.4: Refined routing with better type generation for server builds, improved loader behavior, and a more robust middleware system with cleaner error handling and better context typing.

• Reveal.js 5.2: Upgraded presentation experience with a new lightbox feature for images and videos. Continues to be the go-to choice for developers who want to create stunning slides using web technologies.

• PeanoScript: Brings formal verification to TypeScript syntax, allowing mathematical proof of code correctness. A fascinating bridge between programming and mathematical logic, perfect for critical applications where correctness is non-negotiable.

And that's it for the twenty-seventh issue of "This Week in JavaScript", brought to you by jam.dev—the tool that makes it impossible for your team to send you bad bug reports.

Feel free to share this newsletter with a fellow developer, and make sure you're subscribed to get notified about the next issue.

Until next time, happy coding!