Known issues in beta 0.1 "Blaise"

These are the problems we know about in the beta 0.1 compiler, pin v452 (commit 53dbb01c15, compiler sha256 7ff6198e28a1…). Each row says which compiler it was measured with. Rows measured on the earlier draft pin v425 say so; nothing in this release is known to have changed them.

Problems that compile and silently give a wrong answer come first, because a refusal at least tells you something is wrong.

At a glance

Every open issue on this page, one line each. The rows below give the details, the measurements and the workarounds.

Silently wrong: compiles, and gives a wrong answer with no message

Stops at run time

Refused, or not what you expect

Memory

ESP networking

By design

Unresolved: one test row, riscv32 wait4 under QEMU 8.2.2, is described at the start of Fixed since v441.

Silently wrong

One Pascal row comes first. Four more rows that give a wrong answer with no message are Nil Python rows, under Nil Python: arithmetic on None, and three shapes of exec.

Pascal: SetLength past a short string's capacity overruns it

A ShortString holds at most 255 characters and a string[N] at most N. SetLength with a larger count, held in a variable, does not stop at that capacity, so the loop that usually follows writes past the end of the variable, over whatever the program keeps next to it, and can crash:

program overrun;
var
  t: string[10];
  guard: Integer;
  n, i: Integer;
begin
  guard := 777;
  n := 50;
  SetLength(t, n);                          { Length(t) is now 50, not 10 }
  for i := 1 to Length(t) do t[i] := 'x';   { writes 40 bytes past t }
  writeln('var ', Length(t), ' ', guard);
end.

Measured on 2026-09-29 on x86-64 with v441 (4ebfa2d047a2) and v451 (d9b7226769cc), which behave the same:

FPC 3.2.2 also lets a string[10] grow to 50 and overwrite its neighbour (the Integer read 30840 there), so for string[N] this is FPC's behaviour too. It is listed because the result is memory corruption.

Workaround: check the count against the string's capacity first: if n > High(t) then n := High(t);. High of a string[10] is 10, and of a ShortString 255, with v451 as with FPC.

Wrong in v441 to v451. Fixed after v451 (5ebf185c24 and e04f41f9d7, in no pin yet): SetLength stops at the capacity. On the compiler built at e04f41f9d7 (a91df2b3a1a8) the program above prints var 10 777, and a count of 50 held in a variable gives 10 for a string[10], 8 for a string[8] record field and 6 for an element of an array of string[6], each with its neighbour unchanged; a ShortString set to 1000, or through a pointer to 300, gives 255, as in FPC. Two answers differ from FPC on purpose: a string[N] stops at N where FPC overruns it, and a negative count gives 0 where FPC gives the count's low byte (251 for -5).

C: long double is 8 bytes

GCC's long double is 16 bytes on x86-64; PXX's is 8, the same as double. A single program is consistent with itself, but a struct that contains one has a different size from GCC's: struct { char c; long double y; } is 16 bytes here and 32 under GCC. That matters as soon as such a struct crosses into GCC-compiled code or into a file format. (Measured with v425, and again on 2026-09-28 with v450 (c19cc2d531e4) and the compiler built at fce510f98d: 8 and 16 bytes, against GCC's 16 and 32.)

Workaround: use double, not long double, in a struct that GCC-compiled code or a file format shares.

riscv32 and Xtensa: arithmetic flushes subnormal doubles to zero

On riscv32 and Xtensa (both ABIs), double arithmetic runs in software (compiler/builtin/softfloat.pas), which flushes subnormal numbers, the values below about 2.2e-308, to zero. Every operation with a subnormal operand returns zero (x * 1.0, x + x, x - 0.0, x / 1.0), and so does every result that would be subnormal (1e-300 * 1e-10). Comparing, copying and storing a subnormal are exact. So if x > 0.0 then y := x * 1.0 can give a zero y for an x the same program found to be above zero. Nil Python's math.frexp(5e-324) gives (0.5, -1086) there, where CPython gives (0.5, -1073). This is the documented behaviour of that software arithmetic, stated in the unit's header, not a crash, and flush-to-zero is a common mode on small devices. x86-64, i386, arm32, aarch64 and wasm32 use the hardware or host arithmetic and keep subnormals. Measured on 2026-09-28 with v450 (c19cc2d531e4) on x86-64 and under QEMU user mode for the others (wasmtime for wasm32), with a subnormal built from its bit pattern at run time; the same on riscv32 with v441 (4ebfa2d047a2) and with the compiler built at fce510f98d (f545c8410b32). The ESP32-C3 and ESP32-S3 use these two backends, and with v450 the same program gives the same answers as an ESP-IDF image under Espressif's QEMU on both chips (tools/esp_run.sh); it was not run on a board. If it matters: keep intermediate values above 2.2e-308, for example by working in scaled units. A value that is already subnormal cannot be scaled back up on these targets, because the scaling is itself arithmetic on it.

Stops at run time

ESP: bare-metal images do not run on a real chip

Images built with --esp-profile=bare fault on the first byte access to a global or a string, and their UART output is lost. Measured on an ESP32-S3 with v424; a bare ESP32-C3 image has never been run on silicon. They run under Espressif's QEMU (qemu-system-xtensa and qemu-system-riscv32), which is what the bare profile is for. esptool cannot convert a bare ELF either, since it has no section headers. Workaround: on hardware, build the program as an ESP-IDF component (the default); see ESP32.

Native TLS: most HTTPS sites fail certificate verification

Wrong in v441 to v451. Fixed after v451 (8d0a99417e, in no pin yet); see "After v451" below. TLS 1.2-only servers still fail.

The native TLS 1.3 backend (tls13_native, switched on with Tls13NativeRegister) cannot check an ECDSA signature made with SHA-384, and cannot use a P-384 key. Nearly every public site has one somewhere in its certificate chain, so for most sites the request fails cleanly: Ok is False, and Tls13NativeLastError says certificate chain does not verify to a trusted root (store /etc/ssl/certs/ca-certificates.crt, 121 roots). It fails closed: no connection is accepted that was not verified.

Measured on 2026-09-29 on x86-64 with v451 (d9b7226769cc), from an unpacked release archive, with HttpGet('https://<host>/'):

host native backend OpenSSL backend chain, from openssl s_client
letsencrypt.org fails status 200 ECDSA with SHA-384, P-384 keys
github.com fails status 200 ECDSA with SHA-384 above the leaf
codeberg.org fails status 200 ECDSA with SHA-384, P-384 keys
www.wikipedia.org fails status 403 ECDSA with SHA-384, P-384 keys
cloudflare.com fails status 301 ECDSA with SHA-384 above the leaf
example.com fails status 200 ECDSA with SHA-384, P-384 keys
www.python.org status 200 status 200 RSA with SHA-256 only
docs.espressif.com fails (TLS 1.2 only) status 302 not reached
micropython.org fails (TLS 1.2 only) status 200 not reached

Every host that failed has an ECDSA signature with SHA-384 in its chain, and the one that worked has none. The 403 and 301 are the sites' own HTTP answers; the TLS connection succeeded. The compiler built at c44341534a (81c16b5e3461) fails in the same way on letsencrypt.org and example.com, and gets 200 from www.python.org. Of the 121 roots in that store, 35 have a P-384 key.

The native backend speaks TLS 1.3 only. A server that offers only TLS 1.2 answers its first message with an alert, and the request fails with expected a handshake record, got type 21 (21 is a TLS alert). Both docs.espressif.com and micropython.org did that; openssl s_client -tls1_3 got alert 70 (protocol version) and alert 40 (handshake failure) from them. This is by design for now, not the signature gap above. The signature types x509 understands are listed on Cryptography.

Workaround: on x86-64 (and i386 from v448), use the OpenSSL backend, OpenSslTlsRegister from tls_openssl, built with -dPXX_DYNLIB_LIBC: it completed the TLS handshake with all nine hosts above, verifying each certificate. See Networking. A static program with no C library has no workaround yet.

After v451 (8d0a99417e, in no pin yet), x509 checks ECDSA with SHA-384 and SHA-512, keys on P-384, and RSA with SHA-384 and SHA-512. Measured on 2026-09-29 on x86-64 with the compiler built at 8d0a99417e (553677b94940, with that tree's library), same program, same nine hosts: the six that failed now complete the handshake and give the same status as the OpenSSL backend (200, 200, 200, 403, 301, 200), www.python.org still gives 200, and docs.espressif.com and micropython.org still fail with expected a handshake record, got type 21, because they speak only TLS 1.2. The v451 build, run in the same minute, still failed on letsencrypt.org and example.com. Of the 121 roots in the store, 115 now verify their own signature, against 58 with v451; the six left are five signed with SHA-1 and one on P-521, which x509 still refuses.

Slow on the ESP32-C3. The fix is correct there but slow. Measured on an ESP32-C3 board by the fix's author, after v451: one P-384 signature check takes 22.8 s and one P-256 check 12.1 s, so an HTTPS request to letsencrypt.org spends about 80 s in the TLS handshake. The ESP32-S3 has not been measured. See Cryptography.

Refused, with a message

These do not compile, or compile with a warning. None of them produces a wrong answer silently. (Measured with v425, and again on 2026-09-29 with v451, d9b7226769cc: the __thread warning on riscv32, setvbuf returning nonzero for _IOFBF and _IOLBF and 0 for _IONBF on all five Linux CPUs, and --shared refused on aarch64, arm32 and i386.)

Nil Python

Nil Python is best effort in this beta. It compiles Python-shaped source ahead of time and is not CPython: CPython compatibility is not a goal of this release, and it has a real backlog. Its measured list of limits is kept on the Nil Python page, and the deliberate differences from CPython are recorded beside it. On ESP, the model is MicroPython's assumptions about a small device, such as math errors not halting the program. 15 of 16 common MicroPython drivers compile unchanged (measured with v445); see MicroPython.

Found on 2026-09-29, and open in v441 to v451:

Found on 2026-09-28, and open in v441 to v450 and after it:

Nil Python through ./pxx: import time, import string and import utime find the C headers. The ./pxx wrapper that install.sh writes puts lib/crtl/include on the unit search path, and there Nil Python's import time and import string bind the C headers time.h and string.h instead of PXX's Python modules. time.sleep, time.sleep_ms, time.ticks_ms and string.ascii_lowercase then fail to compile with no member sleep came of the qualifier time (and the same for the others). time.time() still compiles, because C declares time(), and import math is not affected. The same programs compile and run when the compiler is called directly: a program that is only import time and time.sleep(0.01) builds that way but not through ./pxx. import utime fails differently: print(utime.localtime(31536000)) stops at compile time with this build would die at exec: localtime is imported from libutime.so, and prints (1971, 1, 1, 0, 0, 0, 4, 1) when the compiler is called directly (v451, 2026-09-29). Measured on 2026-09-29 on x86-64 with the pinned v450 (c19cc2d531e4), through a checkout's ./pxx (written by tools/install.sh, last changed on 2026-09-25) and directly. Workaround: call the compiler directly (compiler/pxx-<arch> in the release tarball, the pinned binary in a checkout) instead of ./pxx for a Nil Python program that imports time, string or utime. Wrong in v441 to v451. Fixed after v451 (ff6115d2d1, in no pin yet): through a wrapper that runs the compiler built at ff27fe7269 (18dcf7f85d20), time.sleep compiles, string.digits prints 0123456789 and the utime line prints the tuple above.

Nil Python on the ESP32-C3: list.sort() runs out of heap at about half the list length that can be built. On a C3 board, in the nilpy-c3 example project, a shuffled list of integers can be built up to 4,093 elements (4,125 runs out of memory), but sorting it fits only up to 2,031 (2,062 runs out, 2,078 with v450, whose insertion sort did not finish 2,031 elements within the 45-second run, but did not run out of memory either). A list of objects with __lt__ sorts up to 2,037 (2,068 runs out) with both compilers. The limit is the same with v450's insertion sort and with the merge sort that replaced it, so the sort's own index scratch space is not what sets it; sorting needs about as much free heap again as the list itself. The program fails with pxx: out of memory (ESP-IDF heap exhausted). Measured on 2026-09-28 and 2026-09-29 by booting one size at a time, with v450 (c19cc2d531e4) and the compiler built at aefc7ba4bd (1634f6483109); the 4,093 is for the second only. The program, its recipe and the table are in test/esp_board_list_sort_ceiling.npy. Workaround: on a C3, keep a list you sort under about 2,000 elements.

exec and eval

exec and eval run Nil Python source at run time, and accept less than the compiler does. These five rows are where that goes wrong.

Nil Python: a method reached from exec takes the type of its one compiled call, and a float passed to an integer parameter is silently truncated. When every compiled call of a method passes the same kind of value to a parameter with no annotation, the compiler gives that parameter the type (def mi(self, x) called only as n.mi(3) makes x an integer). That is deliberate and makes such calls fast. A call from source compiled at run time, such as exec("def __body__():\n n.mi(2.7)\n", env, ns), cannot be seen at compile time, so its argument is converted to that type rather than passed as is. One of the three results is a wrong answer with no message: a float into an integer parameter is truncated (n.mi(2.7) gets 2, CPython 2.7). The other two are by design: a string into that parameter raises TypeError (CPython passes 'ab'), and an integer into a float parameter arrives as 3.0 (CPython 3), which loses nothing. A parameter whose compiled calls pass different kinds of value is not given a type, and behaves as in CPython. Measured on 2026-09-29 with v450 (c19cc2d531e4) and the compiler built at 6dcfbbb0e0 (9ce84ba69527) on x86-64, and with the latter under QEMU user mode on i386, arm32, aarch64 and riscv32, which print the same. Workaround: annotate a parameter that exec code will call as x: object (or Any). That keeps the compiler from giving it a type, so all three calls print what CPython prints (x86-64, 9ce84ba69527). A scalar annotation such as x: float gives it a type by hand: it stops the truncation, but a string still raises TypeError. Re-measured on 2026-09-29 with the compiler built at f499d25ded (81c16b5e3461) on x86-64 and aarch64: the same as v451, and the object annotation still works.

Nil Python: exec publishes a def only when it is named __body__. After exec("def f():\n return 42\n", {}, ns), ns is empty, and ns["f"] raises KeyError: 'f'. The message names your key, so it reads as a wrong lookup, while the cause is that exec did not store the def. Only a def named __body__ lands in ns; helper, f and __b__ do not. A variable assigned at the top of the executed source is stored: exec("def helper(x):\n return x + 1\nresult = helper(41)\n", {}, ns) gives ns["result"] == 42. Workaround: name the def __body__, or assign the value you need to a variable in the executed source. Measured on 2026-09-29 on x86-64 with v450 (c19cc2d531e4) and the compiler built at 1763b6232b (70e57d59b777), which behave the same.

Nil Python on i386, arm32 and riscv32: exec code calling a method with annotated parameters passes wrong values. With def greet(self, name: str, n: int, flag: bool), the call p.greet('x', 3, True) made from source run by exec prints hi 12884901888 True on i386 (an empty string, and 3 moved up 32 bits) and hi x 12884901888 False on arm32 and riscv32, with no message; x86-64 and aarch64 print hi x 3 True, as CPython does. A parameter without an annotation is affected the same way once the compiler has given it a type from its compiled calls (see the row above on a method reached from exec): after p.plain("y", 4, False) in the program, the exec call prints hi 12884901888 True on i386 and stops with SIGSEGV on arm32. Without any compiled call, or annotated as object, it gets the right values. Measured on 2026-09-29 with v450 (c19cc2d531e4) and v451 (d9b7226769cc), which behave the same, under QEMU user mode. Wrong in v441 to v451. Fixed after v451 (191239f538, in no pin yet): with the compiler built at f499d25ded (81c16b5e3461), on i386, arm32 and riscv32, such a call raises a TypeError that the caller can catch (reflected call to greet is refused: parameter 1 ... is not 64-bit, so the arguments would be misaligned ...) instead of passing wrong values, for the annotated method and for the unannotated one alike; x86-64 and aarch64 still print hi x 3 True. Workaround: on a 32-bit target, annotate the parameters of a method that exec code calls as object (name: object, n: object, flag: object); measured on i386, arm32 and riscv32 with v451, and with the compiler built at f499d25ded, where it gives the right values too.

Nil Python: the parameters of an exec'd __body__ read None. A __body__ defined by exec and called from the program does not receive its arguments: every parameter reads None, with no message. After exec("def __body__(s):\n return s\n", {}, ns), ns["__body__"]("ab") returns None (CPython 'ab'); with two parameters, [a, b] is [None, None] for (1, "x"); n + 1 gives 1 for 41 (CPython 42); and int(s) gives 0 for "ab" instead of raising ValueError. A def nested inside __body__ and returned from it does receive its argument. Measured on 2026-09-29 on x86-64 with v450 (c19cc2d531e4) and the compiler built at 1763b6232b (70e57d59b777), which behave the same. Workaround: give __body__ no parameters and return a nested def that takes them, or pass values in through a variable in the exec globals.

Nil Python: raise inside exec'd code stops the program, while a builtin's error there can be caught. raise ValueError('bad') in source run by exec prints pyeval: ValueError: bad on standard output and exits with status 1; an except ValueError around the call never runs. That raise is not yet catchable there is by design for now: making it catchable is a later step, as the comment on the raise handler in compiler/builtin/pyeval.pas says. A try inside the executed source is not accepted either (pyeval: unexpected token in expression: ":"). An error that a builtin raises is an ordinary exception, and the caller's except catches it: int('ab') gives ValueError in a __body__ and in a def nested in it, and [1][5] gives IndexError in a __body__. Measured on 2026-09-29 on x86-64 with v450 (c19cc2d531e4) and the compiler built at 1763b6232b (70e57d59b777), which behave the same. Workaround: test the condition in the executed code with an if and return a value the caller checks (such as -1), instead of raising.

Memory leaks

Three limits are open; the leaks fixed before and after the release are listed under History.

Program-level global variables are not finalized when the program exits. This is a one-time cost at exit, not a leak that grows while the program runs.

Nil Python: a string temporary built by a module-level statement, such as print("n=" + str(n)) outside any function, is kept until that statement runs again. That is at most one string per source line, and a loop reuses it, so the cost is bounded by the program's length and does not grow while it runs. Inside a function, temporaries are released when the statement ends.

Nil Python: a reference cycle is never freed. Nil Python frees an object when its last reference goes away; there is no garbage collector to find objects that only refer to each other. That is the design for this beta, and it differs from CPython and MicroPython, which both reclaim cycles. A function that makes two objects point at each other (a.other = b; b.other = a) keeps both after it returns: 2 objects kept after one call, 10 after five, measured with v445 and with the compiler at ae11f1ddb5. Workaround: break the cycle before letting go (b.other = None); measured, that keeps none.

ESP networking

TLS on ESP is client-only, and does not check certificates by default. ssl.wrap_socket and SSLContext work, so urequests.get("https://...") and MQTTClient(..., ssl=True) do too, but, as in MicroPython, the server's certificate is only checked when the program asks for CERT_REQUIRED and passes the authority it trusts; there are none on the chip. See TLS on ESP. A Nil Python program on a desktop has no ssl module, so urequests there refuses https:// URLs with a ValueError; desktop Pascal programs have TLS through the http unit.

Optimisation levels

-O2 is the default and the level the compiler proves on itself. -O3 is experimental: its differential check against -O2 had two failing shards at v439. Use -O3 only if you check the output.

Workaround: use -O2, the default.

By design: Trunc of an out-of-range float into a 32-bit integer

Trunc(1e30) stored in an Int64 saturates to 9223372036854775807. Stored in a LongInt it gives -1, the low 32 bits of that saturated value. This is the same on every target, desktop and ESP (measured with v425; the desktop half again with v451 on x86-64, i386, aarch64, arm32 and riscv32). A float that does not fit the integer type it is truncated into has no meaningful integer value; test the range first if the input can be that large.

By design: math errors

An embedded device should keep running when a sensor produces a value that causes a math error. A desktop program should stop and say what happened. So the two behave differently on purpose:

Desktop (Linux, all CPUs) ESP32-S3 and ESP32-C3
Pascal and C: integer div / mod by zero runtime error 200, the program stops gives 0, the program continues
Pascal and C: float division by zero Inf or NaN Inf or NaN
Nil Python: // and % by zero runtime error 200, which except cannot catch, when the divisor is only known at run time; ZeroDivisionError when the compiler can see it is zero or the def is typed (measured with v450; this may change before 1.0, so test the divisor if a program depends on either behaviour) gives 0, the program continues
Nil Python: float / by zero ZeroDivisionError, as in CPython Inf

Each cell was measured on v425. The desktop column was measured again on 2026-09-29 with v451 (d9b7226769cc) on x86-64, i386, aarch64, arm32 and riscv32 Linux, for Pascal, C and Nil Python, and every cell held. The ESP column was measured under Espressif's QEMU on both chips, for Pascal, C and Nil Python; its Pascal and C integer cell again with v450 (see Numbers on ESP). wasm32 is not in the desktop column: there an integer division by zero stops the module (see "Stops at run time" above). This is not a bug to be fixed: if you need a zero divisor to stop an ESP program, test the divisor yourself.

Reporting a problem

Reporting bugs says what to put in a report, how to name the compiler you ran (from a checkout or a release archive), and how to cut a program down to a small reproducer. A program that compiles and gives a wrong answer is the most useful report you can send.

History

What was wrong in an earlier pin and is fixed, and the measurements behind the open rows above.

Fixed since v441

These are wrong in v441 and fixed in a later pin or after the latest one, as each row says: "wrong in v441 to v446" means v446 is the last pin with the fault; the fix landed after it, so the source of every later pin carries it. The C rows were checked against GCC's output and the Pascal rows against FPC 3.2.2. The Nil Python rows were checked against CPython 3 and say what they were measured with.

Pin v448's own binary (b2b325036c3b) was graded on the native test tier on 2026-09-28 at 7abbe26f4e, with no skipped or flaky rows. One row is still red: test/c_crtl_wait.c, where riscv32 under QEMU 8.2.2 leaves wait4's rusage untouched; whether PXX or the emulator is at fault is not yet known. -O3 was not part of that run.

Fixed in this release

These were wrong in the earlier draft pin v425 and are fixed in v441.

These were wrong in v424 and fixed in v425, and so are fixed here too:

The pre-release leak sweep, and leaks fixed since

Memory leaks were treated as release blockers for this beta. Before the release every leak test in the tree was re-run. The Nil Python checks each ran beside a deliberate leak, to prove they could catch one; the Pascal and C checks had no such control at the time. The Pascal checks got one after v448 (cfcfc49263, in v449): the same census, run with a string and an array kept on purpose on each of 400 trips, must trip the bound. Measured on 2026-09-28 with the compiler built at a2614fcb8b: 4 blocks live, and 1,080 with the deliberate leak, on x86-64; 5 and 1,186 on i386 and arm32 (QEMU user mode). The C checks still have no control. The re-run covered:

No open compiler-caused leak was known when v441 was released. The sweep found five, and all five are fixed in this release. If you are on an older pin, use the workaround. One more was found after the release; it is listed after these five.

Found after the release, on 2026-09-27, in v441, and fixed since:

Found on 2026-09-28, wrong in v441 to v448, and fixed in v449:

A list or dict that a statement creates, such as kept = [], stays allocated until that same statement runs again or the function returns. That holds even after the name is bound to something else (kept = [] a second time on another line, kept = None, kept = 5), and calling a method on it (kept.append(r)) holds it the same way. At module level it is held until the program ends. It does not add up in a loop, but a function that fills a list and then drops it keeps the contents until it returns. On an ESP32-C3 with about 70 KB free, 34 kept HTTP responses (about 1.4 KB each) held that way ran the heap low enough that Wi-Fi stopped working. Fixed in v446 (31d314dfa8): the container is released as soon as the last name lets go of it. v446 does not cover a list built by a comprehension (rows = [str(i) for i in range(n)]): after rows = None it is still kept until the function returns. That is fixed after v446 (cdd6fd3c1f, in v447). Measured on 2026-09-28 with tools/census_at_exit.sh, a function whose list of 30 strings is dropped before it exits: kept = None leaves 1 live with v446 (ae3466a018d8); a comprehension then rows = None leaves 32 with v446 and 1 with the compiler at e072d579b0 (ccd62c91f30e). On v445 and earlier, and for a comprehension on v446: return from the function, or let it end, to get the memory back.

del name on a local variable does not release what the name refers to; the object stays allocated until the function returns. This is so from v446 to v448, and fixed in v449 (c4f5dcf929). Measured again on 2026-09-28 with the pinned binaries, each in its own tree: v448 (b2b325036c3b), v449 (0ded1e5d04c8) and v450 (c19cc2d531e4), a function that builds a list of 30 strings and exits inside the function: under del, 32 live with v448 and 1 with v449 and v450; under = None, 1 with all three; kept, 32 with all three. On v446 to v448, assign name = None instead, which does release it. On v445 and earlier name = None does not release it either (see the paragraph above): return from the function. (Measured on 2026-09-28, the same list of 30 strings: under del 32 live with v446 and with the compiler at e072d579b0; under = None 1 with both, and 32 with v445. Measured again with tools/census_at_exit.sh, the census taken inside the function: under del 32 live with v448 (b2b325036c3b) and 1 with the compiler built at a2614fcb8b (5dea028059af), under = None 1 with both, and 32 with both when the list is kept.)

ESP networking under load

Networking was soaked under Espressif's QEMU with the v440 compiler (v441 differs from it only in the Dispose(F()) fix). None of these runs showed memory or sockets growing:

what ran chip result
10,000 HTTP requests with urequests (Nil Python) ESP32-S3 64 bytes in total over 10,000 requests
1,000 sessions each of ntptime, umqtt.simple and umqtt.robust (Nil Python) ESP32-S3 0 bytes per session
3,000 MQTT sessions with umqtt.simple (Nil Python) ESP32-C3 the same socket number every session; heap flat after the first 25
320 TCP connections over loopback, server and client in Pascal ESP32-S3 0 bytes over 40 passes
300 HTTPS requests with urequests (Nil Python; v442 or later) ESP32-S3 (QEMU) 68 bytes in total over 300 requests
300 HTTPS requests with urequests over Wi-Fi (Nil Python; v442) ESP32-C3 board no growth: free heap level at about 65 KB throughout

Each run was checked against a deliberate leak, which it caught. An earlier reading of about 0.6 bytes per pass on the Nil Python example programs turned out to be the soak's own report lines, one kept string per checkpoint line (see the Nil Python paragraph above). With those lines moved into a function, the four Nil Python examples keep 0 bytes after 10, 160, 640 and 1,280 passes on both chips, with v441, beside a deliberate leak that reads 76 bytes per pass. A MicroPython-style main loop written at module level, making 1,000 requests with a print each time, holds about 1.6 KB once (the last response, still bound to its variable, as in CPython) and then stays level.

Two limits apply to these measurements: