Is Python dying in Data Science? Why Julia, Mojo, and Rust are attacking the king's throne

Introduction

Over the past few years, the Data Science community has been increasingly talking about Python losing ground to new programming languages. Julia demonstrates impressive performance, Mojo promises a revolution in AI development, and Rust wins the hearts of ML library developers. Is it time for novice developers to abandon Python and switch to new technologies? Let's find out.

Python today: the king, but with problems

Python remains the undisputed leader in Data Science. According to 2025 surveys, more than 85% of professionals use Python as their primary tool. The language ecosystem includes powerful libraries:

• NumPy and Pandas for working with data

• Scikit-learn for machine learning

• TensorFlow and PyTorch for deep learning

• Matplotlib and Seaborn for visualization

But Python has fundamental problems:

Performance. Python is an interpreted language with dynamic typing. This makes it slow for computationally complex tasks. Yes, NumPy and Pandas use C under the hood, but this is only a partial solution.

GIL (Global Interpreter Lock). Limits multithreading, which is critical for parallel computing in big data.

Memory management. Automatic garbage collection can cause unpredictable delays in critical systems.

Julia: the speed of science

Julia appeared in 2012 specifically for scientific computing. Its main advantage is the speed comparable to C, with a syntax similar to Python.

Advantages of Julia

Productivity out of the box. JIT compilation (Just-In-Time) allows Julia to execute code almost as fast as compiled languages:

# A simple function for calculating the sum of squaresfunction sum_of_squares(n)
    total = 0.0
    for i in 1:n
        total += i^2
    end
    return total
end

# This code will work almost as fast as on C@time sum_of_squares(1_000_000)

Multiple dispatching. Julia uses multiple dispatch — functions are selected based on the types of all arguments, which makes the code more flexible and productive.

Built-in parallelism. Julia was originally designed for parallel computing without crutches.

Disadvantages of Julia

• Small ecosystem compared to Python

• Long first compilation time (time-to-first-plot problem)

• Fewer vacancies and training materials

• API instability in some packages

Julia's growth

According to the TIOBE Index, Julia has consistently been among the top 30 languages since 2020. It is actively used in scientific organizations, including NASA, and fintech companies for high-frequency trading.

Mojo: Python on steroids

Mojo is a new language from the creators of Swift and LLVM, introduced in 2023 by Modular. Its goal is to combine the simplicity of Python with the performance of C.

What's special about Mojo?

Python compatibility. Mojo is designed as a Python superset — all Python code should work in Mojo (although it is still under development).

System programming. Mojo gives direct access to hardware, memory management, and SIMD instructions:

fn sum_vectors(a: DTypePointer[DType.float32], 
               b: DTypePointer[DType.float32],
               result: DTypePointer[DType.float32],
               size: Int):
    # Vectorization using SIMD
    for i in range(0, size, 8):
        let vec_a = a.simd_load[8](i)
        let vec_b = b.simd_load[8](i)
        result.simd_store[8](i, vec_a + vec_b)

Incredible speed. In tests, Mojo shows an acceleration of 35,000 times compared to pure Python for some tasks.

Mojo Issues

• Very young language (less than 2 years)

• Closed development — not open source yet (although they promise)

• Small community

• Unstable documentation

Mojo Perspectives

If Modular delivers on its promises, Mojo could be a real breakthrough. The ability to write code with C performance without leaving the Python ecosystem is the dream of many developers.

Rust + ML: safety and speed

Rust was not originally created for Data Science, but its advantages attracted the attention of the ML community:

Memory security. The Rust compiler guarantees no memory leaks and data races at the compilation stage.

Performance. Rust shows a speed comparable to C++.

Modern ecosystem. Cargo (package manager) and a rich type system make development enjoyable.

ML libraries in Rust

The Rust ecosystem for ML is actively growing:

• Polars — DataFrame library that is 10+ times faster than Pandas in many tasks

• Burn — a framework for deep learning

• Linfa — Scikit-learn analog

• ndarray — multidimensional arrays like NumPy

Example of using Polars:

use polars::prelude::*;

fn main() -> Result<()> {
    let df = CsvReader::from_path("data.csv")?
        .infer_schema(None)
        .has_header(true)
        .finish()?;
    
    // Fast data operations
    let result = df
        .lazy()
        .filter(col("age").gt(30))
        .groupby([col("country")])
        .agg([col("salary").mean()])
        .collect()?;
    
    println!("{:?}", result);
    Ok(())
}

Rust limitations for ML

• Learning curve — Rust is more difficult than Python for beginners

• Fewer ready-made models and pre-trained scales

• Fewer specialists know Rust

• Type system can slow down prototyping

So is Python dying?

The short answer is no.

Python is not dying, but its role is evolving:

Python remains for:

1. Rapid prototyping — nothing compares to the simplicity of writing an ML pipeline in a few hours

2. Training — the best language to enter Data Science

3. Integrations — a huge number of libraries and tools

4. Community — millions of developers, StackOverflow, courses, books

New languages are taking over:

• Julia - for scientific computing where performance is critical

• Mojo — for production of AI systems (in the future)

• Rust - for high-load systems and data processing tools

Conclusions

Python in Data Science is not dying — it is transforming. New languages do not replace it, but complement it, occupying niches where Python shows weakness. For most tasks, Python remains the best choice.

Key rule: choose a tool for the task, not fashionPython, Julia, Mojo, and Rust are not competitors, but participants in the same ecosystem, each with its own strengths.

Learn Python, Julia, Rust basics, and more in Codice — our educational platform for beginner developers. We create easy-to-understand courses and tutorials that will help you enter the world of programming and Data Science.

And we also have cool Telegram channel with a friendly community, where we discuss industry news, share useful materials, and help each other grow as developers. Join us and let's learn together! 🚀