> ## Documentation Index > Fetch the complete documentation index at: https://mintlify.com/shedskin/shedskin/llms.txt > Use this file to discover all available pages before exploring further. # Shed Skin Documentation > Compile Python to optimized C++ with type inference
{/* Hero Content */}

Compile Python to Optimized C++

Shed Skin is a restricted-Python-to-C++ compiler that translates implicitly statically typed Python programs into optimized C++ code, delivering speedups of 1-100x over CPython.

{/* Code Example */} 
              
                {`# sieve.py
                                def sieve(n):
                                  primes = [True] * n
                                  for i in range(2, int(n**0.5) + 1):
                                      if primes[i]:
                                          for j in range(i*i, n, i):
                                              primes[j] = False
                                  return [i for i in range(2, n) 
                                          if primes[i]]

                                # Compile and run
                                $ shedskin build sieve
                                $ build/sieve
                                # 20x faster than CPython!`}

Quick start

Get up and running with Shed Skin in minutes

Install using pip or your package manager: ```bash theme={null} pip install shedskin ``` You'll also need a C++ compiler and the Boehm garbage collector. See the [installation guide](/installation) for platform-specific instructions. Create a Python file with implicitly statically typed code: ```python test.py theme={null} def factorial(n: int) -> int: if n <= 1: return 1 return n * factorial(n - 1) print(factorial(10)) ``` Shed Skin requires implicit static typing — variables must maintain a single type throughout execution. Use the `shedskin build` command to compile your Python code: ```bash theme={null} shedskin build test ``` This generates optimized C++ code and compiles it into an executable in the `build/` directory. Execute the compiled binary for dramatic performance improvements: ```bash theme={null} ./build/test ``` Typical speedups range from 12x to 20x compared to CPython, with some programs achieving 100x improvements.

Key features

Everything you need to accelerate Python performance

Automatic type inference eliminates the need for explicit type annotations while generating statically typed C++ code. Generate fully compiled executables or extension modules that can be imported into larger Python programs. Built-in support for common Python modules including random, re, itertools, and more. Achieve 1-100x speedups over CPython with typical improvements of 12-20x for computation-intensive code. Automatic memory management using the battle-tested Boehm garbage collector. Create C++ extension modules that integrate seamlessly with your existing Python codebase.

Explore the documentation

Learn how to use Shed Skin effectively

Core Concepts

Understand typing restrictions, Python subset support, and how Shed Skin works under the hood.

Learn the fundamentals

Guides

Step-by-step tutorials for writing compatible code, creating extension modules, and optimizing performance.

Read the guides

CLI Reference

Complete command-line reference for build, translate, and all compilation options.

View CLI docs

Examples

Explore 80+ real-world examples including games, algorithms, and performance benchmarks.

Browse examples

Performance comparison

Shed Skin delivers exceptional performance improvements over CPython and other Python implementations

CPython 3.11 11.4 seconds (baseline)
PyPy 3.9 5.8 seconds (2x faster)
Numba 0.56 2.5 seconds (4.5x faster)
Shed Skin 0.9.9 1.9 seconds (6x faster)

Benchmark: Sieve of Eratosthenes with n=100,000,000. See the full benchmark suite for more comparisons.

When to use Shed Skin

Good fit

  • Computation-intensive Python programs (hundreds to thousands of lines)
  • Code that can be made independent of external libraries
  • Performance-critical modules in larger Python applications
  • Algorithms, simulations, and numeric computations

Not recommended

  • Programs heavily dependent on unsupported libraries
  • Code using dynamic Python features (eval, getattr, \*args)
  • Very large codebases (>6,000 lines) due to type inference limitations
  • Applications requiring arbitrary-size arithmetic or full Unicode support

Community & support

Get help and connect with other Shed Skin users

Ask questions, share projects, and discuss features with the community. Report bugs, request features, or browse known issues. Learn how to contribute code, documentation, or supported modules. Find answers to common questions about Shed Skin usage and limitations.

Ready to accelerate your Python code?

Start compiling Python to optimized C++ and achieve dramatic performance improvements.

Get Started Now