TS 6.0 Released: Key Changes and Migration Plan

TypeScript 6.0 shipped March 23, 2026. It's the last version of the TypeScript compiler written in TypeScript. Everything after it — TypeScript 7.0 — is rebuilt in Go. 🐳 The numbers: → VS Code (1.5M lines): 77 seconds → 7.5 seconds → Sentry codebase: 133 seconds → 16 seconds → Memory usage: cut in half That's not a small improvement. That's a different category of tool. But first — TypeScript 6.0 is the bridge release you need to get through. Here's what changed: 🔧 9 new defaults: strict ON, ESM as default, bundler module resolution, all files treated as modules ❌ Breaking changes: ES5 target removed, AMD/UMD deprecated, --outFile gone, @types no longer auto-discovered ✅ New features: - Temporal API types (proper date handling, finally) - RegExp.escape() and Promise.try() types - Map.getOrInsert() typed correctly - #/ subpath imports - Improved method type inference 💡 The Go compiler (tsgo) is already available: npm install @typescript/tsgo tsgo --project tsconfig.json Try it. The compile time difference is immediate and shocking. I wrote the full guide for what changed, what broke, how to upgrade, and what TypeScript 7.0 actually means for your CI/CD and monorepo workflows. Is your team already planning the 6.0 upgrade? 👇 #TypeScript #JavaScript #WebDev #Frontend #NodeJS #100DaysOfBlogging

The Oxc Angular Compiler: up to 20x faster Angular builds. We re-built the Angular compiler on top of Oxc, the Rust-based JavaScript Compiler that also powers Rolldown and Vite 8+. → 6.4x faster than Angular CLI on Super Productivity → 20.7x faster than Webpack + @ngtools/webpack on Bitwarden Coming with a first-class Vite plugin with full HMR and a programmatic API. We implemented the template compiler natively in Rust instead of driving compilation through TypeScript's semantic checker. That's where the speed comes from. We built the compiler in just 2 months with the help of Claude Code and Codex, but this is not just another slop fork. Nevertheless, the Oxc Angular Compiler was an experiment. We skipped cross-file optimizations and template type-checking and not plan to maintain it beyond its current state. The good news: the Angular team is already looking into integrating Oxc as well. Read the full write-up https://lnkd.in/gaWhMEJM

Every framework deserves fast tooling. As an experiment, Yinan Long rebuilt the Angular compiler in Rust on top of Oxc 👀 The results are amazing, but see for yourself!

TypeScript 6.0 is officially here, and it's the end of an era. 🚀 This is the final major release built on the JavaScript compiler. Starting with TS 7.0 (Project Corsa), the compiler is rewritten in Go for native multi-threaded speeds. But TS 6.0 isn’t just a bridge release. Microsoft just aggressively changed the default behaviors and added native support for ES2025. A few major changes you need to know before migrating: 🚨 strict: true is now the default for all new projects. 🗑️ target: ES5 and UMD/AMD are deprecated (IE is officially buried). ⚡ Native typings for Map.getOrInsert and RegExp.escape. 🧩 Perfect support for Node # subpath imports. I’ve broken down the architecture changes and the Before/After syntax in this technical carousel. Swipe through to see how your codebase will change. 👇 Are you already clearing out your tech debt to prepare for TS 7.0? #typescript #javascript #webdevelopment #frontend #softwareengineering #nodejs #reactjs #nestjs

Do you actually know what version you're installing? Most developers write ^, ~, or just a number in package.json without thinking twice — but they behave very differently. Here's a quick breakdown: ^ (Caret) — ^4.19.1 Allows minor + patch updates. Stays on major version 4. Range: ≥4.19.1 <5.0.0 ~ (Tilde) — ~4.18.7 Allows patch updates only. Minor version locked to 18. Range: ≥4.18.7 <4.19.0 Exact — 4.12.4 Pins to this exact version. No updates ever. Range: = 4.12.4 only ✅ Use ^ when you trust the library follows semver and want latest features. 🔒 Use ~ when you want stability but still need bug fixes. 📌 Use exact version when you need 100% reproducibility — CI/CD pipelines, production lockdowns. Pro tip: Always commit your package-lock.json or yarn.lock. The ranges in package.json are intentions — the lock file is what actually gets installed. Which one do you use most? Drop a comment 👇 #javascript #nodejs #npm #webdevelopment #softwareengineering #100daysofcode #devtips

🧵 "Node.js is single threaded" everyone says that. But this is only half of the truth. Yes, Node.js is single threaded in its main execution the Event Loop and your code run on one thread. But using many other things, we can make it behave like a multiprocess or multithreaded system that performs perfectly even for CPU intensive tasks: 1-libuv (the underlying engine) It is the underlying C++ library in Node. Through it we can handle: A)Network I/Os : by dealing with the OS kernel directly So the kernel handles it asynchronously and notifies Node when done, so the main thread never blocks. B)File I/Os and DNS operations : through a thread pool that abstracts our main thread from that heavy load. 2-Event Loop Partitioning: But if the load is heavier than we thought, we need to handle it differently. -We can do partitioning making heavy operations done in multiple phases of the Event Loop so we don't starve any phase. -Using setImmediate(), I can distribute my work across different check phase iterations, so other phases keep running alongside the heavy operation without being starved. 3-Worker Threads & Child Processes Okay but what if the task is even heavier CPU intensive work? -Then we have Node Workers I can make my main thread do some work and offload intensive CPU tasks to other threads. (Yes, other threads just like a multithreading system.) Or we can even use Child Processes to offload work onto entirely different processes, each with their own memory and dedicated everything. So now we get it Node.js is single threaded in its code execution, but we can still make it behave like any concurrent parallel system.  It's not a limitation. It's a deliberate design choice. #nodejs #backend #javascript #SoftwareEngineering

TypeScript 6.0 and CSS Side-Effect Imports: What Changed and How to Fix It TypeScript 6.0 enables noUncheckedSideEffectImports by default, which causes a TS2882 error for CSS side-effect imports like import './style.css'. Here is what changed, why, and how to fix it. https://lnkd.in/dRbGrPHG

I noticed most Node.js logging solutions are either too heavy or too minimal. So I built my own — logpaint 🎨 A lightweight, zero-dependency colored logger with built-in levels and TypeScript support. Instead of adding another heavy logging library, I wanted something: • Minimal • Zero config • Typed • Colorful output • Runtime level switching 💻 Website - https://lnkd.in/gp3HgeBX 🔴 NPM - https://lnkd.in/gNuSPXd4 ♐ GitHub - https://lnkd.in/gVXkyu-P Would love feedback from fellow developers 🙌 What feature should I add next? #opensource #nodejs #typescript #javascript #buildinpublic #developers #webdev #programming

Understanding the Node.js Event Loop — The Heart of Non-Blocking I/O If you've ever wondered how Node.js handles thousands of concurrent requests with a single thread, the answer lies in the Event Loop. Here's a simplified breakdown: Node.js is Single-Threaded Unlike traditional servers that spawn a new thread per request, Node.js uses a single thread powered by the V8 engine and libuv. How the Event Loop Works: 1. Call Stack — Executes synchronous code first. 2. Node APIs — Async tasks (like setTimeout, fs.readFile) are offloaded here. 3. Callback Queue — Once async tasks complete, their callbacks wait here. 4. Event Loop — Continuously checks: 'Is the Call Stack empty?' If yes, it pushes callbacks from the queue to the stack. Phases of the Event Loop: -> timers (setTimeout / setInterval) -> pending callbacks -> idle / prepare -> poll (fetch new I/O events) -> check (setImmediate) -> close callbacks Microtasks (Promise.then, process.nextTick) have higher priority and run between each phase! Key Takeaway: Node.js achieves high performance not by doing things faster, but by never blocking while waiting. It delegates I/O to the OS and moves on. Understanding the Event Loop is fundamental to: ✅ Writing non-blocking code ✅ Avoiding callback hell ✅ Debugging performance bottlenecks ✅ Mastering async/await patterns Drop a comment if you found this helpful or have questions! #NodeJS #JavaScript #EventLoop #WebDevelopment #BackendDevelopment #Programming #SoftwareEngineering #TechLearning

𝗧𝘆𝗽𝗲𝗦𝗰𝗿𝗶𝗽𝘁 𝟳 is not about new features. It is about making TypeScript faster. Before, the TypeScript compiler worked on Node.js. Node.js is single-threaded, so it cannot use all CPU cores. Because of this, large projects can feel slow. Builds take more time, and sometimes the editor becomes slow too. Now, TypeScript 7 is being rewritten in Go programming language. This makes it a native tool, not just a JavaScript program. Because of that: 𝗶𝘁 𝗰𝗮𝗻 𝘂𝘀𝗲 𝗺𝘂𝗹𝘁𝗶𝗽𝗹𝗲 𝗖𝗣𝗨 𝗰𝗼𝗿𝗲𝘀 𝗶𝘁 𝘄𝗼𝗿𝗸𝘀 𝗳𝗮𝘀𝘁𝗲𝗿 𝗶𝘁 𝘂𝘀𝗲𝘀 𝗺𝗲𝗺𝗼𝗿𝘆 𝗯𝗲𝘁𝘁𝗲𝗿 In real projects, this means: faster build time faster autocomplete and navigation better performance in big projects and monorepos 𝗜𝗺𝗽𝗼𝗿𝘁𝗮𝗻𝘁: nothing changes in your code. You write the same TypeScript as before. This is not a new language. It is a faster engine. #TypeScript #FrontendEngineering #JavaScript #SoftwareEngineering #DX