What works, feature by feature¶
Generated on 2026-09-12 from compatibility.json, measured 2026-09-12
This is the honest map of how much of Python 3.9 d/Python supports today. It is kept as a machine-readable file with 45 entries, one per language feature, each saying what works, what is tested, and exactly what is missing. The rule the file states for itself is the rule of this site:
Partial is not complete. Deferred rows remain in the inventory. Compiler acceptance alone is never executing coverage.
36 features are supported in part and 9 are not yet supported. None is marked complete. "In part" means the Works today text is backed by tests, and the Not yet text names what is left. If you hit something the compiler cannot do, this is the page that explains why. The builtin functions and the intent coverage pages are the two companion tables.
Features¶
syntax.scalars · supported in part¶
Works today. literals, assignment, parallel unpacking, object/list values, fixed-shape tuple values and nested unpacking; rebinding of compatible already-typed lists, dictionaries and sets, including nested values
Not yet. Dynamic variable type changes remain pending. Independent unknown empty shapes are not unified; tuple descriptor identities must still match.
Python version: 3.9
Test programs: strings.py, container_rebinding.py
semantics.int · supported in part¶
Works today. arbitrary-precision + - * compare // % **; catchable zero division; int() construction from integers/booleans/text/bytes with bases 0 and 2..36, Unicode decimal digits, Python whitespace/sign/prefix/underscore rules, arbitrary precision accumulation and catchable ValueError; bool/int comparisons preserve Python numeric equality and ordering; bool/int arithmetic, boolean abs and integer/boolean inversion; arbitrary-integer &, | and ^ preserve infinite sign extension; two boolean operands produce bool and mixed bool/int operands produce int; augmented assignment preserves the existing fixed variable representation; << and >> with arbitrary integer counts, catchable negative-count ValueError, zero-left-shift and huge-right-shift shortcuts, and the pinned macOS ssize_t OverflowError for excessive nonzero left shifts; divmod() over integers and booleans returns a quotient/remainder tuple through existing shared arithmetic and tuple ownership, preserving argument evaluation and catchable zero division
Not yet. Exponent must be a nonnegative literal or boolean; true division and mixed float/integer arithmetic remain pending. Float/custom numeric conversion and general buffer inputs are pending. Integer conversion follows the pinned Unicode 13 decimal table. DBC string capacity applies, including representation used to construct errors. Shift index adapters remain pending. Left shifts keep counts as decimal integers; work and output growth remain subject to shared execution/string/memory limits. The excessive-left-shift boundary is pinned to the macOS oracle and needs target-specific validation elsewhere. divmod float/mixed/custom numeric protocols remain pending.
Python version: 3.9
Test programs: arithmetic.py, exceptions.py, integer_conversion.py, membership.py, summation.py, bitwise.py, shifts.py, divmod.py
semantics.str · supported in part¶
Works today. Unicode concat, compare, len, truth, repr and f-string !r; byte concat/compare/length/repr; full unsigned DBC length range; Unicode/byte indexing and slicing with arbitrary integer bounds; find/rfind/index/rindex/count with bounded Unicode/byte indices, byte integer needles, startswith/endswith including typed tuple alternatives, partition/rpartition, strip/lstrip/rstrip with Python whitespace, split/rsplit and keyword limits, replace, typed list/tuple join and Unicode string join; distinct str/bytes bounds errors and signed 64-bit index-sized-integer errors for the pinned macOS target; prefix/suffix predicates expose canonical Python bool values in numeric conversion, equality and indices; Unicode/byte membership and byte-integer membership with catchable range errors; UTF-8 str.encode() over supported scalar text, with default or literal normalized UTF-8 codec aliases and strict errors; immutable DBC string ownership is shared while Python str/bytes semantics stay distinct; byte subscripts retain Python bounds and signed index-sized-integer checks, then extract one byte through the shared DBC substring operation using a Long position instead of scanning the payload; ascii() and f-string !a run existing repr once and escape only non-ASCII Unicode scalars through a shared text DBL helper, preserving custom repr ASCII controls and backslashes; ord() decodes one Unicode scalar or one-byte bytes value with once-only evaluation and catchable length/type errors for supported representations; chr() constructs one Unicode scalar from an integer or boolean, evaluates its argument once, preserves captured aliases and fixed argument expansion, and raises catchable wrong-type, signed C-int overflow and Unicode-range errors with builtin exception identity despite name shadowing. Ordinary class index methods use inherited class-slot lookup, ignore instance-only special attributes, convert once and preserve raised exception identity. Supported non-integer returns and missing/noncallable slots produce catchable TypeError. This conversion is enabled only for bin(), oct(), hex() and chr().
Not yet. Remaining methods, generic iterable/buffer adapters, catchable wrong-type method arguments, format specifications, custom index for string indexing/slicing and method index arguments, and decoding remain pending. DBC string/object capacities apply. Count/maxsplit use the pinned macOS signed 64-bit Py_ssize_t boundary; cross-target policy needs validation. Reverse splitting currently reverses source/separator/pieces and allocates intermediate strings; no linear-time or low-memory claim. Encoding currently requires literal codec/error names and strict handling; other codecs, handlers, surrogates, dynamic codec selection, bound encoding methods and unpacked codec arguments remain pending. ascii inherits existing repr gaps, rejects surrogate text, and refuses output expansion beyond the shared 65,535-byte string carrier; it is not a new codec or a full format-specification adapter. ord() retains gaps for bytearray/buffer adapters, surrogates, some type names and catchable call-shape errors; full invalid Unicode lengths require a billed chunked scan. Surrogate code points U+D800..U+DFFF explicitly raise NotImplementedError because the current string representation cannot preserve them; CPython accepts them, so this refusal is not conformance. Bool-returning index methods need a DeprecationWarning adapter; callable-valued slots/descriptors, dynamic class changes, unsupported return representations, broader wrong-type names and catchable argument-shape errors remain pending. C-int overflow behavior remains pinned to the macOS CPython oracle, including overflow before the Unicode range check after index conversion.
Python version: 3.9
Test programs: strings.py, lists.py, slicing.py, text_methods.py, sequence_iteration.py, membership.py, utf8_encoding.py, bytes_indexing.py, ascii.py, ord.py, chr.py, index_protocols.py
semantics.float · supported in part¶
Works today. finite double literals, homogeneous + - * and comparison where the shared numeric carrier admits the result
Not yet. Python float formatting, nonfinite/overflow behavior, division, conversion and exception behavior are pending. The shared numeric runtime may refuse nonfinite operations; that is a gap, not Python conformance.
Python version: 3.9
semantics.control · supported in part¶
Works today. if, while, range/list/tuple/dictionary/view/set loops, break/continue/else, short circuit, chained comparisons and finally cleanup; direct Unicode character and byte-integer loops, retaining the original immutable source through rebinding, including comprehensions and finally/control transfers; for loops over range objects and dynamic-step range calls, catchable zero step, declared user range-function overrides; synchronous context cleanup across return/break/continue and ordinary user-class iterator loops
Not yet. Same-type values; literal range step; conservative definite assignment.
Python version: 3.9
Test programs: loops.py, lists.py, exceptions.py, dictionary_views.py, sets.py, sequence_iteration.py, ranges.py, iterator_protocols.py, context_managers.py
semantics.functions · supported in part¶
Works today. specialized calls, positional-only/positional/keyword-only binding, fixed-shape args tuples and homogeneous ordered *kwargs dictionaries; module-function defaults evaluated once at definition, retaining shared mutable values, original global values and callable receivers, globals, direct and mutual recursion through DBC activation frames, builtin shadowing by declared functions; compatible typed-container return branches and recursive results share a canonical representation; stable user/builtin function values, aliases, parameters/returns, typed containers and instance fields, identity/equality, truth, callable(), name/module/type-name attributes, and callable-before-arguments evaluation; bound user methods retain receivers, pass through callbacks/containers/instance fields, preserve method identity versus equality, expose self/func, and bind inherited/super methods; nested functions/lambdas and shared nonlocal cells are tracked in semantics.closures; call-site expansion of fixed tuples and literal lists plus literal-string-key dictionary arguments, including mixed carriers for separately bound parameters, repeated expansions and literal dictionary overwrite/insertion order; nested fixed tuple/literal-list expansions share the tuple display evaluator; function, closure and bound/unbound method module keeps the defining global name after later name changes; callable user objects retain state across typed containers, callbacks and GUI events; call methods use existing argument binding and recursive frames, can return closures, and preserve defining module globals. Class-held callable objects, bound methods and class constructors delegate without another implicit receiver. Non-callable supported values raise catchable TypeError after arguments execute.
Not yet. One result type; no annotations or dynamic function redefinition. Recursive result inference needs an earlier concrete base case. Recursion limit is 128. Global declarations must precede other statements in their scope. Callable values specialize by exact target; changing a variable across targets, builtin bound methods, function-valued class descriptors and dynamic global rebinding remain pending. Rebinding a callable captured by already-specialized code is diagnosed. Supported builtin aliases are abs/all/any/ascii/bin/bool/callable/chr/divmod/filter/hex/iter/len/max/min/next/oct/ord/print/repr/reversed/sorted/sum; other builtin/class values and builtin-alias keywords requiring literal syntax remain pending. Address-bearing function repr is pending. Function-signature binding failures currently produce compile diagnostics rather than catchable TypeError. Dynamic call-site iterable/*mapping expansion, nested dictionary expansion in call arguments, builtin methods and literal-sensitive builtin expansion, arbitrary mixed collected keyword dictionaries, method defaults beyond immutable literals, defaults/kwdefaults reflection and general dynamic argument shapes remain pending.
Python version: 3.9
Test programs: functions.py, recursion.py, container_rebinding.py, callables.py, extrema_keys.py, bound_methods.py, function_signatures.py, function_defaults.py, closures.py, call_unpacking.py, display_unpacking.py, module_environment.py
semantics.order · supported in part¶
Works today. left-to-right arguments short circuit chained comparison
Not yet. Supported scalar operations only.
Python version: 3.9
Test programs: evaluation.py
builtins.print · supported in part¶
Works today. str, bytes, int, bool, None, lists, tuples, dictionaries, live views, sets/frozensets, exception objects and str objects; literal or computed str/None sep/end, evaluated once before conversion; ordinary aliases, closures and fixed call unpacking; catchable TypeError for other option types
Not yet. File/flush, float formatting and str subclasses remain pending. Exception wording is not a CPython diagnostic-identity claim.
Python version: 3.9
Test programs: strings.py, classes.py, lists.py, exceptions.py, tuples.py, dictionaries.py, dictionary_views.py, sets.py, print_options.py
dos.console · supported in part¶
Works today. Normal console face and shared DBC execution; installed console launch through the shared store and linker; CLI console shares the live d/BASIC terminal host with streaming output, line input, arguments after --, real monotonic clock and sleep, and native MATH. The trace command and library conformance runner remain deterministic. Live output does not require a complete buffered DBCT trace. Console and GUI CLI launch select the shared FILE provider with --file-mount; absent mounts refuse before execution and launcher configuration cannot grant undeclared FILES. The compiled artifact and source launch paths preserve staged cancellation/commit. Console launch now selects the existing bounded COMPUTE.SHA256 provider for an image declaring BULK, matching GUI selection. Hashing uses the canonical intent and shared native executor; ordinary console programs do not allocate its scratch. Declared SOUND now selects the shared native cached AUDIO provider without a window or GPU dependency; both console launchers require a live stream and check playback health before and after each slice. Both CLIs accept explicit --net-endpoint for console source/DBC runs through one shared selector; d/Python forwards it to the same native GUI host. Selection requires declared NETWORK before mounting host workers. Unselected consoles expose the shared local QUERY_LINK absent answer without a NET provider allocation; NETWORK operations still require a mounted provider. The headless net feature does not enable graphics. Python input uses the shared raw line/result service with an explicit EOFError adapter; legacy READ_LINE preserves its existing byte-string/EOF refusal contract.
Not yet. GUI input producer/cancellation, additional native console intent providers and physical/product launch evidence remain pending. The Python input text/resource profile and remaining adapters are recorded in builtins.input.
Python version: 3.9
dos.gui · supported in part¶
Works today. window faces, native renderer, pointer/key input, complete tic-tac-toe game, repaint, reset, close and heap cleanup; paired retained UI intent scenarios exercise ownership, geometry, text queries and canvas state through the shared native provider; retained widget example with UI property updates, pointer press/release/cancel, Space/Enter activation, resize, six live UI nodes and explicit subtree close; five reviewed native renderer states match with frame journaling enabled and disabled, and repeated updates retain no temporary objects
Not yet. Other lifecycle events need additional executing coverage. Native host now binds DBL support libraries.
Python version: 3.9
dos.intents · supported in part¶
Works today. 187/187 current callable rows have typed compile bindings; dynamic fixed-width bounds, buffers, decimals, numeric selectors and multi-results; PARSE and ARRAY_REDUCE decode the result format from argument 1, while CONVERT uses argument 0, preserving Integer/Long/Decimal/Single/Double carriers; paired native success scenarios now cover all 25 MATH operations, including authorized array effects and random state; 11 advertised native GFX rows have paired typed-call, exact-pixel and publication scenarios; all 24 UI rows have paired retained-scene or owned-array-snapshot success scenarios. Eight basic FILE rows have 22 paired transactions with independently specified complete request/reply bytes, array effects and filesystem snapshots: query/list/stat, staged open/write/close, simultaneous reading, cancel/commit, rename, mkdir and delete. Twelve malformed/path/absent/stale cases and handle exhaustion preserve original bytes and clean up unpublished staging. Python function parameters and local aliases borrow fixed D/OS buffers through existing DBC Places, preserving the caller allocation across nested/recursive/keyword/method/exception paths. Borrowed buffers reach intents, imported module state, and shared DBL array/scalar-BYREF exports; no runtime opcode or ownership rule changes. COMPUTE.SHA256 adds paired exact-digest and buffer-effect scenarios against pinned CPython hashlib vectors, pending publication, aliasing, invalid shapes/lengths and capability/route refusal; six cached AUDIO rows add paired typed calls and independent PCM/tone stereo samples through the console provider with explicit offline capture, including ownership, stop/release, teardown and failure/admission cases; 83 of 187 rows now have partial success evidence. Paired NET.QUERY_LINK and NET.RESOLVE cases compare complete typed records through the production native provider: 24 status snapshots over six endpoint classes and absent/mounted/withdrawn/recovered states; numeric IPv4/IPv6 resolution and family misses; explicit unsupported SRV/mDNS answers; invalid class, length, UTF-8 and array shapes; exact capability/route refusals; unchanged caller requests and replies while pending; and withdrawal/recovery without replay. No external DNS is contacted. Executing paired Python/BASIC TCP scenarios through the production native provider for OPEN, SEND, RECV, CLOSE, LISTEN and ACCEPT: exact typed requests and bounded payload/status replies; real one-byte binary transfers and EOF; stale/recycled generation isolation; listener replay restricted to listener kinds; accepted children surviving listener closure; explicit unsupported HTTP and port-in-use answers; all six capability, route and pre-submit withdrawal refusals; overlong OPEN/SEND refusal with unchanged caller buffers and no transmitted prefix; a caller SEND request deliberately mutated after submission while its original byte reaches the peer; and pending ACCEPT/RECV withdrawal and recovery, including peer closure before teardown. Grant bytes are current adapter observations, not full canonical grant conformance. OS-assigned LISTEN ports are observed separately and independently verified by successful loopback peer connection. The scenarios run inside the existing sole NET aggregate before cancelled resolver cases; central debug and selected release execution pass. Native POLL/PING/CTL remain unadvertised; 60 paired language/admission-state cases preserve exact refusals and never submit provider work.
Not yet. Full success/failure/effect coverage, Unicode decoding for binary String carriers, dynamic format selectors, and record/object payload adapters remain pending. Compile reachability is not executing parity. Buffer returns, captures, global escapes, owned-function-buffer rebinding and function loop allocations still require an ownership adapter. The canonical NET receipt requires OPEN max_span, latency_class, tls_terminator and host_key_state, LISTEN max_span/latency_class, and ACCEPT peer address/latency_class, but shared net.rs has no authoritative offsets for those grant fields; they remain deferred and no private layout is added. RECV sequence validation, ACCEPT nonblocking flags, WebSocket and other protocol semantics, larger/partial payloads, handle exhaustion, deferred array memory, injected allocation failures, general cancellation and physical targets remain outside this slice. NET.POLL/PING/CTL paired success remains deferred. Only numeric/local loopback peers are used; no external DNS or network timing claim. Shared publication callbacks now release fresh native OPEN/ACCEPT/LISTEN grants after final backing-write rejection while preserving idempotent LISTEN. Four native machine fault tests cover this boundary separately from paired language fixtures; full deferred-memory/transactional I/O semantics remain outside this slice.
Python version: 3.9
dos.libraries · supported in part¶
Works today. hash-bound Python integer support and general published scalar BYVAL, explicit BYREF cells, fixed array mutation
Not yet. Python-authored exports, object/opaque/constant exports, array rebinding ownership and widget adapters pending.
Python version: 3.9
semantics.classes · supported in part¶
Works today. construction, fields, methods, single inheritance, super(), class defaults, shared references, identity, str, bool, isinstance and issubclass; repr and str fallback, len and truth fallback, inherited protocol dispatch, catchable missing length and invalid protocol results, nonnegative/macOS signed 64-bit length validation; list repr rereads current length and dictionary repr uses live insertion ordinals after element formatting; bound user-method values and class-level function access, inherited/super binding and shared ownership of method/receiver cycles. First-class user classes and object retain stable identity, aliases, parameters, constructor calls, truth/callable behavior and read-only name/module metadata. Class names are scoped per module; imported bases, class attributes and method callbacks preserve defining globals. Class-valued locals shadow global class names. Type-name observations cover user instances and class values. User instances implement call through class-level lookup, including inherited methods and callable class values; implicit calls ignore instance-only call fields. Existing special protocols share nearest-class binding precedence. Class-slot protocols add ordinary iter/next and synchronous enter/exit, with inherited lookup and instance-field bypass; builtin exception class identities have limited observations. Ordinary class index methods use inherited class-slot lookup, ignore instance-only special attributes, convert once and preserve raised exception identity. Supported non-integer returns and missing/noncallable slots produce catchable TypeError. This conversion is enabled only for bin(), oct(), hex() and chr().
Not yet. Stable field types; top-level classes; no general descriptors, class rebinding, arbitrary special methods, dynamic attributes or subclasses of builtin types. Default address-bearing repr and dynamic type names for invalid exception/D/OS protocol results remain pending. Dictionary representation retains the existing stable-insertion-ordinal limitation: CPython hash-table compaction-specific mutation behavior is not claimed. Unbound method calls still require an instance of the declaring class; arbitrary duck receivers remain pending. Instance fields may shadow methods when their stored and fallback representations are compatible; mixed field/method representations are diagnosed. Mutating class metadata, first-class builtin types beyond existing adapters, class repr, qualname/bases/namespace reflection and adding class defaults to instance-only fields after specialization remain pending. Inherited class-attribute shadow creation is diagnosed; mutate attributes initialized in the defining class body. Replacing a method with a field or the reverse inside a class definition is diagnosed. Callable class-value delegation retains a compiler depth bound of 128.
Python version: 3.9
Test programs: classes.py, type_checks.py, object_protocols.py, representation_mutation.py, bound_methods.py, class_exports/main.py, iterator_protocols.py, context_managers.py, index_protocols.py
semantics.descriptors · not yet¶
Not yet. Descriptor protocol and binding
Python version: 3.9
semantics.metaclasses · not yet¶
Not yet. Class construction and metaclass protocol
Python version: 3.9
semantics.multiple_inheritance · not yet¶
Not yet. MRO and super
Python version: 3.9
semantics.collections · supported in part¶
Works today. homogeneous mutable lists, negative indexing, assignment, iteration, identity/equality, membership, append, clear, copy, extend, reverse, concatenation and alias-preserving list +=, independent slice copies; immutable mixed tuples, tuple return values/nested unpacking, literal mixed-tuple indexing, homogeneous tuple iteration/dynamic indexing, concatenation and equality; list insert/pop/remove/count/index, shallow list copying, construction/extend/+= from supported typed tuples, strings, bytes, mappings/views and sets; list item deletion and boolean subscript indices, boolean literal indexing of mixed tuples, catchable untyped-empty-list access/assignment/deletion errors; tuple membership through supported equality, nested compatible list values and nested equality; boolean/integer equality in list search and equality; identity-preserving tuple(existing_tuple) and range-to-list conversion; lexicographic tuple ordering for supported scalar/tuple fields and prefix lengths; list equality traverses supported non-callback element chains once; starred list/set displays consume supported iterable adapters in expression order; fixed tuple/literal-list expansions preserve mixed tuple fields and saved argument carriers; Stable in-place list.sort() over supported homogeneous lists and total-order scalar/tuple keys, with alias identity, None result and guarded key-time mutation/exception restoration. list construction, extension and membership consume ordinary class iterables through the shared iterator adapter.
Not yet. Mixed list elements, cyclic containers, tuple views/slices/general iterable conversion, mixed tuple dynamic indexing, slice assignment and remaining collection methods are pending. An empty list cannot gain its first inferred element type after a representation-dependent use in a loop or cached function; whole-scope inference is pending. Mixed-type lookup arguments and remaining iterator/length-hint protocols remain pending. List insert/pop follow the pinned macOS signed 64-bit Py_ssize_t bounds; cross-target boundary validation is pending. Dynamic tuple shapes and starred assignment targets remain diagnosed; assignment from expanded literal elements currently needs a fixed shape.
Python version: 3.9
Test programs: lists.py, slicing.py, tuples.py, list_methods.py, sequence_iteration.py, container_rebinding.py, membership.py, ranges.py, sorting.py, display_unpacking.py, list_sort.py, iterator_protocols.py
semantics.mappings · supported in part¶
Works today. homogeneous ordered dictionaries on the shared object heap; immutable scalar/tuple keys; lookup, assignment, deletion, membership, equality/identity, repr/len/truth, live keys/values/items views, iteration and list snapshots; copy, clear, get/setdefault with matching explicit defaults, pop, popitem, update, keyword and tuple-pair construction, mapping literal unpacking. dictionary pair construction/update consume supported ordinary class iterables and preserve partial updates on errors.
Not yet. Mixed key/value types, general hashing/object keys, optional tagged get results, fromkeys, union operators, view equality/set operations and remaining iterable/keys protocols remain pending. Empty mapping types must be known before representation-dependent repeatable code. Same-size structural mutation during iteration follows stable insertion ordinals; CPython hash-table compaction-specific behavior is not claimed. Lookup is linear; no hash-table performance claim. Class sources with keys diagnose until the mapping protocol adapter is implemented. Malformed iterator-pair length raises ValueError, but exact element-index/actual-length message text remains pending.
Python version: 3.9
Test programs: dictionaries.py, dictionary_views.py, dictionary_construction.py, iterator_protocols.py
semantics.sets · supported in part¶
Works today. homogeneous set/frozenset literals and conversion from supported lists, tuples, strings, bytes, mappings and views; membership, len/truth/representation, comparisons, algebra, mutable in-place operators, copy, add/remove/discard/pop/clear, update, union/intersection/difference/symmetric-difference methods, subset/superset/disjoint checks, iteration and scoped comprehensions; direct character/byte consumption for text construction and update, avoiding an intermediate list; streamed range construction and update; starred list/set displays consume supported iterable adapters in expression order; fixed tuple/literal-list expansions preserve mixed tuple fields and saved argument carriers. set/frozenset construction and set.update consume supported ordinary class iterables.
Not yet. Mixed element types, general object/frozenset hashing, general type reflection, remaining iterator/length-hint protocols and iterator-backed short-circuit set methods remain pending. Structural mutation during iteration has no ordering guarantee. Whole-scope inference is still needed for empty containers. Set operations currently use mapping storage and bounded ordinary DBC loops; no hash-table performance claim.
Python version: 3.9
Test programs: sets.py, ranges.py, display_unpacking.py, iterator_protocols.py
semantics.comprehensions · supported in part¶
Works today. scoped list, set and dictionary comprehensions, nested generators, range/list/tuple/dictionary/view/set iteration and filters; tuple elements and tuple targets; dictionary keys evaluated before values; one-clause synchronous generator expressions with eager outer iterator creation and lazy target/filter/element evaluation. eager comprehensions consume ordinary class iterables; generator expressions acquire their outer iterator eagerly and catch source exhaustion only around the source step.
Not yet. Async iteration and multi-clause generator expressions remain pending; generator expressions inherit the documented lexical-scope and inference limits in semantics.generators.
Python version: 3.9
Test programs: lists.py, tuples.py, dictionary_views.py, sets.py, generator_expressions.py, iterator_protocols.py
semantics.exceptions · supported in part¶
Works today. builtin exception objects, raise, re-raise, try/except/else/finally, assertions, catchable zero division and list bounds, recursive unwinding; zero/one immutable scalar or recursively immutable tuple argument, correct KeyError formatting, missing dictionary keys, mapping iteration size changes and tuple immutability/unpacking failures. builtin exception class identity/equality, truth, display and name/module observations support context exit arguments; nested-finalizer lowering preserves newly emitted outer-catch jumps before scope truncation.
Not yet. No traceback/chaining introspection, user exception subclasses, arbitrary constructor arguments or general translation of D/OS refusals. Uncaught exception ABI v1 reports type via HALT status; CLI reports type without full traceback/message. Exception .args reflection remains pending. Saved exception-class construction/raise, dynamic exception matching/subclass checks and mixed user-object equality require separate adapters; identity comparisons remain supported.
Python version: 3.9
Test programs: exceptions.py, recursion.py, dictionaries.py, dictionary_construction.py, tuples.py, context_managers.py
semantics.context_managers · supported in part¶
Works today. Prepared synchronous with lowering for class-defined inherited enter/exit, multiple managers, supported as targets, ordered entry/exit, suppression, exception identity, bare re-raise, and return/break/continue cleanup through existing Python catch/finalizer machinery. Normal exit ignores the result without truth testing; exceptional exit uses the real exception and builtin exception class identity. Imported defining-module globals and closure target scope are preserved.
Not yet. Four ordinary positional exit parameters; the fourth traceback parameter must be unobserved, including nested closures/defaults/keywords/comprehensions. It is eliminated with its argument, never replaced with a fake traceback. The read check is conservative under shadowing. Dynamic slots, method decorators, variadic exits, async with, contextlib/open and general iterable/starred target unpacking remain pending. Existing static result/definite-assignment limits may require initialized names and compatible fallback returns. Saved exception-class calls/raise, dynamic exception matching, user exception subclasses, traceback/chaining reflection and user-object equality dispatch remain diagnosed. Terminal D/OS refusals remain distinct; Python cleanup does not intercept them.
Python version: 3.9
Test programs: context_managers.py
semantics.closures · supported in part¶
Works today. Nested functions and lambdas have fresh identity, per-definition defaults, shared typed lexical cells, nonlocal reads/writes, late binding in ordinary loops, multi-level captures and captured receivers. Recursive nested functions retain their own cell and use ordinary DBC CALL/ENTER/LEAVE frames and the existing 128-call recursion limit. Closures pass through typed containers and instance fields and can retain GUI state across lifecycle events through ordinary factory functions.
Not yet. Captured variables must currently be definitely initialized before closure creation, except a nested function self-reference. Forward/mutual closure bindings, deleted/unbound-cell timing (including captured exception targets), type/target changes, closure definitions directly inside comprehensions or decorated lifecycle handlers, implicit class/super cells, annotations/decorators, function-valued class descriptors and closure/default/code reflection remain pending. Global and nonlocal declarations must precede other statements in their scope. Per-activation shadow value slots currently duplicate cell value ownership until frame exit.
Python version: 3.9
Test programs: closures.py
semantics.generators · supported in part¶
Works today. Synchronous generator expressions with one or more for clauses and any number of filters over supported lazy iterator sources. Outer iterable evaluation and iterator creation are eager; target assignment, filters and elements are lazy. Each inner iterable and iterator is acquired lazily after its parent target and filters, and exhausted inner cursors release before advancing the parent. Targets remain shared across all resume levels; independent generators, repeated target names with compatible types, escaped lambdas and nested generators preserve Python evaluation order. Shared iterator identity and latched exhaustion, live supported source mutation, captured enclosing lexical cells, defining-module globals and method receivers, persistent generator target cells across resumes (including yielded lambdas, filtered escaped closures and nested generator expressions), preserved Python exception identities, and StopIteration escaping a target/filter/element becomes RuntimeError. Failed or exhausted generators release internal sources, closure environments and exhaustion sentinels; escaped values retain their own shared cells. Class iterator sources use the same eager outer acquisition and source-only StopIteration boundary.
Not yet. Generator functions/yield/yield-from, async, send/throw/close, unsupported iterator/length-hint protocols, general frame/code/cause/traceback reflection, mixed dynamic result types and general dynamic iterator-type rebinding remain pending. Globals or captured values required by a nonempty generator must currently be initialized before construction; direct self-reentrant examples depending on an uninitialized generator binding are diagnosed, so the running guard has no executing self-reentrant receipt yet. Generator expressions inside eager comprehensions/lifecycle handlers inherit explicit lexical-scope diagnostics. Unknown-empty source lists retain existing inference guards.
Python version: 3.9
Test programs: generator_expressions.py, iterator_protocols.py, generator_clauses.py
semantics.modules · supported in part¶
Works today. Direct application execution initializes ordinary name, doc, package and spec globals when referenced; name is main, package/spec are None, and doc is the leading docstring or None. Entry guards, local/closure shadowing and compatible global writes work in console and GUI initialization. Function/method/closure module snapshots preserve the defining global name after later rebinding and after default evaluation. Sibling source modules link into the same DBC application through a filesystem-independent resolver. Unconditional top-level import/from-import, aliases, dependency order and once-only initialization work; module values preserve identity/truth and live attributes, while from-import copies bindings. Separate defining globals, defaults, functions and closures survive cross-module calls, callbacks and exceptions. Imported name/doc/package are available; package is the empty string for flat modules. Native GUI state can live in an imported module. User classes export as first-class identities; aliases and constructor parameters, class fields, defining module/name metadata, imported single inheritance and bound/unbound method callbacks preserve module ownership. Local class-valued parameters and assignments shadow same-named global classes. Native GUI models can be defined in another source module. Circular imports and self-imports reuse the partially initialized namespace; functions can read later definitions when invoked after initialization. Explicit import main shares the entry namespace and metadata. Importing the entry filename instead creates a distinct regular module. Regular packages and subpackages use init.py, parent-first initialization, child binding after successful initialization, dotted imports/aliases, relative imports and from-package child loading. Existing attributes take precedence over same-named child candidates, including invalid unused source. The entire from-list resolves before names bind. Cached partial children are available to from-imports during cycles. Package and child metadata preserve qualified names. CLI package initializers take precedence over same-named .py files; diagnostics retain actual initializer/child paths.
Not yet. Namespace packages, wildcard/conditional/function-local imports, import retries, sys.modules mutation/reload, import hooks, standard/native libraries remain pending. Missing sources/attributes and unsupported import forms are compile diagnostics, not catchable import errors. Imported spec, file, loader, path, module repr, dynamic namespace/type changes and general module reflection need adapters. Reading a partially initialized module attribute too early is a located compile diagnostic; function/class rebinding and dynamic dispatch remain limited. Imports after changes to package/path, child initialization that replaces an incompatible package binding, and missing attributes handled by module getattr are diagnosed; dynamic resolution is pending. Optional package-child candidates are discovered eagerly, though unused candidate errors and initialization are omitted.
Python version: 3.9
Test programs: module_environment.py, class_exports/main.py, circular_modules/main.py
semantics.async · not yet¶
Not yet. Coroutine/await protocol on the shared scheduler
Python version: 3.9
semantics.reflection · not yet¶
Not yet. Dynamic attributes, globals/locals, introspection
Python version: 3.9
semantics.dynamic_imports · not yet¶
Not yet. Checked runtime module loading
Python version: 3.9
builtins.remaining · not yet¶
Not yet. Implement remaining builtin APIs retained in builtins.json and their executing oracle cases
Python version: 3.9
stdlib · not yet¶
Not yet. Module-by-module compatibility inventory
Python version: 3.9
dos.packages · supported in part¶
Works today. shared DPK2 metadata, derived capabilities, DBL artifacts and developer sealing; host NOR-medium installation, reopened-store execution, placed DBL resolution and tamper/removal refusal; source/DBC CLI packaging with the shared raw 32-byte seed or 64-byte secret-key reader; strict developer-key validation and shared DPK2/DLC2 admission checks for console and GUI faces, mismatched and stale catalog authority; source/DBC CLI metadata can include existing resource formats and icon faces, resolved relative to metadata, emitted as canonical RES.DRD/manifest bytes, and preserved across console/GUI faces and unsigned/developer seals. Input alias protection includes assets, metadata, key, source/imported modules and DBLs, including macOS symlink/hardlink aliases. Asset bytes and decoded icons have a cumulative retained bound under the existing 262,144-byte package ceiling; complete output is staged before replacement. Four resource CLI tests and the shared icon decoder regression pass
Not yet. Python schema authoring and product platform launch integration remain pending; associations are available through the pure API only. Bundling resources does not install a RESOURCE provider or implement installed launcher icons/lifecycle. Installed-catalog authority in admission tests is explicitly scripted; neither language CLI supplies a production installed-application catalog authority. The development DOBJ schema store does not fill that role.
Python version: 3.9
dos.widgets · not yet¶
Not yet. Shared widget DBL adapters
Python version: 3.9
dos.intent_parity · supported in part¶
Works today. All 25 registered MATH rows have paired native success scenarios: 36 independently specified scalar cases cover 19, an array/capability/evaluation scenario covers four, and random-state operations cover two. Scalar calls compare exact DBCT argument/result spans; array calls compare complete authorized element types, bounds, bytes and alias relationships before/after the production provider, with source assertions for committed writes. Random-state calls preserve exact paired results, existing D/OS normative prefix values, repeat/reseed behavior and distinct seed effects. Every run has the expected terminal status and zero objects/strings/arrays. Paired failures cover division by zero, conversion overflow/inexactness, invalid selectors, absent routes/features and one-byte provider scratch exhaustion. The registry-joined MATH gate requires a paired success fixture for each new MATH row. Graphics adds 19 calls covering all 11 advertised native GFX rows, exact input buffers and independent 32x32 pixel/publication checks with frame journaling on and off. Nine invalid-argument scenarios preserve refusal and no-publication behavior; denied capability and one missing exact route refuse before provider submission. Three negative controls detect changed arguments with equal pixels, changed colors and omitted drawing. The executing-coverage ledger joins all 187 names to the actual scenario groups. All 24 UI rows have paired success evidence: 22 through the production native composite provider with five independent canvas frames; SET_GRID/SET_TABLE through the production shared dispatcher and native GFX sink with direct owned-state observations after caller arrays change. String arrays are read only through typed content authority, never private handle bytes. Ten invalid/stale/cycle cases and an unavailable exact route preserve refusals; invalid table style preserves prior text/style, and node/byte grants enforce capacity. A paired Button-kind scenario restores the independently specified full unpressed pixel frame after a press/release. Eight basic FILE rows have 22 paired transactions with independently specified complete request/reply bytes, array effects and filesystem snapshots: query/list/stat, staged open/write/close, simultaneous reading, cancel/commit, rename, mkdir and delete. Twelve malformed/path/absent/stale cases and handle exhaustion preserve original bytes and clean up unpublished staging. COMPUTE.SHA256 adds pinned hashlib vectors and paired buffer, publication and refusal checks. Six cached AUDIO rows add paired typed calls and independently calculated PCM/tone samples through the shared console provider, with ownership, stop/release, teardown and failure/admission cases. Paired NET.QUERY_LINK and NET.RESOLVE cases compare complete typed records through the production native provider: 24 status snapshots over six endpoint classes and absent/mounted/withdrawn/recovered states; numeric IPv4/IPv6 resolution and family misses; explicit unsupported SRV/mDNS answers; invalid class, length, UTF-8 and array shapes; exact capability/route refusals; unchanged caller requests and replies while pending; and withdrawal/recovery without replay. No external DNS is contacted. Executing paired Python/BASIC TCP scenarios through the production native provider for OPEN, SEND, RECV, CLOSE, LISTEN and ACCEPT: exact typed requests and bounded payload/status replies; real one-byte binary transfers and EOF; stale/recycled generation isolation; listener replay restricted to listener kinds; accepted children surviving listener closure; explicit unsupported HTTP and port-in-use answers; all six capability, route and pre-submit withdrawal refusals; overlong OPEN/SEND refusal with unchanged caller buffers and no transmitted prefix; a caller SEND request deliberately mutated after submission while its original byte reaches the peer; and pending ACCEPT/RECV withdrawal and recovery, including peer closure before teardown. Grant bytes are current adapter observations, not full canonical grant conformance. OS-assigned LISTEN ports are observed separately and independently verified by successful loopback peer connection. The scenarios run inside the existing sole NET aggregate before cancelled resolver cases; central debug and selected release execution pass. Native POLL/PING/CTL remain unadvertised; 60 paired language/admission-state cases preserve exact refusals and never submit provider work.
Not yet. The executing ledger covers 83 of 187 rows with partial scenarios and 104 deferred rows. No row is claimed fully conformant. Seven GFX rows lack native success evidence. Broader numeric/array/graphics boundaries, stale handles, deferred memory/completion/cancellation and remaining domains need coverage. Array observations use immediate hosted memory and normalize only allocation identity through authorized alias checks; compiler-specific scalar adapter calls are outside that comparison. The native frame journal reports invalid buffered scalar records when PRESENT flushes them; direct mode reports the original row, and tests preserve this configuration-specific result. Physical-target evidence remains pending. UI success-row coverage does not cover every widget kind or all geometry/text/style boundaries. Grid/table raster output is compared across languages with independently expected owned state; an independent full glyph raster oracle is still pending. FILE resource/store success scenarios, broader paging/path boundaries and deferred transport remain pending; host rename publication is not power-loss durability. The canonical NET receipt requires OPEN max_span, latency_class, tls_terminator and host_key_state, LISTEN max_span/latency_class, and ACCEPT peer address/latency_class, but shared net.rs has no authoritative offsets for those grant fields; they remain deferred and no private layout is added. RECV sequence validation, ACCEPT nonblocking flags, WebSocket and other protocol semantics, larger/partial payloads, handle exhaustion, deferred array memory, injected allocation failures, general cancellation and physical targets remain outside this slice. NET.POLL/PING/CTL paired success remains deferred. Only numeric/local loopback peers are used; no external DNS or network timing claim. Shared publication callbacks now release fresh native OPEN/ACCEPT/LISTEN grants after final backing-write rejection while preserving idempotent LISTEN. Four native machine fault tests cover this boundary separately from paired language fixtures; full deferred-memory/transactional I/O semantics remain outside this slice.
Python version: 3.9
performance · supported in part¶
Works today. initial macOS measurements
Not yet. Representative budgets and GUI latency under compute/allocation stress remain pending; no 30 KB claim.
Python version: 3.9
builtins.type_checks · supported in part¶
Works today. isinstance/issubclass for known user classes, object, type, int/bool/float/str/bytes/list/tuple/dict/set/frozenset/range; nested tuple alternatives, named class-object checks, argument evaluation order and lazy catchable TypeError First-class user/object class values, including module attributes and nested class-info tuples, are accepted by isinstance/issubclass; class values are instances of type. builtin exception-class values retain canonical identity, are callable, and satisfy isinstance(value, type); saved construction and dynamic matching are not added.
Not yet. Remaining first-class builtin types, dynamic exception type hierarchy, metaclass hooks and standalone/dynamic type() results remain pending. Named type checks do not imply those constructors are fully implemented.
Python version: 3.9
Test programs: type_checks.py, ranges.py, class_exports/main.py, context_managers.py
semantics.ranges · supported in part¶
Works today. immutable range values with arbitrary integer fields; preserved CPython 3.9 boolean attributes/representation; len/truth, equality/identity, int/bool membership/count/index, arbitrary-integer subscripts and slicing, repeatable iteration, comprehensions, list/set adapters and immutable mapping/set keys; reversed() derives lazy endpoints with arbitrary arithmetic even beyond the macOS length limit
Not yet. Custom index, float/custom equality lookup, hash protocols, full invalid-argument translation and rebinding across different boolean-attribute shapes remain pending. len uses the pinned macOS signed 64-bit ssize_t boundary. Mapping/set keys use existing linear lookup, not a hash-table adapter.
Python version: 3.9
Test programs: ranges.py, reversed.py
builtins.boolean_reductions · supported in part¶
Works today. all()/any() over supported lists, mixed fixed tuples, strings, bytes, mappings/views, sets/frozensets and ranges; empty results, ordered truth calls, short-circuiting, errors and live mutation behavior; captured bool builtin aliases and filter(bool, ...) use the same truth protocol, with selected type/name/module and name-shadowing observations. all/any consume supported ordinary class iterators while retaining short-circuit truth/error behavior.
Not yet. Remaining iterator/length-hint protocols and full invalid-argument exception translation remain pending. Untyped empty shapes retain conservative inference guards in repeatable code.
Python version: 3.9
Test programs: reductions.py, ranges.py, filter.py, iterator_protocols.py
builtins.numeric_reductions · supported in part¶
Works today. sum() over supported iterables with positional/keyword start, non-mutating list addition, catchable forbidden text/bytes starts; min/max with multiple arguments or a supported homogeneous iterable, compatible default, key=None or supported function, closure, bound-method or user-object callbacks, once-per-item keys, first-wins ties, catchable empty ValueError and arithmetic extrema of huge ranges; supported tuple keys retain lexicographic ordering. sum/min/max consume supported ordinary class iterators using the existing typed reduction adapters.
Not yet. Remaining iterator/length-hint protocols, dynamically changing callable types, mixed result types and custom arithmetic/comparison protocols remain pending. Variable-length sum inputs require a stable result representation; float sums require an explicit float start. Dictionary-item tuple ordering and complete invalid-call exception translation remain pending.
Python version: 3.9
Test programs: summation.py, extrema.py, extrema_keys.py, sorting.py, iterator_protocols.py
semantics.iterators · supported in part¶
Works today. Lazy iter/next over homogeneous lists/tuples, Unicode strings, bytes and arbitrary ranges; existing iterator identity; enumerate and zip over these sources; correct cursor sharing, list mutation, stable source exhaustion, left-to-right zip consumption including repeated exhausted probes; StopIteration without arguments, compatible next defaults, membership, for/comprehension/reduction/list/set/dict-pair adapters and streaming list extend/+=; direct iter/next and selected iterator type names; lazy reversed sequences preserve list mutation/exhaustion behavior, Unicode scalars, unsigned bytes, element references and captured lifetimes; reversed retains its builtin type identity in supported type/isinstance/issubclass observations; generator expressions with one or more synchronous for clauses resume captured DBC procedures with persistent target cells, source sharing, latched exhaustion and Python-error cleanup; lazy filter captures source/predicate once and yields original items through existing iterator consumers, with eager source iterator creation, shared cursors, callback truth protocols and resumable predicate errors. Direct next preserves a predicate StopIteration instance; consuming iteration stops that pass without permanently closing filter. Ordinary class iter/next methods use inherited class-slot lookup, ignoring instance-only special methods. Public iter returns the original class or builtin iterator object and next calls only next, preserving direct StopIteration and other exception identity/message, next(default), repeated probing and continuation. For/comprehensions/filter/enumerate/zip/generator expressions/list/sorted/min/max/sum/all/any/membership/list.extend/set.update/dict pair update use shared adapters; tests cover evaluation order, reentry, generator late binding, partial mutation, defining-module globals and bounded cleanup. Invalid iter result, missing methods and non-callable next slots are catchable TypeError where representable. Non-callable/missing next slots preserve catchable TypeError even with a differently typed default; generator source StopIteration ends generation while body StopIteration remains outside the source-step catch. Lazy map acquires supported iterators eagerly and applies retained callbacks lazily after ordered source advancement; source/callback exceptions retain identity and permit later continuation, and repeated exhausted probes preserve earlier input effects. See builtins.map for its inference, ownership and protocol limits.
Not yet. Sequence getitem fallback, callable-valued class-slot descriptors, mapping/view/set iterator sources, callable/sentinel iteration, mixed tuple results, next defaults requiring tagged unions, iterator type objects, range-iterator type-name width selection, length hints, saved builtin bound methods and broader reflection remain pending. An iterator over an untyped empty list freezes its unknown element shape. Iterator-backed set intersection/intersection_update/issuperset/isdisjoint receive diagnostics until their short-circuit adapters exist. List lookup remains linear in its linked storage; this is not a hash-table or constant-time list-iteration claim. Custom reversed, mapping reversal and mixed tuple reversal remain pending. Reverse iterators over an initially empty list permit later appends at top level but retain inference guards in repeatable code. Filter-specific protocol, representation and reflection limits are recorded in builtins.filter; its focused cases execute in DBC. No sequence getitem fallback, callable/sentinel iteration, async protocols, dynamic item/default union carriers, callable-valued class-slot descriptors or broad dynamic class mutation. len/length_hint materializations diagnose until hint timing and exception suppression are implemented. Dictionary class sources with keys and membership with contains slots diagnose rather than ignoring those protocols. Existing short-circuit set-method iterator gaps extend to class iterables. Runtime-varying next result types, unbound captures and recursive next without a concrete inferred return retain explicit compiler limits. General tuple() conversion, iterator repr/reflection and terminal D/OS refusal recovery are not added. Exception .args/cause/traceback reflection remains separate. The inherited dict_pair adapter raises ValueError for malformed tuple length but lacks CPython element-index/actual-length message text; exact malformed-pair diagnostics are not claimed.
Python version: 3.9
Test programs: iterators.py, reversed.py, generator_expressions.py, filter.py, iterator_protocols.py, generator_clauses.py, map.py
builtins.filter · supported in part¶
Works today. Lazy filter over existing supported iterator sources, retaining original source and predicate arguments evaluated once in order. None and supported function/closure/bound-method/callable-object/bool predicates use existing truth protocols; original items and identities are yielded. Predicate and truth errors consume that item but permit continuation. Direct next preserves the original StopIteration instance and arguments; iteration consumers and next(default) stop that iteration without closing filter. Nested wrappers retain CPython repeated exhausted zip effects. Source iterator creation is eager. Shared cursor identity, defining-module callbacks, reentrant predicates, object retention/cleanup and selected filter builtin type observations are covered by executing tests. filter acquires an ordinary class source iterator eagerly and calls its next slot lazily through the existing source-step adapter.
Not yet. Remaining dynamic class-slot protocols and mapping/view/set iterator sources, mixed iterator item carriers, dynamic predicate rebinding, broad dynamic argument unpacking, full catchable argument-binding errors, general filter type reflection/subclassing/repr/reduce and unsupported predicate/result type-name adapters remain explicit gaps. Unknown-empty list inference keeps existing diagnostics. Terminal D/OS refusals end the run.
Python version: 3.9
Test programs: filter.py, iterator_protocols.py
builtins.sorting · supported in part¶
Works today. Stable sorted() over supported homogeneous iterable snapshots, scalar or tuple keys, key=None or supported callables including closures, bound methods and user callable objects, once-per-item keys in input order, reverse stability and checked signed-32-bit integer reverse conversion. Preserves original inputs and item identities, consumes sources before keys, propagates key exceptions, and exposes a saved sorted builtin alias. Linked bottom-up merge passes use native bounded counters and ordinary billed DBC instructions. Fixed tuple/literal argument unpacking is supported. In-place list.sort() reuses this stable sorting engine, preserves shared list identity, returns None, captures the receiver before keyword effects, evaluates keys once in original order while aliases see the temporarily empty list, restores original order on Python key exceptions, restores sorted order before reporting ValueError for mutation, and preserves outer mutation state across nested sorts. Mutation includes growth followed by removal and CPython generic-empty extension behavior; exact empty list/tuple extension remains a no-op. sorted consumes supported ordinary class iterators before evaluating keys.
Not yet. Float/NaN, sets and custom partial orders, mixed dynamic keys/results, remaining iterator/length-hint protocols and dynamically changing callable types, index reverse objects, full invalid-argument exception translation, dynamic call-site unpacking and builtin type reflection remain pending. Auxiliary key nodes consume existing shared-pool capacity; no larger memory grant is implied. Saved list.sort method objects, list.sort descriptor calls, dynamic method argument unpacking and full invalid-key translation remain pending (typed-empty non-callable keys are diagnosed despite CPython skipping the call). Python-level sort restoration is covered; terminal D/OS refusals still end the run. Homogeneous element inference guards remain in repeatable code.
Python version: 3.9
Test programs: sorting.py, call_unpacking.py, list_sort.py, iterator_protocols.py
builtins.integer_formatting · supported in part¶
Works today. bin(), oct() and hex() over arbitrary signed integers and booleans, preserving standard prefixes, lowercase digits and signs; first-class builtin aliases, fixed call unpacking and round trips through int(text, base). Ordinary class index methods use inherited class-slot lookup, ignore instance-only special attributes, convert once and preserve raised exception identity. Supported non-integer returns and missing/noncallable slots produce catchable TypeError. This conversion is enabled only for bin(), oct(), hex() and chr().
Not yet. Bool-returning index methods require a DeprecationWarning adapter for the pinned CPython 3.9.6 behavior; ordinary scalar booleans remain supported. Callable-valued slots/descriptors, dynamic class changes, unsupported return representations and other custom-index consumers remain diagnosed or deferred. Invalid non-object scalar calls, full call-shape exception translation and broader builtin reflection remain pending. Output strings retain the shared DBC string and memory limits.
Python version: 3.9
Test programs: integer_formatting.py, index_protocols.py
builtins.input · supported in part¶
Works today. Console input() uses shared CONSOLE.READ_LINE_RESULT, minimum service 1.0.1.22, with the same macOS endpoint as d/BASIC. Zero or one positional prompt, existing str protocols, eager argument evaluation, exact LF removal, empty lines, CR/NUL/valid Unicode and final unterminated lines execute. Only canonical EOF raises builtin EOFError. Host/storage/version/capability refusals retain all original fields. Pending input and deferred allocation preserve one read and publish the result pair together.
Not yet. GUI input producer/cancellation, configured or replaced streams, readline/history/auditing, surrogate strings, broader argument/descriptor protocols and full Python output I/O exception fidelity remain deferred. Undecodable UTF-8 raises an explicit NotImplementedError for the missing surrogateescape representation. The shared 65,535-byte string ceiling refuses larger lines instead of matching CPython unbounded input.
Python version: 3.9
Test programs: input_calls.py
builtins.map · supported in part¶
Works today. Lazy map over supported sources, with all argument expressions evaluated once before eager ordered iterator acquisition. Each request advances sources left to right and applies the retained callback only after every source provides an item. The shortest source stops that request; earlier inputs retain partial advancement and are probed on subsequent attempts. Functions, closures, supported builtin callbacks, bound methods, inherited callable objects and class constructors use existing typed calls. Original source/callback Python exception identity and continuation, defining-module globals, mutable sources, object results, selected builtin/type observations and shared ownership are covered by the executing focused suite. Repeated direct lists with the same concrete element carrier share iterator owner layouts while retaining independent cursors and list aliases.
Not yet. Callback results must have a concrete representation inferred at construction; recursive map-self references, mixed or dynamically changing carriers and unsupported callback binding remain diagnosed. Mapping/view/set sources, remaining class-slot/descriptor/sequence/length-hint/async protocols, dynamic unpacking, tagged next defaults, general reflection/repr/reduce/subclassing and direct dos.array callback/result ownership remain deferred. Existing shared memory, string, frame and consumer limits apply; no timing or full map-conformance claim.
Python version: 3.9
Test programs: map.py
builtins.pow · supported in part¶
Works today. Integer/boolean two-argument powers with nonnegative exponents and optional None modulus; signed nonzero integer/boolean modular powers using square-and-multiply with reduction per product. Dynamic integer exponents, fixed argument expansion and keywords, saved builtin aliases, closures, callback composition and original Python exception identity execute. Zero modulus raises ValueError; zero base with negative exponent preserves pinned CPython conversion-overflow/ZeroDivisionError order. Unit modulus returns zero even for negative exponents.
Not yet. Other negative exponents require floating-result or modular-inverse adapters and raise explicit builtin NotImplementedError. Float/complex results, custom numeric/power protocols, general dynamic call binding and repeated keyword merges remain diagnosed. Existing shared string, memory, frame and intermediate-product limits can refuse larger inputs; no full-carrier or deadline claim. Existing binary ** lowering retains its prior independent restrictions.
Python version: 3.9
Test programs: pow.py
How this table is kept honest¶
Every entry above is checked by tests against real CPython and against d/Python before it changes. A feature is never moved to "works" because it compiles; it has to run and print the right answer.