Jeff Bruchado
Back to blog

TypeScript Surpasses Python to Become the Most Used Language on GitHub in 2025

Hello HaWkers, August 2025 marked a historic moment in programming. For the first time in a decade, JavaScript (and its typed extension) not only remained relevant, but TypeScript surpassed Python to become the language with the most active contributors on GitHub.

This is a milestone that reflects deep transformations in how we develop software. Let's understand what led to this change.

What the Data Shows

GitHub's Octoverse report revealed that in August 2025, TypeScript surpassed Python by approximately 42 thousand active contributors. This ends a sequence where Python had taken the lead in 2024, interrupting 10 years of JavaScript dominance.

Ranking Numbers

Top languages by contributors (August 2025):

Position Language Contributors Change
1 TypeScript ~2.8M +15%
2 Python ~2.75M +8%
3 JavaScript ~2.1M -5%
4 Java ~1.5M +2%
5 C# ~1.1M +7%
6 Go ~950K +12%
7 Rust ~750K +25%

Historical Context

Ranking evolution (2015-2025):

  • 2015-2023: JavaScript absolute leader
  • 2024: Python takes the lead (AI/ML boom)
  • 2025: TypeScript surpasses both

The rise of TypeScript represents the maturity of the JavaScript ecosystem. Developers want types, and they're finally getting them elegantly.

Why TypeScript Grew So Much

AI's Influence on Development

Ironically, the same AI wave that boosted Python now favors TypeScript. AI tools like GitHub Copilot, Claude and ChatGPT work better with typed code.

Why AI prefers TypeScript:

  1. Types are context: LLMs better understand code with explicit types
  2. Superior autocomplete: AI generates more precise code with type hints
  3. Less ambiguity: Types reduce interpretation errors
  4. Implicit documentation: Types serve as living documentation

Enterprise Adoption

Large companies have massively migrated to TypeScript in recent years.

Companies that adopted TypeScript:

  • Microsoft: Language creator, uses in all products
  • Google: Angular is completely TypeScript
  • Meta: Migrating React ecosystem
  • Airbnb: 100% TypeScript in new projects
  • Stripe: API and SDK in TypeScript
  • Slack: Desktop application in TypeScript

Dominated Frontend Ecosystem

Every relevant frontend framework is now TypeScript-first.

Frameworks and TypeScript:

Framework TypeScript Status
Next.js TypeScript-first
Nuxt 3 TypeScript-first
Angular TypeScript required
SvelteKit TypeScript-first
Remix TypeScript-first
Astro TypeScript-first

What This Means For Python

Python Is Not Losing

It's important to contextualize: Python is not in decline. The 8% year-over-year growth is healthy. What happened was that TypeScript grew faster.

Where Python continues to dominate:

  • Data Science: Pandas, NumPy, scikit-learn
  • Machine Learning: TensorFlow, PyTorch
  • Automation: Scripts, DevOps
  • Backend APIs: Django, FastAPI
  • Academic research: Jupyter Notebooks

Different Niches

Market division:

  • TypeScript: Web frontend, Node.js backend, desktop apps
  • Python: AI/ML, data, automation, scripting

The languages don't compete directly in most cases. A developer can (and probably should) know both.

Impact For JavaScript Developers

Gradual Migration

If you still write pure JavaScript, the time to learn TypeScript is now. The good news: the transition is smooth.

Migration strategy:

  1. Start with any: Gradually convert .js files to .ts
  2. Enable strict: Increase rigor as you learn
  3. Use inference: Let TypeScript infer types when possible
  4. Add types gradually: No need to type everything at once

Transition Example

// Original JavaScript
function calculateDiscount(price, percentage) {
  return price - (price * percentage / 100);
}

// Basic TypeScript (inference)
function calculateDiscount(price: number, percentage: number) {
  return price - (price * percentage / 100);
}

// TypeScript with explicit return
function calculateDiscount(price: number, percentage: number): number {
  return price - (price * percentage / 100);
}

// TypeScript with validation
function calculateDiscount(price: number, percentage: number): number {
  if (price < 0) throw new Error('Price must be positive');
  if (percentage < 0 || percentage > 100) {
    throw new Error('Percentage must be between 0 and 100');
  }
  return price - (price * percentage / 100);
}

Features That Made TypeScript Popular

Advanced Type System

TypeScript offers type features that few typed languages have.

// Union Types - value can be multiple types
type Status = 'pending' | 'approved' | 'rejected';

// Conditional types
type NonNullable<T> = T extends null | undefined ? never : T;

// Template Literal Types
type Route = `/api/${string}`;

// Mapped Types
type Readonly<T> = {
  readonly [P in keyof T]: T[P];
};

// Native Utility Types
type UserPreview = Pick<User, 'id' | 'name'>;
type UserUpdate = Partial<User>;
type UserRequired = Required<User>;

Smart Inference

// TypeScript infers types automatically
const numbers = [1, 2, 3]; // number[]
const first = numbers[0];   // number

// Inference in functions
const users = [
  { name: 'Alice', age: 30 },
  { name: 'Bob', age: 25 },
];

// TypeScript knows 'user' has name and age
const names = users.map(user => user.name); // string[]

// Automatic narrowing
function printId(id: string | number) {
  if (typeof id === 'string') {
    // TypeScript knows 'id' is string here
    console.log(id.toUpperCase());
  } else {
    // TypeScript knows 'id' is number here
    console.log(id.toFixed(2));
  }
}

Powerful Generics

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

const firstNumber = getFirst([1, 2, 3]);    // number | undefined
const firstString = getFirst(['a', 'b']);    // string | undefined

// Constraint in generics
interface HasId {
  id: number;
}

function findById<T extends HasId>(items: T[], id: number): T | undefined {
  return items.find(item => item.id === id);
}

// Generics in classes
class Repository<T extends HasId> {
  private items: T[] = [];

  add(item: T): void {
    this.items.push(item);
  }

  find(id: number): T | undefined {
    return this.items.find(item => item.id === id);
  }

  all(): T[] {
    return [...this.items];
  }
}

The Role of Vibe Coding

GitHub highlighted a trend called "vibe coding" that boosted TypeScript.

What Is Vibe Coding

Definition:

Vibe coding is a workflow where developers start with an idea and quickly create a functional prototype, often in a single session, using AI for autocomplete and ready-to-use cloud tools.

Why TypeScript benefits:

  1. AI generates better code: Types help AI understand intent
  2. Errors detected early: Less manual debugging
  3. Safe refactoring: IDE can rename/move with confidence
  4. Automatic documentation: Types explain the code

Tools That Boosted

Popular vibe coding stack:

  • Editor: VS Code / Cursor
  • AI: GitHub Copilot / Claude
  • Framework: Next.js / Nuxt
  • Deploy: Vercel / Netlify
  • Database: Supabase / PlanetScale
  • Language: TypeScript

The Future of TypeScript

Expected Trends

What comes next:

  1. TypeScript 6.0: Performance improvements and new features
  2. Standard decorators: Finally stable
  3. Type-only imports: Bundle optimization
  4. AI integration: Types as prompt engineering

Node.js and Deno

TypeScript-first runtimes:

  • Deno: Native TypeScript without compilation
  • Bun: Ultra-fast transpilation
  • Node.js: Experimental native TS support
// Deno - native TypeScript
// file: server.ts (runs directly, without tsc)
import { serve } from "https://deno.land/std@0.200.0/http/server.ts";

serve((req: Request) => {
  return new Response("Hello TypeScript!");
}, { port: 8000 });

Conclusion

TypeScript's rise to the top of GitHub is no accident. It's the result of a decade of JavaScript ecosystem evolution, combined with the need for safer code and AI tools that work better with types.

For JavaScript developers, the message is clear: TypeScript is no longer optional, it's the standard way to write professional JavaScript in 2025. The good news is that the transition is gradual and the investment is worth it.

If you want to understand more about JavaScript ecosystem trends, I recommend checking out the article about State of JavaScript 2025 where we analyze data from the community's annual survey.

Let's go! 🦅

📚 Want to Deepen Your JavaScript Knowledge?

This article covered the rise of TypeScript, but there's much more to explore in the modern development world.

Developers who invest in solid, structured knowledge tend to have more opportunities in the market.

Complete Study Material

If you want to master JavaScript from basics to advanced, I've prepared a complete guide:

Investment options:

  • 1x of $4.90 on card
  • or $4.90 at sight

👉 Learn About JavaScript Guide

💡 Material updated with industry best practices

Comments (0)

This article has no comments yet 😢. Be the first! 🚀🦅

Add comments