Skip to content
BSWEN
Blog

Why Does Pylance Use 4GB+ RAM and Run So Slowly?

Cowrie
Cowrie
Dev @ Bswen

I opened my Python project in VSCode, and within minutes, my fan was spinning like a jet engine. I checked Activity Monitor and saw it: Pylance was eating 4.2GB of RAM. For a Python autocomplete service.

Why does a language server need more memory than Chrome with 50 tabs?

The Problem

I’ve been using Pylance for Python development in VSCode for a while now. The autocomplete is excellent. Type hints work beautifully. But the cost is ridiculous:

  • Memory usage: 3-6GB for medium-sized projects
  • File parsing: 5-15 seconds for complex files
  • CPU spikes: Random analysis grinding my laptop to a halt
  • VSCode slowdowns: The entire IDE becomes unresponsive

I started digging into why this happens and what alternatives exist.

What Pylance Actually Does

Pylance isn’t just a simple autocomplete tool. It’s Microsoft’s implementation of a full static type checker for Python, built on Pyright. Here’s what runs under the hood:

┌─────────────────────────────────────────────────────────────┐
│                    Pylance Architecture                      │
├─────────────────────────────────────────────────────────────┤
│  Your Code                                                   │
│     │                                                        │
│     ▼                                                        │
│  ┌─────────────────┐                                        │
│  │  AST Parser     │  ← Parses every Python file            │
│  └────────┬────────┘                                        │
│           │                                                  │
│           ▼                                                  │
│  ┌─────────────────┐                                        │
│  │ Type Inference  │  ← Traces types through all code paths │
│  └────────┬────────┘                                        │
│           │                                                  │
│           ▼                                                  │
│  ┌─────────────────┐                                        │
│  │ Symbol Tables   │  ← Maintains in-memory database        │
│  └────────┬────────┘                                        │
│           │                                                  │
│           ▼                                                  │
│  ┌─────────────────┐                                        │
│  │ Type Stubs      │  ← Loads stubs for all dependencies    │
│  └─────────────────┘                                        │
└─────────────────────────────────────────────────────────────┘

Unlike simpler language servers that just do hash table lookups for function definitions, Pylance performs:

  1. Full project analysis - Not just the file you’re editing, but your entire codebase
  2. Deep type inference - Traces how types flow through function calls, generics, inheritance
  3. Dependency resolution - Parses type stubs from all your installed packages
  4. In-memory caching - Stores AST trees, type information, and symbol tables for fast lookups

This is why Reddit users like u/python_dev_2023 report:

“Pylance does a pretty good job but it is so slow and uses so much memory. I mean, why does a language typing service need 4GB+ of RAM? Why does it take 10+ seconds to parse a single file?”

The answer: Pylance trades memory and CPU for accuracy.

Why 4GB+ of RAM?

Let me break down where that memory goes:

1. Your Codebase (500MB - 2GB)

Pylance parses every Python file in your project and creates:

  • Abstract Syntax Trees (ASTs) for each file
  • Symbol tables for all classes, functions, variables
  • Import graphs showing dependencies between modules

2. Type Stubs (1GB - 2GB)

This is the hidden memory sink. Pylance loads type stubs for every package in your virtual environment:

node_modules/             ← JavaScript devs know this pain
venv/lib/python3.11/      ← Python devs have it worse
├── site-packages/
│   ├── numpy/            ← 500+ .pyi files
│   ├── pandas/           ← 300+ .pyi files
│   ├── django/           ← 400+ .pyi files
│   └── ...                ← Multiply by every package

Each .pyi file gets parsed and added to the type database.

3. Type Inference Cache (500MB - 1GB)

Pylance maintains a cache of all inferred types. For complex code with generics:

generics_example.py
from typing import Generic, TypeVar


T = TypeVar('T')


class Container(Generic[T]):
    def __init__(self, value: T) -> None:
        self._value = value


    def get(self) -> T:
        return self._value


# Pylance must track:
# - Container[int] → get() returns int
# - Container[str] → get() returns str
# - Container[list[dict[str, Any]]] → ...complex nesting

Pylance recursively expands these types and caches every combination it sees.

4. IntelliCode Models (Optional, 200MB - 500MB)

If you enable IntelliCode, Pylance loads additional ML models for better autocomplete ranking.

Configuration Options to Reduce Memory

If you want to keep Pylance but reduce its footprint, here are the settings that helped me:

.vscode/settings.json
{
  "python.analysis.memory": 2048,
  "python.analysis.autoImportCompletions": false,
  "python.analysis.typeCheckingMode": "off",
  "python.analysis.diagnosticSeverityOverrides": {
    "reportUnusedImport": "none",
    "reportUnusedVariable": "none"
  },
  "python.analysis.packageIndexDepths": [
    {
      "name": "numpy",
      "depth": 2
    },
    {
      "name": "pandas",
      "depth": 2
    }
  ]
}

Key settings explained:

  • memory: Hard limit on heap size (MB). Pylance will throttle analysis when hitting this.
  • autoImportCompletions: Disables searching all packages for import suggestions.
  • typeCheckingMode: “off” disables Pyright analysis, keeps basic autocomplete.
  • packageIndexDepths: Limits how deep Pylance indexes large packages.

With these settings, my Pylance memory dropped from 4.2GB to about 1.8GB. Autocomplete is slightly less smart, but still usable.

Alternative: Using Jedi Language Server

If you want something lighter, Jedi is the classic choice:

.vscode/settings.json
{
  "python.languageServer": "Jedi"
}

Jedi uses a different approach:

  • Analyzes only open files and their direct imports
  • Uses simpler type inference
  • No full-project analysis by default

Memory usage: typically 200MB - 500MB.

Trade-off: You lose cross-file refactoring, some type hints, and comprehensive autocomplete for complex generic types.

Alternative: Pyright as a Checker Only

You can use Pyright (Pylance’s core) only for type checking, not as a language server:

terminal
# Install pyright globally
pip install pyright


# Run type checking on demand
pyright your_project/

This keeps the heavy analysis out of your editor and runs only when you explicitly check types.

Comparison Table

Here’s how the options stack up:

text ┌─────────────────┬──────────────┬─────────────┬─────────────────┬──────────────┐ │ Language Server │ Memory Usage │ Speed │ Type Accuracy │ Features │ ├─────────────────┼──────────────┼─────────────┼─────────────────┼──────────────┤ │ Pylance │ 3-6 GB │ Slow │ Excellent │ Full IDE │ │ Pylance (tuned) │ 1-2 GB │ Medium │ Good │ Most IDE │ │ Jedi │ 200-500 MB │ Fast │ Basic │ Core IDE │ │ None (plain) │ 50-100 MB │ Instant │ None │ Syntax only │ └─────────────────┴──────────────┴─────────────┴─────────────────┴──────────────┘

Why AI-Based Alternatives Are Even Slower

You might wonder: “Why not use AI for autocomplete?”

I tried GitHub Copilot and other AI assistants. They’re actually slower and more resource-intensive than Pylance:

  1. Network latency: Every suggestion requires an API call
  2. Model inference: Running even small models locally takes 2-4GB VRAM
  3. CPU overhead: AI suggestions need scoring and ranking

As one Reddit commenter noted:

“AI solutions tends to be slower, and CPU-intensive. using table lookup handle the unknown worse, but faster”

Traditional language servers use hash table lookups for symbol resolution - O(1) complexity. AI models require forward passes through neural networks - orders of magnitude slower.

The Design Trade-off

Pylance’s memory usage isn’t a bug - it’s a design choice. Microsoft optimized for:

  • Type accuracy over memory efficiency
  • Comprehensive analysis over speed
  • IDE features over simplicity

If you work on large codebases with complex type hierarchies, Pylance’s approach makes sense. The type safety catches bugs that would cost hours to debug.

For smaller projects or if your machine struggles, configure Pylance to be leaner, or switch to Jedi. Your development experience will be faster, if slightly less feature-complete.

Quick Fix Summary

If you’re hitting memory limits right now:

  1. Immediate relief: Set "python.analysis.memory": 2048 in settings
  2. Better: Switch to Jedi with "python.languageServer": "Jedi"
  3. Alternative: Use external Pyright for type checking, not as language server

The 4GB RAM usage is excessive for simple autocomplete, but reasonable for a full static analysis engine. Pick the tool that matches your needs.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!

Comments

Tags: