TypeScript Surpasses Python and JavaScript to Become GitHub's Most Popular Language

Hello HaWkers, a historic shift in the programming world that few predicted has occurred: TypeScript has surpassed both Python and JavaScript to become the most used language on GitHub. This is the first time in over a decade that we've seen such a significant change in the language ranking.

The GitHub Octoverse 2025 report, published in October, revealed that TypeScript reached 2,636,006 monthly contributors, surpassing Python by approximately 42,000 developers. What's behind this meteoric rise?

The Impressive Numbers

TypeScript's growth in 2025 was extraordinary, breaking records for programming language adoption.

GitHub Octoverse 2025 Statistics:

TypeScript: 2,636,006 monthly contributors (+66% YoY)
Python: 2,594,000 monthly contributors (+48% YoY)
JavaScript: 2,135,000 monthly contributors (+25% YoY)

Growth in absolute numbers:

TypeScript gained over 1 million new developers in one year
Python added 850,000 contributors
JavaScript grew by 427,000 contributors

Most impressive is that TypeScript achieved this position starting from a much smaller base. Just 5 years ago, TypeScript was in 7th place in the ranking.

Why TypeScript Exploded in 2025

TypeScript's rise is no coincidence. Several factors converged to create perfect conditions for this adoption explosion.

1. The AI Era Favors Static Typing

The most surprising factor behind TypeScript's growth is artificial intelligence. A 2025 academic study revealed an impressive finding: 94% of compilation errors in LLM-generated code are type-check failures.

This means that statically typed languages like TypeScript make AI-generated code much more reliable. When Copilot or another AI assistant generates TypeScript code, the compiler immediately identifies type errors, allowing instant corrections.

// AI-generated code in plain JavaScript
// Error only appears at runtime
function calculateDiscount(price, percentage) {
  return price - price * percentage;
}

calculateDiscount('100', 0.1); // Silent bug: returns "100" - NaN

// Same code in TypeScript
// Error detected immediately by the compiler
function calculateDiscount(price: number, percentage: number): number {
  return price - price * percentage;
}

calculateDiscount('100', 0.1); // ERROR: Argument of type 'string' is not assignable

2. Modern Frameworks Adopted TypeScript as Default

Virtually every modern frontend framework now generates projects in TypeScript by default.

Frameworks using TypeScript as default:

Next.js 15
Astro 3
SvelteKit 2
Qwik
SolidStart
Angular 18
Remix
Nuxt 3

When a developer runs npx create-next-app@latest, the project already comes configured with TypeScript. This eliminated the configuration friction that previously drove many developers away.

3. GitHub Copilot and Productivity

The Octoverse report revealed another fascinating finding: 80% of new developers on GitHub use Copilot in their first week.

This creates a virtuous cycle for TypeScript:

// The TypeScript + Copilot cycle

// 1. Developer writes type
interface User {
  id: number;
  name: string;
  email: string;
  createdAt: Date;
}

// 2. Copilot suggests code based on types
function createUser(data: Omit<User, 'id' | 'createdAt'>): User {
  return {
    id: Math.random(),
    createdAt: new Date(),
    ...data,
  };
}

// 3. Autocomplete shows exactly what's expected
const newUser = createUser({
  name: 'John', // Copilot knows it needs name and email
  email: 'john@email.com',
});

Static typing provides additional context for Copilot, resulting in more accurate suggestions and more reliable code.

4. Ecosystem Maturity

TypeScript has reached a level of maturity that eliminates most historical objections.

TypeScript Evolution:

Version	Important Feature
4.0	Variadic Tuple Types
4.1	Template Literal Types
4.5	Awaited Type
5.0	Decorators (ES Stage 3)
5.2	using Declarations
5.3	Import Attributes
5.4	Object.groupBy Types
5.5	Isolated Declarations

The type ecosystem has also matured. Libraries like Zod, tRPC, and Prisma demonstrate the power of end-to-end typing.

What This Means for Developers

If you're not using TypeScript yet, this is a crucial moment to rethink your career strategy.

Job Market

The market already reflects this shift. Jobs requiring TypeScript are on the rise:

TypeScript demand in jobs (2025):

Frontend: 78% of jobs mention TypeScript
Backend Node.js: 65% require TypeScript
Full Stack: 82% prefer candidates with TypeScript
Startups: 91% use TypeScript as default

Migrating from JavaScript to TypeScript

If you work with JavaScript, migration can be gradual:

// Step 1: Add TypeScript to the project
// npm install --save-dev typescript @types/node

// Step 2: Create tsconfig.json with permissive configuration
{
  "compilerOptions": {
    "allowJs": true,
    "checkJs": false,
    "strict": false,
    "noEmit": true,
    "esModuleInterop": true
  },
  "include": ["src/**/*"]
}

// Step 3: Gradually rename .js files to .ts
// Start with the simplest files

// Step 4: Add types progressively
// Before (JavaScript)
function processData(data) {
  return data.map(item => item.value * 2);
}

// After (basic TypeScript)
interface Item {
  value: number;
}

function processData(data: Item[]): number[] {
  return data.map(item => item.value * 2);
}

Essential TypeScript Concepts to Get Started

If you're starting with TypeScript, here are the fundamental concepts you need to master.

Basic Types

// Primitive types
let name: string = 'John';
let age: number = 25;
let active: boolean = true;
let nullable: null = null;
let undef: undefined = undefined;

// Arrays
let numbers: number[] = [1, 2, 3];
let names: Array<string> = ['Anna', 'John'];

// Objects
let user: { name: string; age: number } = {
  name: 'Maria',
  age: 30,
};

// Union Types
let id: string | number = 'abc123';
id = 123; // Also valid

Interfaces and Types

// Interface - ideal for objects
interface User {
  id: number;
  name: string;
  email: string;
  avatar?: string; // Optional property
}

// Type alias - more flexible
type Status = 'active' | 'inactive' | 'pending';
type Callback = (error: Error | null, result?: string) => void;

// Extending interfaces
interface Admin extends User {
  permissions: string[];
  level: number;
}

// Composition with types
type UserWithStatus = User & { status: Status };

Generics

// Generic function
function first<T>(array: T[]): T | undefined {
  return array[0];
}

const firstNumber = first([1, 2, 3]); // type: number
const firstName = first(['Anna', 'John']); // type: string

// Generic interface
interface Response<T> {
  data: T;
  success: boolean;
  message: string;
}

// Usage with specific types
const userResponse: Response<User> = {
  data: { id: 1, name: 'John', email: 'john@email.com' },
  success: true,
  message: 'User found',
};

The Future of TypeScript

Anders Hejlsberg, TypeScript's lead architect, shared his vision for the language's future in a recent interview.

Expected trends:

Better type inference: The compiler will become even smarter
Performance: Focus on faster compilation
AI Integration: Types optimized for code generation
Simplicity: Reducing complexity for common cases

TypeScript and the Future of the Web

The combination of TypeScript with emerging technologies is creating new possibilities:

// TypeScript with Server Components (React 19+)
async function UserData({ id }: { id: string }) {
  const user = await fetchUser(id);

  return (
    <div>
      <h1>{user.name}</h1>
      <p>{user.email}</p>
    </div>
  );
}

// TypeScript with Edge Functions
export default async function handler(
  request: Request,
  context: { geo: { city: string; country: string } }
) {
  const { city, country } = context.geo;

  return Response.json({
    message: `Hello from ${city}, ${country}!`,
  });
}

Conclusion

TypeScript's rise to the top of the GitHub ranking is not just a statistical curiosity. It's a clear signal of where the industry is heading. The combination of static typing with the AI era has created perfect conditions for TypeScript to thrive.

What you should do now:

If you still use plain JavaScript, start learning TypeScript
Configure your existing project to accept .ts files
Migrate gradually, file by file
Take advantage of Copilot and other AI tools with TypeScript
Explore type-safe libraries like Zod, tRPC, and Prisma

If you want to dive deeper into modern JavaScript and TypeScript, I recommend checking out another article: ECMAScript 2025: New JavaScript Features where you will discover the new features that arrived in the language this year.