Skip to content
ThingFace

Changelog

What changed in each release of the device SDK, the page library and the service.

The SDK follows semantic versions below 1.0.0 until the launch: MINOR goes up with what is new to whoever uses the SDK, PATCH with a fix (The SDK's versions). A change of documentation only does not raise the number: its entry stays under "Not versioned yet", in "Documentation", and goes with the next version. The board sends the version in the HELLO, and the portal shows it in the device's health. Each version says the version of the devui.1 protocol it speaks; the v1 API is frozen since 16/10/2026, and from now on it only grows by additions (Compatibility).

Not versioned yet

Documentation

  • The OTA's heap on the Arduino-ESP32, measured (16/11): on a classic ESP32 without PSRAM, with the core as it comes, the lowest during the download was 15.6 to 18.3 KB; with the recipe of ESP32 without PSRAM, 69 KB. The guide recommends the recipe and says the version the release asks for with a pioarduino image (1 by default) (Arduino-ESP32).

0.4.0 (16/11/2026), protocol 1.2

  • ESP8266: the firmware download up to 42 % faster (16/11): the channel mode's window goes from one piece to four (4,032 B). Measured through the production on an ESP-12F, an image of 473 KB: 57 s instead of 99 s, with ~1.2 KB more heap at the lowest. Whoever needs that heap goes back to one piece with window = 1008 in the options of DevUIOta.begin (ESP8266).

0.3.3 (15/11/2026), protocol 1.2

  • The dependencies.lock of the ESP-IDF examples (16/11): the manifest_hash of each one is again the one the build writes, in every example (15 were stale from earlier versions, and the build rewrote them). At each version, tools/bump_version.py remakes these hashes with the IDF Component Manager's own calculation (tools/lock_hashes.py, which needs the IDF's python), and a test checks them. Nothing changes on the board or in the CLI.

0.3.2 (15/11/2026), protocol 1.2

  • CLI: the boards without room for the image (15/11): devui firmware status says how many boards of the rollout have no free space for the image (the cloud's no_space state: an ESP8266 built with the 4m3m layout, for example) and what to do: flash them by cable with the 4m1m or 4m2m layout. Before, they stayed pending with no visible reason (ESP8266).

0.3.1 (15/11/2026), protocol 1.2

  • ESP8266: the diagnosis of an interrupted eboot copy (15/11): when the power goes in the middle of the copy of the new image (~6.3 s), the eboot does not resume it, and what is left at the start of the flash is a mixture of the two images. When the mixture runs, the board's log said the image had never been copied; now it compares the image running with the last update applied and says "not copied whole". What goes to the cloud does not change (falhou, interrompido, and the next offer mends the image). The guide now says what a power cut during the copy does, measured in four cuts on an ESP-12F: in three the board only came back by cable (ESP8266).

0.3.0 (15/11/2026), protocol 1.2

  • Remote firmware update on Arduino-ESP32 (15/11): the Arduino library carries the same devui_ota as ESP-IDF, built on the core 3.3: DevUIOta.begin with the firmware public key in hex, before DevUI.begin, the same optional hooks, the same download over HTTPS, the read-back and the confirmation after reconnecting and 60 s. The library overrides the core's verifyRollbackLater(), which would otherwise confirm the new image right at boot, before the health check; an image that came another way (the app's Update, ArduinoOTA) is still confirmed by the core as before. Every new release must keep DevUIOta.begin. Proved on a board, on the S3 (a good image applied, an image that dies after boot reverted, a wrong signature refused before the first byte written, the network dropping midway); during the download, measured on the S3 without PSRAM, the free heap is ~70 to 75 KB below the online one. The example is arduino/examples/Ota (Remote firmware update).
  • Remote firmware update on ESP8266, over the connection itself (15/11): with no memory for a second TLS session, the ESP8266 receives the firmware in chunks over the SDK's channel (FW_CHUNK, asked for with FW_WANT, no new version of the protocol), and the core 3.1.2's Updater writes them in the free space. The Ed25519 signature is checked before the first byte written and again reading back the written copy, before Update.end(); the anti-rollback floor lives in the SDK's sector of the flash. The ESP8266 does not go back by itself from a new image that dies: a rollout to more than one board first takes a pilot board with the same release applied, and the portal marks "ESP8266: no automatic way back". Layouts 4m1m and 4m2m; on 4m3m the board refuses the offer for lack of space. Proved on an ESP-12F (a good image applied, ~24 KB/s measured on a local network; a power loss before the end leaves the board on the version it had); a power loss during the eboot copy is still being measured (ESP8266).
  • devui firmware: phases, release notes and advancing the phase (15/11): a rollout to a list or to the product goes in phases by default (1 % → 10 % → 100 % of the boards, with an automatic stop when the failure rate goes past the limit; --no-phases, --failure-pct, --failure-min and --phase-minutes); status tells the phase and why the rollout is paused; advance opens the next phase by hand; publish takes the release notes (--notes or --notes-file), which the portal, the owner's app and the emails to the owner show; an ESP8266 release to more than one board without the pilot board gets 409 pilot_required, and the CLI tells the way. On an image of the Arduino-ESP32 core --version is required, as on ESP8266 (CLI reference).

0.2.0 (14/11/2026), protocol 1.2

  • Remote firmware update (OTA), on ESP-IDF (14/11): the optional component devui_ota (ports/esp-idf/devui_ota; in the ESP Component Registry, thingface/devui_ota, of the same version as thingface/devui) updates the board from the cloud. The maker uploads the app's .bin in the portal or through the CLI, the cloud signs it with the product's firmware key and offers the release over the SDK's own connection (FW_OFFER, no new version of the protocol). The board downloads it over HTTPS straight from the storage and, before the first byte written, checks the Ed25519 signature (Monocypher 4.0.2, in the NOTICE), the chip, the size and the anti-rollback floor; writes the inactive slot, reads it back and checks the SHA-256 and the signature again before promoting it; and, on the new image, confirms only after reconnecting, the HELLO_ACK, 60 s and the app's is_healthy, otherwise it goes back to the previous one. The hooks on_offer, on_ready and is_healthy are optional; the progress and the result reach the portal (FW_STATUS). Proved on boards, on the ESP32 and the S3; the C3, the C6 and the P4 build. The example is examples/ota and the guide, Remote firmware update. An app without devui_ota builds and runs as before; the core announces the OTA capabilities in the HELLO only when it is on. The Arduino library and the ESP8266 come later.
  • The bootloader's rollback on in the examples (14/11): every example with the SDK's partition table now has CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE=y. An OTA does not update the bootloader, so a product born from an example leaves its first flashing by cable ready to go back by itself from an image that dies before confirming.
  • devui firmware: publish and deploy the firmware from the CLI (14/11): firmware publish <app.bin> --chip CHIP publishes the release (--version, --security-version, --key-id, --commit), and firmware releases, rollout, status, pause, resume and complete handle the rollouts, with the publish key (or OIDC) and no second factor; publishing and deploying take the key of an administrator of the product. The standard output carries only the cloud's JSON (CLI reference).
  • ESP8266 on Arduino: each stack thunk in its own section (14/11): the linker no longer takes into every sketch the functions nothing calls (without it, the OTA's Ed25519 would go into every ESP8266 sketch, OTA or not: +19 KB of flash and 1.8 KB of RAM). Nothing changes on the wire or in the API.

0.1.1 (11/11/2026), protocol 1.2

  • ESP32 without PSRAM on Arduino: dynamic TLS buffers, and STOPPED with the memory back (11/11): on the Arduino core 3.3 as it ships, the SDK's idle TLS session holds ~40 KB (the precompiled mbedTLS uses fixed buffers), and on an ESP32 without PSRAM a second TLS of the app (an HTTPS API) may not fit. The recommendation for that case is to rebuild the core's mbedTLS with dynamic buffers through pioarduino's custom_sdkconfig, with the link's --wrap that pioarduino does not add by itself: the idle session drops to ~4 KB and a second TLS's handshake asks 23 KB instead of 54 KB (ESP32 without PSRAM on Arduino). In the SDK: devui_stop now publishes DEVUI_STATUS_STOPPED only once the TLS session is back in the heap (0.2 to 0.35 s later, instead of at once; with the client stuck closing, 20 s later anyway, with a warning in the log), so an app that pauses the SDK can wait for it before opening its own TLS; and the Arduino library for the ESP32 family no longer carries the vault mode, which it did not offer anyway (+3 KB of heap). Nothing changes on the wire nor in the API.

0.1.0 (11/11/2026), protocol 1.2

The first numbered version: everything below, from 13/10 up to here. Boards that send 0.0.0 are from before it.

  • The SDK gets a version (11/11): the SDK's number (devui_version(), the SDK_VERSION of the HELLO) is no longer always 0.0.0 and goes up with each change that reaches the board or the CLI: MINOR with what is new to whoever uses the SDK, PATCH with a fix, below 1.0.0 until the launch. Two boards with the same number run the same SDK; a board built before the first version keeps sending 0.0.0. The CLI (devui, in the User-Agent), the Arduino library, the ESP-IDF component and the Rust binding carry the same number. This page gets a title per version, with the date and the protocol's version, and the history from before stays under "Before 0.1.0". Nothing changes on the wire or in the API (The SDK's versions).

Before 0.1.0 (no number, 0.0.0)

The SDK had no number before 0.1.0: every board built from 13/10/2026 up to it sends 0.0.0. The changes of that time are grouped by the version of the protocol each one brought.

Since 26/10/2026, still on protocol 1.2

  • The board's permission on its own records (11/11): the device of each table of the database becomes an object, {"device": [...], "account": [...]}, after the pattern of guest. device.device, new and required (it may be []), says what the board does on its own records (DEVUI_DB_DEVICE), which before it always read and wrote; device.account is the list of before, on the account's records, with the same default (only read). A table where the board only inserts takes "device": {"device": ["insert"]}, and what it may not do comes back DEVUI_DB_FORBIDDEN. The old list ("device": [...]) is refused: devui tables push exits with code 2 showing the new form, and the cloud refuses it again. The tables declared before got the four actions on their own records, what the board could already do, and tables get returns them in the new form. In the portal, the "Declarar tabela" ("Declare table") screen becomes a grid of who × scope, and in a new table the row of the board on its own records starts empty. Nothing changes on the wire or in the API (Database).
  • devui unpublish: unpublishing from the CLI (11/11): devui unpublish --project-key pk_... takes the product's publication in force off the air, on every device of the product, as the Despublicar ("Unpublish") button of the product's page does, with the same key (or OIDC) as publish; the output says the retired hash. With the product's interface in the cloud, the tabs have no interface until the next publication; on the device, each board serves its own firmware's again. With no publication in force, or with the product locked (its signed publication stays), it exits with code 5 and the reason, and nothing changes (CLI reference).
  • The ESP32-C3 takes the SDK's partition table, as the C6 (11/11): the LED example grew by 26,960 to 27,968 B a target since 27/10 (18,432 B on the C6), with the local mode, the database, the account's preferences and the refusal of the firmware's interface, and no longer fits the 1 MB app of ESP-IDF's default partition table on the C3 (6,672 B short, measured on 11/11 in the example's build with ESP-IDF 5.5.5). The example already takes the SDK's table on every target; devui pack --target esp32c3 now warns, as on the C6, that the firmware with the interface does not fit the default table, and without --target the warning's threshold is the S3's. Nothing changes in the API.
  • DevUI.getPrefs in the Arduino shell (11/11): devui_get_prefs gets its method in the shell, as the other functions of devui.h (the C name without the prefix, in camelCase); an addition to the v1 API.
  • The database's tables belong to the product (11/11): devui tables push tabelas.json --project-key pk_... checks the file here, by the cloud's rules (an invalid file exits with code 2, with the table and the field, without leaving the machine), and writes the tables in the product, with the same key (or OIDC) as publish; the answer says the new version. devui tables get prints the tables in force, in JSON, ready for a push. devui pack no longer puts tabelas in the manifest: a tabelas.json beside web/ is an error, with the reason pointing to the product's "Banco de dados" ("Database") tab and to devui tables, and --tabelas is gone (Database).
  • The product decides the interface (11/11): in a product with its interface in the cloud, the cloud refuses the bundle the board announces with REFUSAL 4 (DEVUI_REFUSAL_CLOUD_UI), and the SDK says on the serial why (bundle REJECT, REFUSAL 4: the product serves its interface from the cloud...) and stays connected, as at every REJECT; an earlier SDK logs the 4 as a number. For such a product, the firmware may go without an interface (no web/): the HELLO goes without the bundle's fields, and the tabs get the product's publication (Firmware without an interface).
  • The owner account's time zone and language on the board (10/11): the PREFS frame (0x66) brings the IANA zone, its POSIX rule and the owner account's language, and the SDK announces it knows it by bit 7 of OPTIONS. Taken, the SDK keeps the three in the NVS (with no rewrite when they come the same), tells the app with DEVUI_EV_PREFS and, by default, applies the rule with setenv("TZ", …) and tzset(), so localtime() comes out in the account's zone, also at a boot with no cloud; devui_config_t.manual_tz turns that off. A PREFS out of the rules (the POSIX grammar of TZ) is refused with 4400 and nothing changes. The limbo and devui_factory_reset() erase the preferences and give back the firmware's TZ. devui_get_prefs() reads the kept ones; in the local mode, /_devui/env now says the account's locale and time_zone (or null). A rule with a signed transition hour (America/Nuuk), which newlib reads wrong, is not applied. New example: examples/hora-local (The account's preferences).
  • A simple database over the board's connection (10/11): devui_db_insert, devui_db_update, devui_db_delete, devui_db_find, devui_db_aggregate and the generic devui_db_request write, read and sum records of the tables the owner declared, in the board's scope (DEVUI_DB_DEVICE) or the account's (DEVUI_DB_ACCOUNT), with the request and the answer in JSON. The SDK builds the request and puts the scope in it; the result comes to the callback once (devui_db_result_t: the cloud's result, the answer in JSON, the wait asked for). At most 4 requests at once (the fifth returns DEVUI_ERR_DB_LIMIT with nothing on the wire); with no answer in 10 s, or with the connection's drop, DEVUI_DB_UNAVAILABLE. With no cloud, the call is refused at once, unless the app turns on the queue (devui_db_queue, in the RAM or in the NVS): the inserts wait and go in order when the connection comes back, each with an op_id drawn on the board, so the cloud does not write twice. The methods dbInsert... in the Arduino shell; on the ESP8266, the queue in the RAM only. New example: examples/banco (Database).
  • Arduino: the library can leave the Serial alone (09/11): built with -D DEVUI_ARDUINO_SERIAL=0 (on PlatformIO, in build_flags, which reach the library too), DevUI.begin does not call Serial.begin and the SDK writes nothing to the Serial, on the ESP32 and on the ESP8266: neither the pairing code's line, nor the warnings of where the key is, nor the errors of begin. It is for a board whose UART0 TX pin drives something else (the relay on the TX of the ESP32-2432S028, the "Cheap Yellow Display"): Serial.begin would give the pin back to the UART, and each line would toggle it. The pairing goes on the same, and the code reaches the app by the events DEVUI_EV_PAIR_CODE (pair_code, pair_url, pair_ttl_s) and DEVUI_EV_PAIR_CODE_ACCEPTED, to show on the display or on the board's page. Out of the option's reach: ESP-IDF's own log (ESP_LOGx, the port's warnings), which only reaches the pin while it is the UART's (a pin taken by pinMode is not), the ROM's boot messages and, on the ESP8266, the fatal message of BearSSL's stack overflow, written straight to the UARTs. Without the option, nothing changes (the default is 1). No change in the API; on the ESP8266, Hello8266 built with the option is 8.7 KB smaller in the flash.
  • A cloud that could not keep the bundle asks for "try later" (04/11): when the cloud's storage fails at the end of an upload, the BUNDLE_DONE comes with RESULT 5 and a RETRY_AFTER_MS, instead of the 3 ("invalid container") of before. The SDK ends the upload, tells the app (DEVUI_EV_BUNDLE_REJECTED with result 5; in Rust, BundleRejected { result: 5 }) and logs it on the serial; the connection goes on. Once the wait is over, the cloud itself asks for the bundle again on the same connection (BUNDLE_WANT from 0), and the board uploads it again, with no reconnection and no tab dropped; at most 5 times per upload, with the wait doubling (from 1-2 min to 16-32 min). The last RESULT 5 comes without RETRY_AFTER_MS, and the serial says the cloud asks no more on this connection. No change in the API; the earlier firmware, which already answers BUNDLE_WANT at any moment, uploads again the same way.
  • Local mode: the UI over the LAN and the app's AP (31/10, under review): with CONFIG_DEVUI_LOCAL, devui_local() no longer answers ESP_ERR_NOT_SUPPORTED and the board serves its own UI, the lib and /_devui/env (mode: "local") at http://<the board's IP>/, behind its login with the local password (80 bits born on the board; devui_local_secret gives it to the app to show the owner). Never on an open AP. Each local tab is a session from 0x8000 to 0xFFFE, of the kind DEVUI_SESSION_LOCAL, with the operator's role; the traffic on the LAN is HTTP with no TLS. Additions to the v1 API: devui_local_secret, devui_local_secret_renew, DEVUI_SESSION_LOCAL and DEVUI_LOCAL_SECRET_SIZE (on Arduino, DevUI.localSecret and DevUI.localSecretRenew, which answer ESP_ERR_NOT_SUPPORTED, as local()). The ESP8266 stays out. In the LED example, sdkconfig.localmode turns the mode on (Local mode).
  • The board answers the device API (26/10): a server, a script or another board sends a message to the device with POST /v1/devices/{id}/messages, with an access key the owner creates on their page, and gets the firmware's answer (Device API, in Portuguese). On the board, each call is a session of the API kind (SESSION_KIND 2), which the SDK opens like a tab's; kind 1 (the tunnel) and the unknown ones are still refused with 4400. The SDK announces in the HELLO that it answers the API (bit 2 of OPTIONS), always, with no option for the firmware; the earlier SDK refuses the session, and the cloud answers 422 firmware_sem_api to the caller. Additions to the v1 API: DEVUI_SESSION_BROWSER and DEVUI_SESSION_API, the field session_kind of devui_event_t (in the SESSION_OPEN) and the field kind of devui_session_info_t, the same on the Arduino (ESP32 and ESP8266). A firmware that does not want machine calls refuses by the session's kind. In the "8266" profile, the HELLO of an app with no options grows by 7 bytes (the OPTIONS). A new example: examples/api-chamada, a board that calls another through the API, on ESP-IDF.
  • One board calls another over its own connection (27/10): devui_call(apelido, dados, tamanho, prazo_ms, callback, ctx) (C), call (Rust), DevUI.call (Arduino, ESP32 and ESP8266), an addition to the v1 API. The owner links the two boards in the portal with a nickname; the firmware calls by the nickname, with no key and no second TLS connection, and the callback comes once, on the SDK's task, with the other board's answer or the reason there was none (DEVUI_CALL_*, the names of the HTTP API, plus DEVUI_CALL_NOT_SENT and DEVUI_CALL_ERROR, the SDK's own) (Linking one device to another, in Portuguese). On the wire, the frames CALL (0x24) and CALL_REPLY (0x25). The called board sees a session of the device kind (DEVUI_SESSION_DEVICE, 3; SessionKind::Device in Rust, a new variant of the #[non_exhaustive] enum), which the new SDK always opens and announces in the HELLO (bit 3 of OPTIONS); the earlier SDK refuses it, and the caller gets DEVUI_CALL_UNSUPPORTED. The HELLO does not grow (the OPTIONS was already there). New examples: examples/chamar-outro (ESP-IDF) and arduino/examples/ChamarOutro (ESP32 and ESP8266).
  • Named actions in the manifest (27/10): the acoes.json beside web/ (or --acoes) goes into the bundle's manifest as acoes, and the API caller asks for the action by its name (POST /v1/devices/{id}/actions/{nome}) (Named actions, in Portuguese). devui pack, devui publish and devui_add_bundle check the list before writing or sending (name, description, minimum role, the markers {{nonce}} and {{p:<nome>}} only as a whole value, typed parameters, up to 32 actions, a final payload of up to 4 KB in the worst case, the whole manifest up to 8 KB) and refuse it naming the action and the field. devui publish with actions sends the manifest also when unsigned (Devui-Manifest) and checks in the answer that the cloud kept the actions; they exist only for the bundle published by the CLI (the board never sends the manifest). Without the file, the manifest is the one of before, byte for byte; the firmware does not change.
  • The firmware closes a session (27/10): devui_session_close(sessao, motivo) (C), session_close (Rust), DevUI.sessionClose (Arduino, ESP32 and ESP8266), an addition to the v1 API. It sends the SESSION_CLOSE with the reason (a code from 1000 to 4999, or 0 for none) and forgets the session at once, with no DEVUI_EV_SESSION_CLOSE; what was still in the SDK's queue for it is dropped. With 4405, the firmware's refusal: the API's event stream ends with the event closed ({"erro":"proibido"}) and the call gets 403 proibido (Device API, in Portuguese). It also works for a person's tab. On the ESP32, it goes into the SDK's queue behind what the app put there before (a devui_reply to the session goes out before the close); on the ESP8266, it goes out before the function returns.
  • A visible change in the Rust binding: the session's kind in Event::SessionOpen and in SessionInfo. Both get the field kind: SessionKind (the new enum, Browser, Api or Other(u8), #[non_exhaustive]), the same session_kind/kind as in C. Unlike the other changes since 26/10, this one is not only an addition: a new field in a variant and in a struct that already existed breaks the code that destructures Event::SessionOpen { session, role, reopened, user } or SessionInfo { open, role } without .., or that builds a SessionInfo by a literal. Fix: add kind or .. to the pattern. A decision of 26/10, preferred to a new function just for the kind; the snapshot of the v1 API (api/devui-rust-v1.txt) was corrected by hand in those two items, and SessionKind went into it as an addition. The C and the Arduino do not change.
  • The change of owner comes signed: the build carries the cloud's ownership key beside the roots and the order keys (owner.pub.pem, and owner-next.pub.pem for the key change, in the order keys' folder; the dev profile carries the SDK's staging one). With it, a generation of the new ownership, by the OWNER_CHANGED or by the HELLO_ACK, counts only with the cloud's OWNER_SIG that verifies for this device_id; unsigned, from another key or with a byte changed, the board ignores it (no event, no write) and the serial says owner change ignored (<motivo>): generation <n>. Without the key in the build, as before. Nothing changes in the API. The change of owner through the limbo too (26/10): with the key, the HELLO_ACK that takes the board out of the limbo gives PAIRED only with the signed generation; without it, the board acts as paired on that connection (no code, no button), but does not tell the app nor write the owner (pairing not taken ... on the serial), and the PAIRED comes with the first signed HELLO_ACK (or OWNER_CHANGED). The ownership key is required in the release (since 26/10): the ESP-IDF release build without owner.pub.pem (pinned as owner in the production.sha256) fails at configure and at check-bin, and the production Arduino package (ESP32 and ESP8266) does not come out without it; only the dev profile and the test endpoint go without. The ESP-IDF endpoint with the roots pinned as production is a release: only with the order keys and the ownership key pinned, like the Arduino package.
  • The factory reset comes signed by the board (30/10): devui_factory_reset() with the connection ready signs the UNPAIR with the board's identity key (the same as the HELLO's signature; ECDSA P-256 over SHA-256("devui.1/unpair\0" ‖ device_id)) and sends it with the TLV SIGNATURE; then it closes with 1000 and erases the key, as before. The HELLO now announces it, always, in bit 4 of OPTIONS (UNPAIR_SIGNED), with no option for the firmware; the cloud locks the board when it sees the bit and, from then on, only marks the reset the board signed: a compromised gateway no longer resets a board's record on its own. If the signature fails, the UNPAIR goes without it (the serial says UNPAIR signature failed) and the reset happens all the same. Cost: one P-256 signature per reset (its time on the ESP8266 and on the S3 is still to be measured); the UNPAIR grows from 8 to 75 bytes, and the HELLO does not grow (the OPTIONS was already there). The earlier cloud ignores the signature. Nothing changes in the API. Since 31/10: a board that keeps the ownership's generation signs the generation too, SHA-256("devui.1/unpair\0" ‖ device_id ‖ OWNER_GEN), with the generation as a little-endian u32. With the factory identity the reset keeps the key and the device_id, and the deterministic nonce would give the same signature at every reset: tied to the generation, which changes at each pairing, the signature of one reset never resets the next owner. With no generation kept, the message of before goes. A cloud from before this change refuses the signature with the generation (the reset is not marked and the board comes back as a new device or, with a factory identity, with the same owner): publish the cloud first. Nothing changes in the API.
  • The HELLO says where the key lives (30/10): every HELLO carries the TLV KEY_STORE (2 bytes: the scheme and the signals), and the cloud works out from it the key's protection level, shows it in the fleet and refuses the pairing in a product that demands more (PAIR_RESULT 4; the board stays in the limbo renewing the code, and the serial says pairing refused: the key protection is below the product minimum (PAIR_RESULT 4)). The scheme comes from the build: a factory identity by the eFuse's HMAC key (4), by the ECDSA peripheral (5) or under flash encryption (3); without CONFIG_DEVUI_FACTORY_ID, the NVS (1), and the encrypted NVS (2) only when the key is in the default NVS partition of a build with CONFIG_NVS_ENCRYPTION (the devui partition is never encrypted by the IDF: nvs_flash_init_partition does not use NVS encryption). The signals are read from the chip at boot: flash encryption, secure boot and a virtual eFuse (for tests). ESP8266 and POSIX send NVS, with no signal. The level is self-declared: the HELLO's signature proves the key, not where it lives. The HELLO grows by 5 bytes: in the "8266" profile, the longest host that fits with the other fields at their most drops from 41 to 36 characters (the service's has 16). The earlier cloud ignores the TLV. Nothing changes in the API.
  • The unlinking and the change of the ownership key come signed (27/10). Only on a board with the ownership key in the build; without it, nothing changes.
    • The unlinking: on a board with a stored generation, the close 4410 becomes only a notice (it reconnects with the normal backoff, with the same owner and the same generation). What takes it to the limbo is the HELLO_ACK with OWNED = 0 and the UNOWN_SIG (76 bytes: the generation that ends and its signature, with the conventions of the OWNER_SIG) of a generation equal to or greater than the stored one (since 27/10: the generation only goes up); then, as before: UNPAIRED, the generation erased. From a lower generation (an old unlinking repeated after a new pairing: stale, without checking the signature), unsigned, from another key or with a byte changed, the board keeps the owner and the generation, with no ERROR; the serial says unown ignored (<motivo>), and the connection goes on with no cloud session and no pairing code until it drops or until the cloud closes it with 4410 after signing. With no stored generation (never paired with a signed generation, or already in the limbo), OWNED = 0 asks for no signature. The local factory reset is still unsigned. The cloud with the signed unlinking goes before the firmware with it: the earlier cloud sends OWNED = 0 without UNOWN_SIG, and a board unlinked by it keeps the owner until the cloud sends the signature (or until a local factory reset).
    • The change of the ownership key: the HELLO carries the OWNER_KEY_SEQ (the highest change sequence taken; 0 if none), and the new frame OWNER_KEY brings the new key, the sequence and the signature of one of the ownership keys the board has. The sequence only goes up (equal or lower: owner key ignored (stale); 0 is 4400), and the new key has to be a P-256 point (otherwise, point); once taken, the new key becomes the current one and the one that signed stays as the second until the next change. Both, with the sequence, stay in the NVS (devui.okeys) or, on the ESP8266, in the SDK's own sector (a new record, tag 8; the sector already written on the boards is read as before), count in place of the build's ones also after a reboot, and survive the factory reset, like the trust orders; a change the write refuses does not count (owner key ignored (not stored)), and the cloud sends it again. Cost: one P-256 check per change; in the "8266" profile, 136 more bytes in the devui_conn_t and 7 in the HELLO. A firmware earlier than this one that finds the new record in the ESP8266's sector (going back a version) reads it as a cut-off write and drops it, with what came after it, on the next write.
  • The board carries the interface's signature (26/10): with the maker's key in the build (devui_pack.py --sign-key <file>, or idf.py -DDEVUI_SIGN_KEY=<file> build with devui_add_bundle, or devui pack web/ --sign-key <file> on the Arduino), the packer signs the bundle and writes the 72 bytes of the signature next to it (devui_bundle_sig, bundle.sig); the SDK sends them in the HELLO (BUNDLE_SIG), and the cloud checks them with the product's keys. A signature that does not verify (an unknown or revoked key, or a byte changed after signing): the cloud refuses the bundle (REJECT with REFUSAL 2), the board stays connected, the serial says why and the interface of before stays. Verified: the seal "Signed" on the device's page. Additions to the v1 API: the field bundle_sig of devui_config_t is no longer reserved (72 bytes, or ESP_ERR_INVALID_ARG), DevUIBundle.bundle_sig (Arduino) and Config::bundle_sig (Rust). Without the key, nothing changes. The private key never goes into the firmware.
  • The business event's text refuses the invisible ones too (26/10): U+2028, U+2029, the bidirectional controls (U+061C, U+200E, U+200F, U+202A–U+202E, U+2066–U+2069) and the BOM (U+FEFF); devui_audit answers ESP_ERR_INVALID_ARG. The zero width joiner (U+200D) of composed emoji stays text.
  • Interface signed by the CLI: devui keygen makes the maker's Ed25519 key, and devui publish --sign-key signs the manifest (which names the container's hash); the cloud checks it with the product's public keys, registered in the portal, and the interface gets the seal "signed". Only the CLI changes: the firmware and the protocol stay the same.
  • Business events in the device's log (26/10): devui_audit("abriu o portão") (C), audit (Rust), DevUI.audit (Arduino, ESP32 and ESP8266), an addition to the v1 API. The board says only what happened: the cloud writes the event with its own time (the board's goes apart, when its clock is valid) and with who had the interface open; with nobody, the event counts all the same. A text of 1 to 128 B (DEVUI_AUDIT_MAX) of UTF-8, with no line break nor any other control character. The cloud says in the HELLO_ACK (AUDIT_QUOTA) that it takes the event and how many: 10 at once and 360 an hour by default, counted on the board too (DEVUI_ERR_OVER_QUOTA). An earlier cloud does not say so, and the function answers ESP_ERR_NOT_SUPPORTED; with no owner, ESP_ERR_INVALID_STATE. The owner sees the events on the device's events page, in the portal.
  • Vault mode: end-to-end encryption per product (31/10). With CONFIG_DEVUI_VAULT in the build (off by default) and devui_config_t.vault = true, the product's browser sessions trade only messages encrypted end to end with the portal's frame (Noise_XXpsk3_25519_AESGCM_SHA256; on the ESP32, the Everest/HACL* X25519 that already ships in the IDF's mbedTLS and AES-GCM in hardware): the cloud relays sizes and times, never the content. The PSK is born on the board (32 B, under the key's entropy guard) and reaches the user outside the cloud: devui_vault_psk_text(text, size) gives the 55-character text (11 groups of 5, with a check) for the screen, the label or the serial; the short pairing code does not serve as a PSK. The board's X25519 key is attested by the identity key. The board keeps the access list (up to 8 users, the first one is the owner, the effective role is the less privileged of the list's and the cloud's; devui_vault_enroll(false) closes enrolment; a change of owner and the return to limbo erase the list; devui_vault_reset(new_psk) erases the list and, with true, draws a new PSK and key). What changes for the app: DEVUI_EV_SESSION_OPEN comes only when the tab's handshake ends, with the effective role; the largest message is DEVUI_VAULT_OVERHEAD (26) bytes shorter; no device API sessions nor another board's; the cloud keeps no last state. On the wire: bit 6 of OPTIONS (VAULT) and the E2E flag in DATA. Additions to the v1 API: the vault field, DEVUI_VAULT_OVERHEAD, DEVUI_VAULT_PSK_TEXT_SIZE, devui_vault_psk_text, devui_vault_reset, devui_vault_enroll, and the methods DevUI.vaultPskText, vaultReset and vaultEnroll (Arduino; on the ESP8266 they answer ESP_ERR_NOT_SUPPORTED). The crypto HAL gains two optional primitives, x25519 and aead, after ctx; the Rust binding does not turn the vault on yet.

Protocol 1.2 (from 16/10/2026)

  • Change of owner told to the firmware: OWNER_CHANGED and OWNER_GEN, with the generation kept in the NVS; the app erases the former owner's data before coming back online.
  • Trust orders (TRUST_ORDER): the handler checks signature, scope, origin and sequence, and applies the change of endpoint, roots or keys after the 7 days of operation. An order also comes in by a local path: devui_trust_order_local() (C), trust_order_local (Rust), DevUI.trustOrderLocal (Arduino), and the Improv vendor command 0xF0 in the LED example (tools/improv_cli.py order).
  • The plan's refusals: QUOTA_KIND in the ERROR (the month's allowance), and the upload's REJECT and a refused BUNDLE_DONE said on the serial.
  • DEVUI_EV_CLOCK_SET, the ceiling of the cloud's time, and devui_reply answering only on the request's connection (DEVUI_ERR_STALE_REQUEST).
  • Arduino and PlatformIO: the ThingFace library (DevUI), the hello world, the package for the Library Manager and PlatformIO, and Serial on the native USB of the C3 and the S3.
  • Orders in the Arduino package (25/10): the package carries the three order keys beside the roots (src/devui_trust_gen.h) and turns the ESP32's TRUST_ORDER handler on (devui: ordens: tratador ligado on the serial); the production's go with its roots (the staging ones until the ceremony), and --order-keys DIR gives others to an --endpoint. The package check refuses one with roots and without the three keys.
  • ESP8266 (18 to 21/10): the same Arduino library on the ESP8266 core 3.1.2, with the "8266" profile (messages of up to 1 KB, up to 4 tabs, no signed orders), BearSSL's own stack with a guard zone and the Hello8266 example (The SDK on the ESP8266, in Portuguese).
  • Diagnostics of the drop in the HELLO (21/10): LAST_DROP, the OFFLINE reason of the last connection that got online (0 on the first of the boot) with the close code, and WIFI_RSSI, the Wi-Fi signal in dBm, on the ESP-IDF ports (no RSSI on the P4) and the ESP8266; the cloud shows them in the device's health.
  • Examples: Olá, Formulário and Painel ao vivo, on ESP-IDF and Arduino; the ESPUI adapter (ThingFaceESPUI).
  • The code's line on the serial: the SDK, not the example, writes devui: pair code XXXX-XXXX ttl=NNN once per code valid in the cloud (a new one, a renewed one or one back from the NVS, after it reaches the cloud); it is the line the portal reads from the USB. The examples' Portuguese line is gone (Quickstart).
  • Improv over BLE (optional: sdkconfig.ble in the LED example, the ESP32 family only): the same core as Improv Serial (the Wi-Fi and the redirect URL with the base of the HELLO_ACK), and a GATT characteristic of its own that gives the current pairing code while the board has no owner; the PC client tools/improv_ble.py. It costs ~99 KB of heap on an ESP32 without PSRAM (the LED example's README). Since 25/10, with an owner the BLE is on only for the first 2 minutes after the boot, taking a Wi-Fi in that window, and then off for good, giving back ~69 KB of heap on the ESP32 (~56 KB on the S3).
  • DEVUI_EV_PAIR_CODE_ACCEPTED (25/10, added at the end of the enum, on the ESP-IDF and ESP8266 ports; Event::PairCodeAccepted in Rust): the current code is registered in the cloud, at each send, with the code, the URL and the time left. The LED example's code characteristic and Improv URL wait for it. Since 25/10 it comes from the cloud's explicit confirmation, the PAIR CODE_ACK, checked against the current code, no longer from 2 s with no 4429 (which also took for accepted a code the cloud did not keep). With a cloud without CODE_ACK the event does not come.
  • The devui: pair code line waits for the CODE_ACK (25/10): it comes out the moment the cloud confirms the current code, instead of 2 s after the send. With a cloud without CODE_ACK, it comes out 5 s after the send, if no 4429 came (the rule before, with 5 s). After the boot's first CODE_ACK that wait is off: a code the cloud did not confirm (one it did not keep) gets no line. devui_pair_code_trusted() and DEVUI_PAIR_NO_ACK_WAIT_MS (devui/devui_conn.h, a core header outside the v1 API, replacing DEVUI_PAIR_LINE_AFTER_MS) are the rule, which the LED example also uses for the BLE characteristic and the Improv URL.
  • The link of a code handed out offline stays valid (25/10): asked for before the boot's first connection, the earlier boot's stored code is the one handed out (with the most time it can have, settled at the connection), instead of a new one that gave way to it and killed the link; with 60 s or less left, a new one takes its place.
  • Tools: the publishing CLI (devui pack and devui publish), the USB install page (ESP Web Tools and Improv), and the documentation built from the repository.
  • DEVUI_EV_DUPLICATE emitted (25/10, an addition): the ESP-IDF and ESP8266 ports now send it when the cloud closes the connection with 4409 (another board with the same identity took its place), right after that drop's DEVUI_EV_OFFLINE (which still goes, with close_code 4409), or alone when the 4409 came before DEVUI_EV_ONLINE. The event was declared since protocol 1.0 and no port emitted it. The docs also no longer say the SDK drops a request that waited too long in the app's queue: the app checks that wait (The confirmation levels), and DEVUI_ERR_STALE_REQUEST means "the request's connection ended", not "an old request".
  • C3 on PlatformIO (25/10): the esp32c3 environment of arduino/platformio got ARDUINO_USB_MODE=1 (without it the build stopped on "USBSerial was not declared") and the flash in DIO (board_build.flash_mode = dio): a QIO app on a C3 whose bootloader or flash is DIO reads the NVS wrong, erases the devui partition at each boot and changes the device_id (the Arduino README).

Protocol 1.1 (14 to 16/10/2026)

  • Pairing: an 8-character code on the serial, by the button, the result and the factory reset; the code survives a reboot.
  • Send queue with TX_READY, a local quota, the server's keepalive and messages in pieces.
  • Trust: build profiles (release with the pinned production roots, development with the staging ones), the clock floor that rises with verified leaves, and one partition table for ESP-IDF, Rust and Arduino, with the identity in a partition of its own (devui).
  • Improv Serial in the LED example, the ESP Component Registry package and the internal Rust binding, with the example on the S3 and the P4.
  • Frozen API (devui.h and the Rust binding), checked at each build.

Protocol 1.0 (13/10/2026)

  • The C99 core of devui.1, the POSIX and ESP-IDF ports, the interface's packer and the LED example, on the five chips (ESP32, C3, S3, C6 and P4).