100. Future Directions
Active PEPs, the free-threaded and JIT roadmaps, memory model work, and how to follow CPython development.
Tag
Internals
111 notes
32. Method Calls
LOAD_METHOD and CALL_METHOD optimization, bound method objects, and the method cache.
27. Evaluation Loop
The main evaluation loop in Python/ceval.c, opcode dispatch via computed gotos, and the eval breaker mechanism.
99. Security Boundaries
CPython security model: what is and is not sandboxed, restricted execution limits, and audit hook coverage.
98. Serialization Internals
pickle protocol versions, the __reduce__ / __reduce_ex__ protocol, marshal format, and shelve internals.
97. Import System Edge Cases
Circular import resolution, namespace package search order, zip imports, and __import__ hook edge cases.
96. Stable ABI Design Tradeoffs
What breaking the stable ABI costs, historical breakages, versioning policy, and the tradeoff against new features.
95. JIT Work in CPython
CPython 3.13 copy-and-patch JIT: template JIT design, trace selection, and the roadmap toward full JIT compilation.
94. Per-Interpreter GIL
PEP 684 per-interpreter GIL: isolated interpreter state, shared-nothing model, and module isolation requirements.
93. Immortal Objects
PEP 683 immortal objects: _Py_IMMORTAL_REFCNT sentinel, zero-cost incref/decref, and implications for forks.
92. Free-Threaded CPython
PEP 703 no-GIL build: per-object locking, biased reference counting, and the free-threaded evaluation loop.
91. Release Process
CPython version numbering, alpha/beta/RC schedule, branch management, and the role of the release manager.
90. Reading PEPs
PEP document structure, the steering council review process, and tracking PEP status on peps.python.org.
89. Making a CPython Patch
GitHub workflow: forking, branching, opening a PR, responding to review, and the CLA requirement.
88. Documentation Workflow
Doc/ Sphinx source layout, building docs with make html, and the process for submitting documentation fixes.
87. Writing Core Tests
test_* module conventions, unittest patterns, support helpers in Lib/test/support/, and writing C-level tests.
86. Tracing Memory Bugs
Valgrind suppression files, tracemalloc snapshot diffing, and libasan leak detection in CPython builds.
85. Sanitizers
Building CPython with AddressSanitizer, UBSan, and ThreadSanitizer to catch memory and concurrency bugs.
84. GDB and LLDB
CPython-aware GDB and LLDB scripts in Tools/gdb/, py-bt, py-list, and inspecting live interpreter frames.
83. Debug Builds
Py_DEBUG compile flag, assertion macros, the --with-pydebug configure option, and debugging allocator.
82. Running the Test Suite
python -m test flags, regrtest test selection, parallel execution (-j), and interpreting test output.
81. Benchmarking CPython
pyperformance benchmark suite, microbenchmark pitfalls, timer resolution, and interpreter warm-up effects.
80. Profiling CPython
Using perf, Instruments, and py-spy to profile CPython; reading perf maps generated by the JIT.
79. Memory Locality
Object allocation locality, arena page placement, freelists for common types, and cache-line–aware design.
78. Attribute Access Performance
Type version tags, LOAD_ATTR inline cache hits, and the attribute specialization guards for slots and descriptors.
77. Dictionary Performance
Compact dict memory layout, hash collision probing strategy, split-table sharing, and lookup specialization.
76. Vectorcall
PEP 590 vectorcall protocol, _Py_TPFLAGS_HAVE_VECTORCALL, and stack-based argument passing for zero-overhead calls.
75. Function Call Fast Paths
CALL_PY_EXACT_ARGS, CALL_BUILTIN_FAST, and the fast-path conditions that bypass the generic call machinery.
74. Specializing Adaptive Interpreter
Adaptive counter logic, specialization guards, and how CPython 3.11+ rewrites opcodes to LOAD_ATTR_SLOT and friends.
73. Inline Caches
Inline cache entries appended to CACHE instructions in the bytecode array and their layout per opcode family.
72. Interpreter Dispatch
Computed goto dispatch table, the switch fallback, and how opcode prediction reduces branch mispredictions.
71. Calling C From Python
ctypes, cffi, and CFFI-based extension dispatch as the primary paths for calling C libraries from Python.
70. Calling Python From C
PyObject_Call, PyObject_CallNoArgs, argument tuple construction, and error checking after calling into Python.
69. Embedding Python
Py_Initialize, PyConfig, embedding CPython in a host process, and managing interpreter lifetime.
68. Limited API
Py_LIMITED_API version macros, symbols excluded from the limited API, and building abi3-compatible extensions.
67. Stable ABI
The stable ABI symbol set, abi3 wheel tagging, and the constraints imposed by maintaining ABI compatibility.
66. Capsules
PyCapsule_New, PyCapsule_GetPointer, and the pattern for passing opaque C pointers between extension modules.
65. Buffer Protocol
Py_buffer, PyBUF_* flags, PyObject_GetBuffer, and implementing the buffer protocol in a custom type.
64. Defining New Types
PyTypeObject slot-by-slot walkthrough: tp_new, tp_init, tp_dealloc, tp_methods, tp_getset, and inheritance.
63. Creating Extension Modules
PyModuleDef structure, PyModule_Create, multi-phase initialization (PEP 451), and module state.
62. Reference Ownership Rules
Borrowed vs. owned references, Py_XDECREF patterns, and common reference counting mistakes in extensions.
61. The Python C API
Public C API overview, Include/ header organization, and the stable vs. internal API distinction.
60. `asyncio`
asyncio event loop internals, the coroutine runner, I/O selector integration, and Task scheduling.
59. `multiprocessing`
multiprocessing Process creation strategies (fork/spawn/forkserver), shared memory, and the pickle channel.
58. `ctypes`
ctypes CDLL and WinDLL, fundamental types, Structure/Union layout, function prototypes, and libffi integration.
57. `importlib`
importlib.machinery finders and loaders, importlib.util helpers, and the Python-level import bootstrap.
56. `types`
types.FunctionType, types.CodeType, types.SimpleNamespace, and dynamic type creation with types.new_class.
55. `gc`
gc.collect, gc.get_objects, gc.freeze, callbacks, and tuning generational thresholds.
54. `dis`
dis.dis output, Instruction namedtuples, the bytecode iterator API, and reading adaptive specializations.
53. `inspect`
inspect.getmembers, signature objects, frame introspection, and source retrieval via linecache.
52. `sys`
sys module fields that expose interpreter state: sys.modules, sys._getframe, sys.getsizeof, and audit hooks.
51. Audit Hooks
sys.addaudithook, the cpython.PyAudit_AddHook C API, and auditable events across the standard library.
50. Context Variables
PEP 567 Context and ContextVar objects, context copying on task creation, and asyncio integration.
49. Signals
Signal handler registration, the eval breaker flag, and safe SIGINT delivery to Python code.
48. Subinterpreters
Per-interpreter state isolation, Py_NewInterpreterFromConfig, and the experimental per-interpreter GIL.
47. Threads
Python thread objects, OS thread mapping, the GIL acquisition protocol, and thread-local state management.
46. The GIL
GIL purpose, implementation in Python/ceval_gil.c, forced release intervals, and its effect on multi-core performance.
45. The MRO
C3 linearization algorithm, mro() computation, and how Python resolves method lookup across multiple inheritance.
44. Classes and Metaclasses
type.__new__ and type.__init__, __init_subclass__, __set_name__, and metaclass resolution order.
43. Descriptors
__get__, __set__, __delete__ protocol, data vs. non-data descriptors, and property/classmethod/staticmethod internals.
42. The Import Lock
The per-module import lock, re-entrant import detection, and deadlock scenarios in multithreaded code.
41. Packages
Package __init__.py, namespace packages (PEP 420), relative imports, and __path__ manipulation.
40. Modules and Imports
The import machinery: finders, loaders, sys.modules cache, and the importlib bootstrap sequence.
39. Closures and Cells
MAKE_CELL, LOAD_DEREF, STORE_DEREF opcodes and the PyCellObject that captures variables in enclosing scopes.
38. Comprehensions
How list/dict/set comprehensions and generator expressions compile to nested code objects with implicit iteration.
37. Pattern Matching
match/case compilation to MATCH_* opcodes, pattern semantics, and guard evaluation in the interpreter.
36. Coroutines and Async
async def, await, SEND opcode, coroutine wakeup, and how asyncio integrates with CPython's coroutine machinery.
35. Generators
Generator object internals, YIELD_VALUE and RESUME opcodes, and frame suspension and resumption mechanics.
34. Exception Handling
Exception tables, the try/except/finally bytecode pattern, exception chaining, and the unwinding protocol.
33. Attribute Lookup
LOAD_ATTR bytecode, __getattribute__ dispatch, the descriptor protocol, and type version tag caching.
31. Function Calls
CALL opcode mechanics, positional and keyword argument handling, *args/**kwargs unpacking, and call overhead.
30. Bytecode Instructions
Catalogue of CPython opcodes: LOAD/STORE variants, binary ops, comparison, jumps, and call instructions.
29. Stack-Based Execution
The value stack, operand push/pop discipline, and how the interpreter maintains stack depth invariants.
28. Frames
PyFrameObject and _PyInterpreterFrame layout, frame creation, the frame stack, and frame introspection.
26. Bytecode Optimization
Peephole optimizer passes: constant folding, dead code elimination, and superinstruction formation in Python/flowgraph.c.
25. Bytecode Generation
Instruction emission, jump fixup, and the assembler in Python/compile.c that produces the final bytecode array.
24. Constants, Names, and Locals
How compile-time constants are folded, names interned, and local variable slots assigned in the code object.
23. Code Objects
PyCodeObject fields: co_code, co_consts, co_names, co_varnames, co_filename, and how they are used at runtime.
22. Compiler Passes
Multi-pass lowering from AST to CFG to linear bytecode, and the role of each compiler pass in Python/compile.c.
21. Symbol Tables
Scope analysis in Python/symtable.c: local, global, free, and cell variable classification before compilation.
20. The AST
AST node types defined in Parser/Python.asdl, the ast module, and how AST nodes map to source locations.
19. Parsing
CPython's PEG parser, Grammar/python.gram, the generated Parser/parser.c, and parse tree construction.
18. Tokenization
Tokenize module internals, the C tokenizer in Parser/tokenize.c, and how indentation becomes INDENT/DEDENT tokens.
17. Integers, Floats, and Complex Numbers
PyLongObject digit array for arbitrary precision, PyFloatObject IEEE 754 storage, and complex number layout.
16. Dictionaries and Sets
Compact dict implementation, hash table probing, split-key sharing, and PySetObject collision resolution.
15. Lists, Tuples, and Arrays
PyListObject dynamic resizing strategy, PyTupleObject immutability, and the array module's typed buffer.
14. Strings, Bytes, and Unicode
PyUnicodeObject internal encodings, the interning table, bytes vs. bytearray, and the codec infrastructure.
13. Built-in Object Implementations
C-level implementations of None, True, False, NotImplemented, and Ellipsis as statically allocated objects.
12. Object Layout and Type Slots
PyTypeObject slot layout, tp_* function pointers, and how type slots encode object behavior for the interpreter.
11. Memory Allocators
The pymalloc small-object allocator, arenas, pools, blocks, and when CPython falls back to system malloc.
10. The Garbage Collector
Cycle detection algorithm, generational collection, gc thresholds, and the interaction with reference counting.
9. Reference Counting
Py_INCREF, Py_DECREF, and the deterministic lifetime rules that drive most memory reclamation in CPython.
8. PyObject and PyVarObject
The PyObject and PyVarObject C structs: ob_refcnt, ob_type, and the ob_size extension for variable-length objects.
7. The Python Object Model
How every value in Python is a heap-allocated object, and the role of type objects in defining behavior.
6. From Source Code to Execution
End-to-end journey of a .py file through lexing, parsing, compilation, and bytecode evaluation.
5. The Runtime Model
The interpreter state, thread state, frame stack, and the runtime lifecycle from Py_Initialize to Py_Finalize.
4. Reading CPython C Code
Conventions, macros, naming patterns, and header layout used throughout the CPython C codebase.
3. Repository Layout
Tour of the CPython source tree: Modules/, Objects/, Python/, Parser/, Include/, and the build system.
2. Building CPython From Source
Cloning the repository, installing dependencies, running ./configure, and compiling CPython from source.
1. What CPython Is
What CPython is, how it differs from other Python implementations, and why its internals are worth studying.
10. Advanced Topics
Free-threaded CPython, immortal objects, per-interpreter GIL, JIT work, stable ABI design tradeoffs, import system edge cases, serialization internals, security boundaries, and future directions.
9. Development Workflow
Running the test suite, debug builds, GDB and LLDB, sanitizers, tracing memory bugs, writing core tests, documentation, making patches, reading PEPs, and the release process.
8. Performance Internals
Interpreter dispatch, inline caches, the specializing adaptive interpreter, function call fast paths, vectorcall, dictionary and attribute access performance, memory locality, profiling, and benchmarking.
7. C API and Extensions
The Python C API, reference ownership rules, creating extension modules, defining new types, the buffer protocol, capsules, stable ABI, limited API, embedding Python, and cross-language calls.
6. Standard Library Interfaces to the Core
How sys, inspect, dis, gc, types, importlib, ctypes, multiprocessing, and asyncio bridge Python code to CPython internals.
5. Runtime Systems
Modules and imports, packages, the import lock, descriptors, classes and metaclasses, the MRO, the GIL, threads, subinterpreters, signals, context variables, and audit hooks.
4. The Interpreter
The evaluation loop, frames, stack-based execution, bytecode instructions, function and method calls, attribute lookup, exceptions, generators, coroutines, pattern matching, comprehensions, and closures.
3. Compilation Pipeline
Tokenization, parsing, the AST, symbol tables, compiler passes, code objects, constants and locals, bytecode generation, and bytecode optimization.
2. Objects and Memory
The Python object model, PyObject and PyVarObject layout, reference counting, the garbage collector, memory allocators, and built-in type implementations.
1. Orientation
What CPython is, building from source, the repository layout, reading C code, the runtime model, and the path from source code to execution.
CPython Internals
A deep read of CPython: architecture, object model, memory management, compilation pipeline, and the evaluation loop.