Wasmtime: baixar versions anteriors

Added
- Wasmtime now supports the WebAssembly compact imports proposal, disabled by default, via Config::wasm_compact_imports. #14335
- The Wasmtime CLI now has options to configure unsafe intrinsics and compile-time builtins. #14279
- The Wasmtime CLI and C API can now enable the component model's canonical names and accessors features. #14344 #14497
- A new Store::gc_heap_grow method can be used to manually grow the GC heap of a store. #14341
- A new ResourceAny::resource_drop_concurrent method can be used to drop a guest resource with only an Accessor. #14362
- A new Engine::release_idle_pool_memory method can be used to release memory kept resident by the pooling allocator for idle slots. #14419 #14507
- A new off-by-default task-group-hook feature enables embedders to associate guest-to-host calls with their corresponding host-to-guest calls when using component-model-async. #14416
- The wasmtime-wasi and wasmtime-wasi-http crates now support "named imports", the implements field of the component model. #14275
- The wasmtime explore command now supports components and has resizable panes. #14426 #14427 #14458
- The debugger now exposes shared memories to gdbstub. #14087
- Winch now supports tail calls on x86_64 and AArch64. #14349
- Cranelift has initial support for some x86_64 APX instructions. #13916
- The wasmtime serve command can now inherit listening sockets from a service manager (e.g. systemd socket units) with a new --systemd-listenfd option, can serve on Unix sockets, and can automatically exit when idle with a new --idle-process-timeout option. #14294 #14320 #14392
Changed
- Epoch deadline and call-hook callbacks now receive a StoreHookState instead of a StoreContextMut, which only allows access to the T in a Store<T>. #14386
- The wasmtime CLI no longer enables WASIp0 (wasi_unstable) by default. It can be enabled with -Spreview0. #14479
- Winch no longer enables the GC types, exceptions, or tail-call proposals by default as support for these is not yet Tier 1. #14449 #14502
- Accessor::spawn now takes an async closure instead of an AccessorTask. #14376
- Component-model-async has been updated to the latest specification: the cancellable immediate has been removed from intrinsics, subtask.cancel semantics have been refined, task.cancel now traps before the cancel event is delivered, and use of stream/future handles after the other end has been dropped now traps. #14244 #14340 #14342 #14378 #14382
- Component-model-async now periodically yields during concurrent work to avoid starving other host tasks. #14460
- The performance of async guest-to-host calls in component-model-async has been improved by lazily creating host tasks, and sync-to-sync adapters no longer need to call {enter,exit}-sync-call in many cases. #14350 #14270
- Wasmtime now drops cached compiler contexts between compiling modules/components, reducing sustained memory usage. #14314
- Cranelift's alias analysis is faster and more precise, and GC struct fields, array elements, and GC header fields now all have their own alias regions. #14290 #14425 #14351 #14353
- Wasmtime now uses bulk libunwind section registration when available. #14304
- Fuel is now charged for more host allocations made with Val. #14415
- Default wasi:http hooks now classify connection and TLS errors in more detail. #14501
- wasi:http now always accepts an empty path-with-query. #14446
- The CLI now rejects zero for the --http-outgoing-body-* options. #14448
- Work continues on implementing the stack-switching proposal. #14140 #14369 #14398 #14441
- Wasmtime now requires Rust 1.97.0 to compile. #14466
- The pooling allocator now scans further than a fixed set of region and additionally correctly resets pages that have been paged out. #14357
Fixed
- Converting a borrowed Resource<T> or ResourceDynamic created with new_borrow into a ResourceAny outside of a component call no longer panics. The borrow is now lowered into the guest when the call happens, and ResourceAny::resource

Fixed
- wasi-http: Guests can add conflicting content lengths to messages GHSA-r8xh-cgf7-392j
- wasi-http p3: forwarded trailers aren't checked against is_forbidden_header hook GHSA-jxcf-8qw5-5c33
- wasi-http p3: Guests can set incorrect content-length for spliced response bodies GHSA-9prg-84vf-g5fc
- Cranelift backend on aarch64 can jump to incorrect target on large Wasm br_table instruction GHSA-mghf-wjfp-p5xm
- Update rustls to 0.23.46 #14767
- Panic lowering a host-created component model stream into a guest that expects a different payload type. GHSA-9pvw-hwfg-92h5

Fixed
- Out-of-bounds zero-length stream writes can panic. GHSA-93g3-36p8-x2gc
- Host panic when component call_async is cancelled under some conditions. GHSA-3r89-v5mq-j5xf
- Panic on erroneous call-to-host from guest realloc call. GHSA-7v24-42x9-pxf7
- Yielding in a component start function can lead to a host panic. GHSA-5hhx-4wrr-3j9g
- Panic when invoking an async-lifted function via call. GHSA-m6w2-jwq2-cv2c
- Panic when pending calls are run after a trap. GHSA-hmwq-g22x-qjw5
- Stack overflow dropping a long chain of recursive types. GHSA-wjc8-633q-pwxr
- Wasmtime may not properly enforce async-entrypoint requirement. GHSA-vcg5-q8m5-8379
- Panic viewing component model stream or future as the wrong type. GHSA-63h4-6cx9-pjfj
- Component-model handle tables are capped only per instance and charged to no limit. GHSA-q554-3cjc-rx7p
- Exception tags can cause host data structures to be unaligned. GHSA-p79w-pv2r-29qp
- Filesystem sandbox escape when renaming symlinks with trailing slashes. GHSA-m9f7-9w4p-gv38
- Overlapping string transcode in a fused adapter can panic. GHSA-54p9-vhhq-8f7q
- Guests can send absolute-form HTTP requests to different hosts. GHSA-5qpp-g3j2-8frx
- wasi-http: Request with long url before query parameter crashes host. GHSA-w36r-2hch-9xp9

Fixed
- WASI preview 0 implementation of poll_oneoff circumvents fuel consumption. GHSA-j366-h8gg-77pm
- Excessive allocated memory on the host when guests don't have stdio. GHSA-gqmc-89g8-p25r
- fd_readdir copies uninitialized struct padding into guest memory. GHSA-96f6-r43r-8c24
- Guest can panic host through filesystem timestamp before the epoch on wasip3. GHSA-mr2v-56j5-cmfc
- Wasmtime component async-lifted callback result count is unvalidated, causing a native stack buffer overflow. GHSA-32h6-97mm-8q3c
- Mis-typed WebAssembly tag imports can lead to GC heap corruption. GHSA-cfhf-m2cr-62wj
- Wasmtime wasi:http implementation panics with a zero timeout supplied. GHSA-w4qr-p94g-mjhv
- Rooting for GC values live across try_call may be missing, causing GC heap corruption. GHSA-hw8m-q44c-ggrf

Fixed
- Do not drop fuel-spend accrued by callees of call_ref and callees that return via exception throws. GHSA-m63x-6p34-q65x
- Fix fuel spend for dynamic record lifting. GHSA-jqpg-j7w6-42pr
- Fix host memory exhaustion on outgoing HTTP body write. GHSA-c9gc-w9vx-w86p
- wasmtime-wasi: Fix panic on out-of-range datetimes in WASI filesystem set-times, set-times-at. GHSA-j2g9-4prp-pf6h

Added
- Winch now has initial experimental support for the WebAssembly exception-handling proposal. #14066 #14081 #14132 #14149 #14180 #14209
- Wasmtime's type reflection APIs for WebAssembly GC types now have dedicated enums for Heap{Top,Bottom}Types. #14208
- Wasmtime now supports the use of environment variables to configure most CLI arguments in addition to the preexisting CLI flags. #14217
- Cranelift will now fold u{add,mul}_overflow results combined with brif instructions for more optimal codegen. #14217 #14254
- Components can be tested for equality with a new Component::same API. #14257
- The Wasmtime C/C++ API now supports the component-model-implements feature. #14264
- Cranelift will now emit the {u,s}bfm instructions on AArch64. #14187
Changed
- The wide-arithmetic WebAssembly proposal is now enabled by default. #14110
- Config::operator_cost now applies to operators inside constant expressions (global initializers, element and data segment offsets, element segment expressions) and to the synthesized call to a module's start function. Previously each of those was charged 1 fuel unit regardless of the configured cost. #14215
- Wasmtime's WASI implementation will no longer over-read stdin where possible. #14077
- Wasmtime's WASIp2 implementation now maps host-level "broken pipe" errors to StreamError::Closed. #14107
- Wasmtime's WASIp2 implementation of wasi:http now validates ports in the same manner as wasip3. #14123
- Wasmtime's WASI implementation of wasi:filesystem now returns the is-directory error in some situations when a file is provided. #14135
- The wasmtime-wasi-http crate now has the p3 feature enabled by default. #14137
- Wasmtime's WASIp2 implementation of wasi:http now runs more hooks from the WasiHttpHooks trait in the same manner as wasip3. #14167
- Wasmtime now requires Rust 1.96.0 to compile. #14184
- Adjustments have been made to the scheduling of threads w.r.t. trapping behavior for cooperatively threaded components. These changes are made to align with the upstream component-model specification. #14146 #14250
- Fuel for bulk operations is now consumed after the bulk operation has completed instead of up-front, restoring previous behavior where a failed very large memory growth doesn't trap the original program. #14213
- A number of future poll calls throughout the WASIp2 implementation now explicitly opt-out of Tokio's per-task cooperative budget to better uphold guarantees of WASIp2 APIs. #14265
- The run_concurrent function is now allowed to run recursively for separate stores, but it still can only be used at most once recursively for any one store. #14302
- The compile-time performance of the alias analysis in Cranelift has been greatly improved. #14306

Changed
- Wasmtime's dependency on cap-primitives is now vendored within Wasmtime itself. #14225
Fixed
- Code generated by bindgen! is now compatible with the latest Rust nightly by default. #14307

Fixed
- Context slots in component compositions are now correctly managed. #14139
- The Host header is now set by default for HTTP requests sent with WASIp2. #14167

Added
- Wasmtime has an initial implementation of the component model fixed-length-lists feature. #12315
- Wasmtime's reflection of component imports/exports now exposes external-id information. #13874
- Cranelift's alias analysis pass now eliminates dead stores. #13806 #13947
- Winch now supports the wasm SIMD proposal on AArch64. #13911 #13921 #13928 #13937 #13945 #13938 #13946 ...
- Cranelift now supports an AVX512-VNNI lowering for the dot-product wasm instruction and usdot on AArch64. #14006 #14054
- Wasmtime's bindgen! macro now has an include_component_type option to generate a COMPONENT_TYPE constant with the encoded type of the world being bound. #14013
- Wasmtime now supports configurable fuel costs for variable-length wasm opcodes. #13931
Changed
- Host-implemented traits in wasmtime-wasi-http are now the same across wasip2/wasip3 and no longer require separate implementations/structures. #13810 #13812 #13835
- Wasmtime will now use the process_madvise syscall on Linux where available which can improve the performance of the pooling allocator when the deallocation batch size is configured to larger than 1. #13830
- Synchronous cancellation of streams/futures/subtasks now traps if the waitable was already in a waitable set. #13708
- Winch is now flagged to be compatible with component-model-async. #13845
- Wasmtime's pooling allocator now uses more sharding to reduce lock contention. #13840
- Wasmtime now requires Rust 1.95.0 to build. #13853
- Cranelift now has a uniform maximum size across all backends on the bounds of a function's stack frame. #13783
- Wasmtime's LinkerInstance for components now supports being reopened to gradually add more items. #13908
- The wasmtime-wasi crate's default configuration now denies creation of TCP/UDP sockets by default. #13936
- Wasmtime now configures async task context fields on realloc calls to zero. #13949
- Work has continued on continuous verification of Cranelift's lowering rules on AArch64. #13935 #13929 #13998
- Codegen for loads on AArch64 has been optimized slightly to improve sharing common sub-expressions. #13766
- Work continues on implementing the stack-switching proposal. #11717 #13996 #14052
- Permissions for wasi-filesystem in the implementation of the wasmtime-wasi crate have been simplified to either read-write or read-only for a directory. #14010
Fixed
- A late-drop of host-defined stream producers/consumers has been fixed. #13891
- Call hooks are now invoked around async yields when dealing with concurrent execution. #13871
- Extreme filesystem timestamps no longer cause panics. #13894
- An erroneous trap was fixed where an async-delivered write-closed event was sent to a future. #13914
- An erroneous trap where Wasmtime internally used the wrong thread id has been fixed. #13926
- Cross-component instance streams are no longer erroneously flagged as being intra-instance. #14018
- A panic in the wasmtime CLI with non-utf8 environment variables has been fixed. #14017
- Atomic waits on big-endian hosts have been fixed. #14027
- Enabling MPK with CoW images has been fixed. #14076

Fixed
- Stores can mix up type indices between engines. GHSA-hgjw-h833-99q9
- Preemption and traps during bulk operations enable breaking internal VM state. GHSA-2hw9-mc66-jc2q

Fixed
- Fix async-delivered write-closed events for futures. #13914
- Fix call hooks with yields and concurrent execution. #13871

Fixed
- Fixed publication of wasmtime-cli to crates.io. #13902

Fixed
- WASI hard links and renames check wasmtime-wasi's FilePerms for destination GHSA-4ch3-9j33-3pmj
- Explicit hint for generic call in wasmtime wit-bindgen. #13719

Added
- Added opt-in support for the WebAssembly branch-hinting proposal: the metadata.code.branch_hint custom section is parsed and used to mark cold blocks during Cranelift compilation, behind Config::wasm_branch_hinting (off by default). #13459
- Wasmtime's C API now supports type reflection of GC values. #13268
- Wasmtime now supports being compiled to arm64_32 platforms. #13259
- The cranelift-frontend crate,the RISC-V Cranelift backend, and Wasmtime's component-model-async feature now support no_std. #13401 #13479 #13533
- Wasmtime has initial support for the component model (implements "...") feature. #13361 #13497 #13513
- The wasmtime CLI now supports configuring the initial-cwd property of WASI. #13468
- The wasmtime serve subcommand now supports --header to set headers for the guest. #13471
- Wasmtime supports WASI 0.2.12, which notably includes exit-with-code in stable. #13536
- Wasmtime's component-model-async-bytes feature was renamed to component-model-bytes and now lifting/lowering using Bytes and BytesMut is directly supported. #13366
- Wasmtime now exposes the async call stack of components through its public API which can be used to determine which root task performed an import call. #13510
- Wasmtime now supports WASI 0.3.0 by default and the component-model-async wasm feature is now enabled by default. #13612
Changed
- Performance of bulk-data-transfer instructions such as {array,table,memory}.{copy,fill,init} have been improved. #13312 #13367 #13368 #13382 #13407 #13424 #13438 #13460 #13524
- Codegen for conditions based on ctz or clz has been optimized. #13332 #13343
- Cranelift now optimizes conditional branches of constant conditions into unconditional jumps. #13267 #13391
- Wasmtime's copying collector now has an in-wasm fast path for its bump allocator. #13323
- Wasmtime's GC implementation has been hardened in the face of GC heap corruption to avoid panicking or aborting. Corruption is returned as a WasmtimeBug type for embedders to detect and safely tear down the store/instance. #13321 #13320
- Cranelift's MemFlags type is now renamed to MemFlagsData, and AliasRegions are now stored in the DFG. #13353 #13354
- Wasmtime now handles OOM gracefully in more situations. #13371 #13372 #13374 #13375 #13376 #13377 #13378 #13379 #13388 #13413 #13412 #13414
- Cranelift's egraph rewrite pass now uses a concept of fuel to avoid exponential blowup of rewrites. #13390
- Wasmtime now consumes fuel in bulk-data-transfer instructions proportional to the size of the transfer. #13393 #13448
- Cranelift's ISLE format now supports structs as well as tuple fields for structs/enums. #13319 #13335
- Wasmtime's implementation of passive element and data segments is now optimized to perform more work in wasm itself and has a refactored representation on the host. #13394 #13444
- Heuristics for triggering GC in the DRC collector have been adjusted to avoid blowups seen in the wild. #13422
- Wasmtime's default garbage collector is now the copying collector instead of the deferred-reference-counting collector. This collector should be more performant in most situations and additionally have the ability to collect cycles. #13439
- Wasmtime now traps if a waitable is being waited on synchronously and additionally added to a waitable-set. #13415
- Wasmtime's behavior with subtask.cancel is now adjusted to resume the cancelled task immediately instead of always yielding. #13443
- The wasmtime_wasi_http::handler module has had its interface overhauled to better handle configuring the lifecycle of a request as it flows through the system in terms of timeouts and such. #13404
- Most of Wasmtime's instance initialization is now compiled into a per-module initialization function rather than happening through the host in Wasmtime. #13487
- The InstanceExportLookup trait has been generalized into ExportLookup, and this is now optionally implemented for wit_parser::ItemName with the wit-parser crate feature. #13505
- Many of Cranelift's *

Fixed
- Leak in WASIp1 fd_renumber implementation. GHSA-3p27-qvp9-27qf

Fixed
- Fixed regression with WASIp2 zero-delay clocks/timers: allow repeat calls to .ready() to make progress. #13511

Added
- Winch now respects the enable_nan_canonicalization setting. #12939
- Initial support for invoking component functions asynchronously has been added to the C API. #12973
- Cranelift's s390x backend implements more instructions from z17 and also implements more CLIF arithmetic overflow instructions. #12523 #12707
- Wasmtime's support for handling OOM in more APIs has expanded and is now documented as well. #12993 #12988 #13017 #13047 #13049 #13051 #13074 #13083 #13088 #13224
- The Component type now offers reflection APIs over the compiled in-memory view of instructions in the same manner Module does. #13073
- The wasmtime CLI now has a hot-blocks subcommand to explore a perf-recorded output and show hot basic blocks of WebAssembly instructions. #13077
- Wasmtime now has an initial implementation of a copying collector for GC, which notably enables collecting cycles unlike the DRC collector. #13093 #13107
- The WASI inherit_network and allow_ip_name_lookup options were added to the C API. #13145
- The C API now has the ability to select Winch as well as the RegallocAlgorithm in use. #13155
- The Wasmtime CLI now has a -Dmax-backtrace=N argument to control the number of frames captured. #13218
- Wasmtime now tracks whether there are any active async tasks within a store and provides an embedder API to learn when there are none left. #13246
- Cranelift now has an idempotent-store elimination pass. #13251
Changed
- Wasmtime's DRC collector has received some optimizations to get some wins on local benchmarking. #12969 #12974
- Wasmtime's C API can now be built without the gc crate feature of Wasmtime. #12805
- Wasmtime now has an implemented and improved grow-vs-collect heuristic to improve behavior of GC-using programs. #12942
- Cranelift on aarch64 now uses a more optimized frame layout for tail-call-only functions. #11608
- Wasmtime now supports a separate set of GC tunables different from the main set of tunables for linear memory to enable configuring it separately. #13080
- Wasmtime no longer uses pointer authentication instructions for the implementation of fibers due to issues on Android. #13118
- Wasmtime now requires Rust 1.93.0 to compile. #13127
- The behavior of using Wasmtime as a CMake subproject has been improved. #13157
- Reference types in the C/C++ API have been refactored and reorganized. #13154 #13235
- The Wasmtime CLI now warns about usage of wasi-common or wasi-threads as these components are slated for removal in Wasmtime 47.0.0. For more information see the associated RFC. #13264
- Inlining in Wasmtime now has a different set of configuration options, notably more values are packed into -Cinlining=.... #13250
Fixed
- The WASIp1-to-WASIp2 adapter now handles nonblocking I/O in fd_{read,write} more appropriately. #13111
- The Host header is injected less often for wasmtime-wasi-http. #13138
- Downcasts of funcref values now uses the correct type for imported functions. #13161
- The DRC allocator's memory usage during tracing has been reduced when there are large arrays. #13192
- The performance of reading stdin in WASI has been improved. #13256
- WASI path_open(TRUNCATE) bypasses FilePerms::WRITE host restriction. GHSA-2r75-cxrj-cmph

Fixed
- Panic when allocating a table exceeding the size of the host's address space. GHSA-p8xm-42r7-89xg

Added
- The wasmtime CLI now supports a -g flag which runs a built-in wasm program to host a gdbstub-compatible server (can be connected to with LLDB) to debug guest programs. #12756 #12771 #12856 #12859
- Wasmtime now has experimental support for the map<K, V> type in the component model. #12216
- Wasmtime's C API now supports wasm tag types. #12763 #12803
- Wasmtime's C API now supports exceptions. #12861
- Wasmtime's C API has more support for the GC proposal. #12914 #12915 #12916 #12917
- An initial implementation of the wasi:tls proposal for the 0.3.0-draft version has been added. #12834
Changed
- The demangle Cargo feature of the wasmtime crate is now compatible with no_std targets. #12740
- The wasmtime-wasi-tls-* crates are now merged into one crate with feature flags for each backend. #12780
- Wasmtime now requires Rust 1.92.0 or later to build. #12828
- The cranelift-codegen crate now compiles for no_std targets. #12812
- The csdb instruction, a defense-in-depth measure for spectre, is no longer emitted by default on aarch64 to match what peer runtimes are doing. In some situations this is known to provide up to a 6x performance boost on macOS as well. #12932
Fixed
- Wasmtime's native DWARF has been improved on aarch64 to support recovering values more frequently. #12779
- A significant number of minor issues have been fixed throughout this release. In addition to the security advisories found by LLMs there have also been a large number of other issues identified as well. Many minor fixes are present in this release for various situations for issues found in this manner.

Fixed
- Miscompiled guest heap access enables sandbox escape on aarch64 Cranelift. GHSA-jhxm-h53p-jm7w
- Wasmtime with Winch compiler backend may allow a sandbox-escaping memory access. GHSA-xx5w-cvp6-jv83
- Out-of-bounds write or crash when transcoding component model strings. GHSA-394w-hwhg-8vgm
- Host panic when Winch compiler executes table.fill. GHSA-q49f-xg75-m9xw
- Wasmtime segfault or unused out-of-sandbox load with f64x2.splat operator on x86-64. GHSA-qqfj-4vcm-26hv
- Improperly masked return value from table.grow with Winch compiler backend. GHSA-f984-pcp8-v2p7
- Panic when transcoding misaligned utf-16 strings. GHSA-jxhv-7h78-9775
- Panic when lifting flags component value. GHSA-m758-wjhj-p3jq
- Heap OOB read in component model UTF-16 to latin1+utf16 string transcoding. GHSA-hx6p-xpx3-jvvv
- Use-after-free bug after cloning wasmtime::Linker. GHSA-hfr4-7c6c-48w2
- Data leakage between pooling allocator instances. GHSA-6wgr-89rj-399p
- Host data leakage with 64-bit tables and Winch. GHSA-m9w2-8782-2946

Added
- Wasmtime now supports the WASIp3 snapshot 0.3.0-rc-2026-03-15. #12557
- The number of frames captured in backtrace collection can now be configured. #12542
- Wasmtime now supports fine-grained operator cost configuration for when fuel is enabled. #12541
- Configuring the gc_support option is now possible through the C API. #12630
- Configuring the concurrency_support option is now possible through the C API. #12703
- Debugging-related APIs have been added to access all modules and instances on a store. #12637
- All store entities now expose a "unique ID" for debugging purposes. #12645
- Cranelift's x64 backend now supports the cls instruction for all integer types. #12644
Changed
- Internal refactoring and support necessary for handling OOM gracefully throughout the runtime is proceeding apace. New APIs such as FuncType::try_new are available in addition to many internal changes. #12530 #12537 (... and many more ...)
- Wasmtime's representation of stack frames in the debugging API no longer borrows the store itself and is instead represented as a handle. #12566
- Wasmtime now unconditionally sets SO_REUSEADDR for guest-bound sockets. #12597
- Cranelift now supports more VRegs which means effectively that larger functions will be compilable by default rather than returning a "function too large" error. #12611
- WASIp3 implementations now limit returned memory by default for randomness and HTTP headers. #12745 #12761
Fixed
- Running wasmtime wizer over components with modules that contain an _initialize function no longer removes the function to preserve the validity of the component. #12540
- Borrow state for host async tasks is now handled more correctly throughout Wasmtime, especially in the face of cancellation. #12550
- Bindings generation now accounts for the fact that future and stream are not cloneable types. #12155
- The impementation of UDP in WASIp2 has had some wakeup-related bugs fixed. #12629
- Cancellation of host subtasks for component-model-async has been improved and works more reliably. #12640
- Subtask management for component-model-async now no longer reparents which fixes a number spec-related divergences. #12570
- Converting a wasmtime::Error into anyhow::Error and using downcast has been fixed. #12689
- Async stream/future read/write cancellation has had some corner cases fixed. #12704
- Cranelift's timing infrastructure is now more robust in the face of buggy system clocks. #12709
- The currently running guest task has been corrected in a number of cases related to component-model-async and cooperative threading. #12718 #12735 #12736 #12737
- An issue of lost wakeups with the WASIp3 stdin implementation has been fixed. #12745

Fixed
- Fix some minor bindgen! issues with anyhow: true #12658

Added
- Cranelift now supports bitwise operations on floats on aarch64. #12326
- Cranelift now supports NaN canonicalization of f16 and f128. #12337
- Wasmtime has gained minimal support to implement fixed-length lists in the component model being communicated between composed components. #10619
- Wasmtime's Error and Result types are now built-in to the wasmtime crate and are no longer defined by the anyhow crate. Wasmtime exports a mostly-compatible anyhow-like API at wasmtime::error which is used instead. Wasmtime's own Error handles OOM internally and is foundational part of Wasmtime's work-in-progress support to gracefully handle OOM. #12309
- Wasmtime now exports an extension trait to convert anyhow::Result<T> into wasmtime::Result<T>. #12255
- Wasmtime supports a new bindgen! option to generate bindings specifically with anyhow::Result instead of wasmtime::Result. #12331
- The Nvidia-Cuda execution provider is now supported for the wasi-nn onnx backend. #12044
- Non-exported and private entities can now be accessed through the debugger API. #12367
- A new Store::try_new API has been added which handles OOM. #12415
- Initial configuration knobs for record-and-replay support have been added. #12375
- Cranelift's s390x backend now has support for instructions added in z17. #12319
- Wasmtime's implementation of fibers can now be compiled on riscv32imac platforms. #12506
- Wasmtime's implementation of WASI now correctly limits resource consumption on behalf of the guest, such as host-allocated memory, by default. This means that some behaviors previously allowed by Wasmtime are now disallowed by default if they rely on transferring a large amount of data from the guest to the host. Additionally calls to wasi:random/random.get-random-bytes, for example, now have limits in place by default to avoid allocating too much memory on the host. For more information on this see the related security advisory with further details on knobs added and what behaviors are now restricted by default. GHSA-852m-cvvp-9p4w
Changed
- Reentrance rules for WebAssembly components have changed in accordance with upstream specification changes. Embeddings are not expected to be affected, but please reach out if you find problems. #12349
- Wasmtime's Config::async_support option is now removed and no longer necessary. Embeddings can likely just remove turning this on and everything should keep working like normal. #12371
- Wasmtime now supports Config::concurrency_support as a knob to enable or disable *_concurrent APIs at runtime when the component-model-async crate feature is enabled. #12416
- The post_return-style functions in Wasmtime's API are now noops and will be removed in the future. #12498
- Translation of global.get of a defined, immutable global is now turned into a CLIF constant. #12234
- The wasmtime-wasi-nn crate's dependency on ort has been updated. #12162
- Error bounds requiring using hyper::Error in wasmtime-wasi-http have been relaxed to taking E: Into<ErrorCode> instead. #12227
- The cranelift-assembler-x64, and cranelift-isle crates now supports no_std targets. The cranelift-codegen crate now mostly supports no_std, but not entirely. #12222 #12235 #12236
- Android release binaries are now compiled with a larger page size configured. #12246
- Implicit binds are now allowed for WASIp3 sockets. #12225
- Wasmtime's implementation of component-model-async now correctly checks for whether tasks are allowed to block in all guest-to-guest situations. #12282
- The wasmtime-wasi-tls crate now has an OpenSSL backend. #12228
- Wasmtime's OutOfMemory error now keeps track of the attempted allocation size that failed. #12351
- Wasmtime's *_unchecked functions now work with MaybeUninit<ValRaw> instead of ValRaw directly. #12366
- Wasmtime now requires Rust 1.91.0 to compile. #12392
- Wasmtime's management of component-model-async tasks is now consistently done in all boundaries between guest/host tasks. #12379
Fixed
- The HeapType::matches implem

Fixed
- Fix an incorrect mid-end optimization rule that could cause a compiler panic due to mismatched types. #12504

Fixed
- Reduce the dependencies of the wasmtime-internal-jit-icache-coherence crate. #12446

Fixed
- Fixed a bug in lowering of f64.copysign on x86-64 whereby when combined with an f64.load, the resulting machine code could read 16 bytes rather than 8 bytes. This could result in a segfault when Wasmtime is configured without signals-based traps.

Added
- Support for {Future,Stream}Any in the component model has improved. #12142
- Wasmtime has initial support for breakpoints and single-stepping with the debug feature for guest programs. #12133
- Wasmtime has begun adding a new Error type which is similar to anyhow::Error but supports gracefully handling OOM. Wasmtime still uses anyhow::Error but this will change in the future to wasmtime::Error which will be a distinct type. #12163
- An initial top-level crate for async-debugging guest programs has been added. #12183
Changed
- Cranelift now optimizes redundant select + icmp instructions. #12135
- Synchronous component model functions can no longer block before returning. This implements a change in the upstream specification to the upcoming async support in the component model which places stricter restrictions on non-async functions and their ability to perform blocking operations. #12043
- Frame iteration in debug mode now visits all activations which enables seeing all frames from recursive wasm calls. #12176
- Wasmtime now requires Rust 1.90.0 or later. #12167
- Intra-component stream/future reads/writes are now allowed for simple data types. #12181
- The POLL callback code has been removed from the canonical ABI for async functions and the waitable-set.poll function no longer yields. #12182
- Guest-to-guest adapters injected by Wasmtime now have improved trapping error messages. #12215
Fixed
- #[derive(Lift)] for enums with exactly 256 cases has been fixed. #12140
- With component-model-async support recursively calling a guest from a host function has now been fixed. #12152

Fixed
- A possible stack overflow in the x64 backend with cmp emission has been fixed. #12333
- Some ISLE optimization rules which created erroneous IR for vector inputs have been fixed. #12179 #12335
- The x64 lowering of shld has been fixed for some edge caxes. #12321

Changed
- This release is a test of Wasmtime's CI-based crate publishing infrastructure. Wasmtime is switching to crates.io-based trusted publishing for this release and is testing that everything works. #12257

Added
- WASIp3 support for wasi:http now implements Response::from_http to convert from standard Rust types to WASI types. #12063
- Cranelift now supports a "patchable" ABI which has a maximum number of arguments and clobbers no registers. This is paired as well with a new patchable_call instruction which supports being turned into NOPs at runtime. #12061 #12101
Changed
- Support for the WebAssembly threads proposal is now classified as tier 2 by default. Additionally creation of SharedMemory is disabled by deafult behind a new config knob/CLI flag. #12036
- A variety of peephole-style optimizations have been added to Cranelift's optimization passes. #11994 #11995 #11996 #11997 #11998 #11999 #12000 #12006 #12008
- Component host functions have been slightly optimized to remove an Arc clone and reduce contention. #11987
- Support for component-model-async has been updated to account for the changes specified in WebAssembly/component-model#578. This means that historical binaries using WASIp3, for example, are no longer valid. Recompilation of historical components will be required and source-level changes may also be required in some circumstances. #12031 #12043
- The UnsyncBoxBody type is now used everywhere in wasmtime-wasi-http instead of just in the wasip3 support. #12060
- Initial groundwork for gracefully handling OOM (e.g. returning an error instead of aborting) has been added. #12070 #12089
- Wasmtime will create a private copy of code memory when guest debugging is enabled to assist with modifying code when adding/removing breakpoints. #12051
- The ResourceTable type will no longer use Tombstone when compiled in debug mode. #12114
- Intra-component future/stream reads/writes will now trap instead of accidentally being allowed. #12117
- Cranelift optimization rules have been tweaked after it was discovered that they could pessimize code containing long chains of computations. #12116
Fixed
- Compilation of i8x16.popcnt has been fixed in Winch for some potential inputs. #12010
- A panic in Instance::prepare_call for some component-model-async situations has been fixed. #12054
- An off-by-one error for lifting/lowering enums/variants with 255 cases has been fixed. #12066
- Restarting the read of a host future after cancellation has been fixed. #12093
- Compilation for OpenBSD on x86_64 has been fixed. #12097
- Components containing a module type which exoprts a tag are now supported. #12125

Fixed
- Compiling the debug feature without the gc feature enabled has been fixed. #12074

Added
- Initial work has begun to support WebAssembly-level debugging natively in Wasmtime. This is intended to complement today's preexisting DWARF-level debugging, but this work will be portable and operate at the WebAssembly level of abstraction rather than the machine-level. Note that this work is not yet complete at this time but is expected to get filled out over the coming releases. #11768 #11769 #11873 #11892 #11895
- The pooling allocator now exposes more metrics about unused slots. #11789
- The Wizer and component-init projects have been merged into Wasmtime under a new wasmtime wizer CLI subcommand and wasmtime-wizer crate. This is mostly a drop-in replacement for both with a minor caveat that the initialization function is now called wizer-initialize instead of wizer.initialize to be compatible with components. #11805 #11851 #11853 #11855 #11857 #11863 #11866 #11867 #11877 #11876 #11878 #11891 #11897 #11898
- The Config::wasm_feature method is now public. #11812
- Enabling the wasm exceptions proposal is now exposed in the C API. #11861
- The wasmtime crate now has a custom-sync-primitives Cargo feature which enables using custom synchronization primitives defined by the embedder. This is useful in no_std targets where the default panic-on-contention primitives are not appropriate. #11836
- Wasmtime now supports unsafe intrinsics to be used for compile-time builtins. This can be used to provide give low-level access to host APIs/memory to a guest program in a controlled fashion. #11825 #11918
- The signals_based_traps configuration option is now exposed in the C API. #11879
- A new EqRef::from_i31 function has been added. #11884
- The wasmtime serve subcommand will, by default, now reuse instances when used with WASIp3 components. This increases throughput and additionally showcases the concurrent features of WASIp3. This can be opted-out-of on the CLI as well. #11807
- The C++ API for components has been filled out and implemented. #11880 #11889 #11988
- A new ResourceDynamic type, similar to Resource<T>, has been added to support host resources that have a dynamic tag at runtime rather than a statically known tag at compile time. This is then used to implement resources in the C/C++ API as well. #11885 #11920
- The C/C++ API of Wasmtime now supports the custom-page-sizes wasm proposal. #11890
- Initial support has been added for the cooperative multithreading component model proposal in Wasmtime, built on async primitives. #11751
- The epoch_deadline_callback Rust API has been bound in C++. #11945
- A new Request::into_http helper has been added to the WASIp3 implementation of wasi:http. #11843
- A define_unknown_imports_as_traps function has been added to the C API. #11962
- A callback-based implementation of stdout and stderr has been added to the C API for WASI configuration. #11965
Changed
- Running async functions in the component model now operates at the Store-level of abstraction rather than an Instance. #11796
- The wasmtime serve subcommand no longer mistakenly spawns an epoch thread per-request and instead uses a single epoch thread. #11817
- The component-model-async Cargo feature is now on-by-default. Note that it is still gated at runtime by default. Also note that Wasmtime 39 does not include #12031 which means that components using async produced with the latest wasm-tools will not run in Wasmtime 39. To run async components it's recommended to pin to a historical version of wasm-tools and guest toolchains for now. #11822
- Bindings generated by wiggle no longer use async_trait. #11839
- Wasmtime's documentation now has an example of a plugin system using Wasmtime. #11848
- Profiling with perfmap or jitdump now uses O_APPEND to be more amenable to other engines in the same process also using perfmap/jitdump. #11865
- The wasmtime-wasi-http crate now uses UnsyncBoxBody to clarify that Sync is not required. #11941
- A . character is now used instead of / int he bindgen! macro to separate interface m

Fixed
- Prevent using shared memories with Memory. CVE-2025-64345

Fixed
- Fix possible host crash with host-to-wasm component intrinsics CVE-2025-62711

Changed
- This repository is attempting to start out using GitHub's "Immutable Releases" feature with this release, and this'll be the first release, assuming all goes well, that has this enabled. #11901
Fixed
- Fix compatibility with the Go runtime on Windows for exceptions. #11892

Fixed
- Fixed some automation that went wrong with the 38.0.0 release.

Fixed
- Fix a memory leak in the C API when using anyref or externref. CVE-2025-61670.

Fixed
- Cranelift's cranelift-jit crate now properly applies relocations to ADRP instructions on aarch64; a zero-extension on the offset was fixed to properly sign-extend instead. #11734

Added
- Wasmtime now fully implements the WebAssembly exception-handling proposal. Support is still disabled by default but is ready for testing. The proposal will be enabled by default in a future release of Wasmtime. #11326
- An initial implementation of WASIp3 is available for the 0.3.0-rc-2025-08-15 tag made for the WASIp3 release. Note that this is not production ready yet but is an excellent time to start kicking the tires in preparation for an upcoming officialy WASIp3 0.3.0 release. Users of the CLI can opt-in with -Sp3 -Wcomponent-model-async. #11406 #11423 #11443
- Wasmtime has initial support for the Linux PAGEMAP_SCAN ioctl which can greatly improve instantiation throughput in scenarios with a high number of instantiations and short instance lifetime. This support is disabled by default but will likely be enabled by default in a future release. #11372 #11433
- GC support can now be configured in Config and not only through crate features through Config::gc_support. #11463
- Wasmtime now supports reading metrics of the pooling allocator at runtime. #11490
- The ManuallyRooted type is now replaced with OwnedRooted which is intended to make management of GC object lifetimes on the host easier. #11514
- Wasmtime's documentation of the C++ embedding API and examples has been expanded. #11569
- Wasmtime's support for the stack-switching WebAssembly proposal continues to progress on x86_64 Linux. #11003
Changed
- The preview0 and preview1 modules and features in the wasmtime-wasi crate are now called p0 and p1. #11380
- Release artifacts for the C API are now unconditionally built with unwind tables. #11383
- Wasmtime now requires Rust 1.87.0 or later to build. #11396
- The component-model-async gated AbortHandle is now named JoinHandle. #11414
- Wasmtime's internal implementation details are now async in many more locations to help ensure the implementation is more sound. #11411 #11416 #11442 #11444 #11457 #11460 #11461 #11468 #11470 #11481 #11496
- Component-model-async primitives such as streams, tasks, etc, now use the same table as resources in a component. This means that guest-visible allocated indices are updated slightly. #11374
- Wasmtime's precompiled binaries available from CI now include the component-model-async feature. #11429
- C API release artifacts are now built with LTO so they have a smaller size. #11483
- Code can no longer be loaded on x86_64-unknown-none by default without opting-in to a contract that either the host is compiled with SSE2 support or wasm is compiled with enough features that libcalls aren't used. #11553
- Host support for component model async futures/streams has been updated to a new API. #11515
Fixed
- GC of dead DWARF has been improved. #11402
- Wasm-gc branching instructions now correctly check for fuel. #11426
- The array.new_default instruction now checks for fuel/epochs in its inner loop. #11428
- The "min" C API artifacts now have correct headers. #11479
- GC OOM during const eval no longer panics. #11557
- Wasmtime now properly respects a disabled std feature even on targets which have std available. #11568

Fixed
- Wasmtime will no longer panic in the pooling allocator when in near-OOM conditions related to resetting the linear memory of a slot. #11510

Added
- Accessors for internal WASI-related contexts are added to wasmtime_wasi::WasiCtx to account for refactorings that happened in this release. #11473
Changed
- Release artifacts for the C API are now smaller than the previous release to assist with redistribution as-is. #11483

Added
- Cranelift's has initial support for inlining between functions. Wasmtime additionally now has support for inlining as well, for example between modules in a component. #11210 #11239 #11228 #11269 #11283
- The async proposal for the Component Model is now fully implemented in Wasmtime with a number of WASIp3 interfaces implemented. The implementation is still off-by-default and the implementation of WASIp3 is not fully complete, but is remains suitable for testing. #11127 #11136 #11137 #11238 #11221 #11250 #11257 #11291 #11325
Changed
- Users who implemented WasiHttpView::is_forbidden_header from wasmtime-wasi-http now need to include DEFAULT_FORBIDDEN_HEADERS, e.g. DEFAULT_FORBIDDEN_HEADERS.contains(name) || name.as_str() == "custom-forbidden-header" #11292
- Cranelift's incremental cache has received some optimizations. #11186
- Wasmtime's internal implementations of WebAssembly primitives has been refactored to be modeled with safer internal primitives. #11211 #11212 #11216 #11229 #11215 #11254 #11255 #11319 #11320
- Detection of native hardware features has been refactored on s390x. #11220
- Further progress has been made towards an implementation of the WebAssembly exceptions proposal, although it is not yet complete. #11230 #11321
- Cranelift's assembler for x64 now supports EVEX encoding. #11153 #11270 #11303
- The default implementation of send_request in the wasmtime-wasi-http crate is now behind an on-by-default feature gate. #11323
- Configuration of the bindgen! macro has been redesigned to more consistently configure per-function options such as whether or not it's async. #11328
- Initial support fo mutatis has been added to Wasmtime's fuzzers. #11290
- The debug-builtins crate feature of wasmtime no compiles on no_std targets. #11304
Fixed
- Deserializing external modules no long unnecessarily requires the allocation to be aligned. #11306
- A CMake linker error and warning when using the C API on macOS has been fixed. #11293 #11315
- The C API declaration of wasmtime_component_linker_instance_add_func has been fixed. #11327
- The calculation of reachable DWARF has been fixed. #11338

Added
- A new InputFile type has been added for specifying stdin as a file in WASI. #10968
- Conditional branches to unconditional traps are now translated to conditional traps during legalization. #10988
- The TE HTTP header can now be specified by guests. #11002
- Winch on AArch64 should now pass all WebAssembly MVP tests. Note that it is still not yet Tier 1 at this time, however. #10829 #11013 #11031 #11051
- The x64 backend now has lowering rules for {add,sub,or,and} mem, imm #11043
- Initial support for WASIp2 in the C API has started to land. #11055 #11172
- Initial support for GC support in the component model has started to land (note that it is not finished yet). #10967 #11020
- The wasmtime-wasi-nn crate now has a feature to use a custom ONNX runtime. #11060
- Cranelift now optimizes division-by-constant operations to no longer use division. #11129
- A native-tls backend has been added for the wasi-tls implementation. #11064
Changed
- Many more instructions for the x64 backend in Cranelift were migrated to the new assembler. #10927 #10928 #10918 #10946 #10954 #10958 #10971 #10942 #10975 #11017 #10898 #10836 ... (and more)
- Wasmtime internally uses Pin for VM data structures to make the internal implementations more sound to use. This has no effect on the public API of Wasmtime. #10934 #10937 #10943 #10959 #11042
- Fused adapters between components now transfer the enum component model type more efficiently. #10939
- Filenames of --emit-clif now match the symbol names found in *.cwasm artifacts and include the function name as well. #10947 #11040
- Wasmtime-internal crates are now all named wasmtime-internal-* to even further discourage their use. #10963
- Codegen of conditional traps with float compares has been improved. #10966
- More patterns are now optimized in ISLE mid-end rules. #10978 #10979 #11173
- Winch's support for constants/scratch registers has been improved internally. #10986 #10998
- The C API artifacts on Windows are now produced with Clang instead of cl.exe. #10890
- WebAssembly operand types are now taken into account during translation to optimize codegen better in the face of subtyping. #11030
- The behavior of blocking-write-and-flush has been updated during flushing when closed is found. #11018
- WASI WITs have been updated to 0.2.6. #11049
- OpenVINO has been updated to v2025.1. #11054
- The size of the wasmtime.addrmap section in *.cwasm artifacts has been shrunk slightly. #11126
- Authorities in wasmtime-wasi-http can now contain the : character. #11145
- Wasmtime now requires Rust 1.86 to compile. #11142
- Wasmtime's DRC collector has been optimized and has a new more efficient means of managing the set of over-approximated roots on the stack. #11144 #11148 #11167 #11168 #11169 #11175
- The ComponentType trait in Wasmtime now requires the Send and Sync bounds for all implementors. #11160
- The V128 type is now usable on platforms other than aarch64 and x86_64. #11165
- Wasmtime's policy on unsafe code and guidelines has been added. #11177
- The std crate will no longer implicitly be used on cfg(unix) and cfg(windows) targets when the std Cargo feature is disabled. This means that these platforms now require std to be enabled to use the platform-specific implementation of linear memory, for example. #11152
Fixed
- A panic when optimizing icmp with vectors has been fixed. #10948
- A panic when lowering scalar_to_vector with i16x8 types has been fixed. #10949
- The vector state register is now considered clobbered by calls on riscv64 to ensure it's updated across calls. #11048
- An instance of gdb crashing on DWARF emitted by Wasmtime has been fixed. #11077
- Fix a panic in the host caused by preview1 guests using fd_renumber. CVE-2025-53901.
- Fix a panic in the preview1 adapter caused by guests using fd_renumber. #11277

Fixed
- Fix a panic with host-defined tables/globals and concrete reference types. #11103

Added
- Support for SIMD in the Pulley interpreter can now be disabled at compile-time to shrink the size of the final binary. #10727
- The C API now has wasmtime_trap_new_code to create a wasm_trap_t from its code. #10765
- Winch's support for x86_64 is now classified with tier 1 support in Wasmtime. #10755
- Winch's support for aarch64 now implements stack checks to pass many more spec tests. #10763
- Cranelift's s390x backend now has full support for the f128 type. #10774
- Wasmtime's C API for the component model has initial support for calling functions. #10697 #10841 #10858 #10864 #10877
- The wasmtime wast command now has a --generate-dwarf flag to show filename/line number information for backtraces. #10780
Changed
- The shape of bindgen!-generated add_to_linker functions has changed with the removal of GetHost and replacement of a HasData trait. For more information see the associated PR. #10770
- Wasmtime's Store<T> now requires that T: 'static. This is done in preparation for merging WASIp3 work to the main repository with some more information on the associated PR. #10760
- The wasmtime::component::Instance::instance_pre method is now public. #10761
- Wasmtime and Cranelift's minimnum supported version of Rust (MSRV) is now 1.85.0. #10785
- Cranelift's debugtrap on aarch64 now generates brk #0xf000 for debuggers to recognize it. #10813
- The wasi-http implementation no longer generates a trap if the handle to receive the response on the host is dropped early. #10833
- The wasmtime serve command will now send some boilerplate descriptive HTML on a 500 server error instead of nothing. #10851
- A significant amount of work has gone into the new assembler for the x64 backend. Too many PRs to list here but progress continues apace at defining all machine instructions in a standalone crate.
- Cranelift will now reject unimplemented big-endian loads/stores on backends that do not implement this functionality. #10863
- The wasmtime explore generated HTML handles large modules better now. #10892
- Wasmtime's internal representation of wasmtime::Func has changed and a previous optimization of Func::call has been lost. If affected it'd recommended to use Func::call_unchecked instead or to open an issue. #10897

Added
- Cranelift now has initial support for try_call and try_call_indirect instructions, to be used in the future for the WebAssembly exception-handling proposal. Wasmtime does not yet implement this proposal yet. #10510 #10557 #10593
- Cranelift can now optimize some simple possibly-side-effectful instructions, such as division. #10524
- Wasmtime now supports --invoke for components using the WAVE format. #10054
- Initial support for the Component Model has landed in Wasmtime's C API. Note that the API is not yet feature-complete, however. #10566 #10598 #10651 #10675
- Wasmtime's C++ API is now available from this repository and the bytecodealliance/wasmtime-cpp repository has been archived. Additionally the monolithic wasmtime.hh header file has been split into separate header files. #10582 #10600
- Wasmtime's cookbook-style documentation has been expanded. #10630
- Wasmtime's now supports custom yield behavior when using epoch interrupts. #10671
Changed
- Wasmtime's bindgen now type-checks export functions in the constructor of the generated {Worldname}Pre or {Worldname} structs, rather than at the call of the export function. #10610
- Wasmtime's component::Component and component::Instance now have consistient get_export and get_export_index methods, which return (ComponentItem, ComponentExportIndex) and ComponentExportIndex, respectively. #10597
- On failure, wasmtime serve gives an internal server error response, rather than closing the connection. #10645
- Cranelift's single-pass allocator has been disabled due to being unable to support internal refactorings in preparation for the WebAssembly exceptions proposal. Re-enabling this allocator is tracked at regalloc2#217 for those interested. #10554
- Wasmtime's {Array,Extern,Struct}Ref functions will now automatically trigger a GC. #10560
- Wasmtime's GC heaps now use the same translation techniques as linear memories meaning they have far fewer bounds-checks than before. #10503
- Wasmtime's implementation of WASIp2 has moved to wasmtime_wasi::p2 from the root of the crate. #10073
- Wasmtime will no longer emit calls to Cranelift-defined "libcalls" and instead everything goes through Wasmtime's libcall mechanism instead, paving the way for a future change for more efficient stack limit checking in wasm. This can also improve deserialize-from-disk times and improve page cache usage for modules that use libcalls as relocations are no longer necessary. #10657
- Configuration of caching can now be done through an API instead of exclusively through a configuration file. Additionally cache-related APIs in Config have changed. #10665
- Resources in the Component Model are now stored in a single table per-instance instead of per-type tables. Guests will see a different pattern of index allocation but this is not expected to cause any issues at runtime. #10701
Fixed
- Some math intrinsics have been fixed when compiled by Rust 1.87+. #10534
- Component model libcalls correctly handle platform-specific argument extension in ABIs. #10540
- An off-by-one issue with DWARF debuginfo has been fixed. #10570
- The Config::target method is no longer gated by a #[cfg] for an enabled compiler, it can be used when only the runtime feature is available. #10618
- An issue with "simulated" DWARF has been fixed. #10681
- C/C++ headers are now tested that they can be included in isolation, and a number of issues have been fixed. #10694

Added
- {Module,Component}::deserialize_raw can now be used to deserialize an in-memory module while relying on external management of the memory. #10321
- An initial implementation of wasi-tls has been added. #10249
- The wasmtime CLI now supports hexadecimal integer CLI arguments. #10360
- Cranelift now supports a log2_min_function_alignment flag. #10391
- A new wasmtime objdump subcommand has been added to help explore and debug *.cwasm files. #10405
- Support for the pooling allocator has been added to the C API. #10484
- Support for the guest profiler with the component model has been added. #10507
Changed
- Cranelift MemFlags now has a can_move flag which restricts whether a load or store can be moved. #10340
- The .text size of Pulley *.cwasm files should be smaller with less padding. #10285
- The wasmtime serve subcommand now implements a graceful shutdown on ctrl-c. #10394
- Stack maps used for GC are now stored in a serialized binary format that is faster to deserialize. #10404
- The aegraph implementation in Cranelift has been simplified to remove the union-find and canonical eclass IDs. #10471
- The store_list and load_list helpers have been specialized in components for f32 and f64. #9892
- Cranelift now removes block params on critical-edge blocks. #10485
- The Linker::define_unknown_imports_as_default_values API now supports defining defaults for more kinds of items. #10500
- Wasmtime now requires Rust 1.84.0 to compile. #10520
Fixed
- Winch compilation of extadd instructions has been fixed. #10337
- Fix an issue with DRC collector's barriers. #10371
- Loads on (ref null none) that can trap are now performed. #10372
- Fix reference count management in AnyRef::from_raw. #10374
- An issue with multi-value returns in Winch has been fixed. #10370
- A panic at compile-time from an overflowing shift has been fixed when targeting aarch64. #10382
- The wasmtime serve command no longer panics when handle returns before calling set. #10387
- Winch compilation of replace_lane instructions with floats has been fixed. #10393
- An invalid integer-shift optimization on vector types has been removed. #10413
- The DWARF loclist to exprloc optimization has been fixed. #10400
- Objects in the DRC collector are now transitively dec-ref's when collected. #10401
- A bug with GC rec gropus and registration in an Engine has been fixed. #10435
- A bug related to GC arrays of GC refs misreported their count of GC edges has been fixed. #10453
- A bug related to appropriately adding stack maps for all GC variables has been fixed. #10456 #10468
- A bug with array.fill has been fixed. #10470
- GC structs are no longer reordered to optimize their size to fix subtyping. #10463
- Panics related to exceptions and components being mixed has been fixed. #10473
- Winch stack parameter alignment has been fixed. #10513
- Rendering inline function frames in a trap backtrace has been fixed. #10523

Added
- Winch's implementation of the SIMD proposal for WebAssembly is now feature-complete (but still being fuzzed). #10180 #10170 #10203 #10202 #10210 #10213 #10224 #10205 #10226 #10228 #10236 #10241 #10243 #10247 #10271 #10284 #10288 #10296
- The pytorch implementation in wasmtime-wasi-nn now has GPU support. #10204
- Cranelift now supports emitting the AArch64 extr instruction. #10229
- Cranelift now supports emitting the x64 shld instruction. #10233
- Initial support for the stack-switching proposal has started to land, but it is not complete just yet. #10251 #10265 #10255
Changed
- Pulley's implementation of loads/stores to linear memory has changed to better support optimizations and reduction of interpreter opcodes in the final binary. #10154
- Cranelift's verifier now ensures that integers used as address types have the correct width. #10209
- Wasmtime and Cranelift's minimum supported version of Rust is now 1.83.0. #10264
- Wasmtime now mentions the filename when the input cannot be opened on the CLI. #10292
- All types are now generated in component::bindgen!, even if they're not reachable. #10311
- Tables allocated with the system allocator now use alloc_zeroed (aka calloc) for allocation. #10313
Fixed
- GC: the is-null-or-i31ref checks have been fixed. #10221
- GC: an incorrect assertion and canonicalized types for runtime usage has been fixed. #10223
- GC: subtype checks for imported globals during instantiation have been fixed. #10304
- GC: exposing references to wasm in the gc_alloc_raw libcall has been fixed. #10322
- Winch's fuel checks correctly sync fuel before the check now. #10231
- Winch's treatment of stores and other trapping ops has been fixed on AArch64. #10201
- Winch's handling of the shadow stack pointer has been fixed on AArch64. #10263
- Winch's handling of address calculations has been fixed on AArch64. #10297
- Winch's handling of multivalue return of constants has ben fixed. #10315

Fixed
- MinGW C API builds are now built with a newer version of GCC which seems to fix an issue caused by #9929. #10290
Changed
- The cranelift-codegen crate now no longer depends on arbitrary, a now-unnecessary dependency. #10217

Fixed
- Fixes an issue building the cranelift-assembler-x64 crate on Windows when the Rust toolchain is on a different drive than the project using wasmtime. For more details, see the Zulip discussion. #10270

Added
- New wasmtime-wasi-io crate provides a #![no_std] wasi:io implementation, factored out of wasmtime-wasi. Users of wasmtime-wasi don't have to depend on this new crate. #10036
- Wasmtime's interpreter, Pulley, is now complete and has been listed as tier 2. #9897 #9884 #9943 #9944 #9983 #9966 #9935 #10034 #10057 #10095
- Wasmtime's CI now checks that the repository builds for aarch64-apple-ios. Note that no tests are run for this target, so it's still tier 3. #9888
- Winch's support for AArch64 and simd on x64 have continued to progress well. Winch additionally now fully supports the threads WebAssembly proposal. #9889 #9970 #9950 #9987 #9990 #9959 #10008 #10028 #10029 #10023 #10042 #10050 #10039 #10082 #10092 #10109 #10148 #10147
- The memory64 WebAssembly feature is now enabled by default. This WebAssembly proposal is now considered a tier 1 feature. #9937 #10159
- Wasmtime's full test suite and CI now includes 32-bit platforms such as x86 and armv7 Linux. These platforms have been added to tier 3 status and use Pulley as their execution backend. #10025
- Initial experimental support for WASIp3 and async features of the Component Model have started to land. These features are not yet ready for general-purpose use. #10044 #10047 #10083 #10103
- The wasmtime CLI now supports using a TOML configuration file via --config in addition to CLI options. #9811 #10132
- Initial support for a new assembler on x64 has been added. #10110 #10178
Changed
- wasmtime-wasi split the WasiView trait into IoView and WasiView, and wasmtime-wasi-http re-uses IoView in WasiHttpView. Details on porting for embedders in PR. #10016
- wasmtime-wasi renamed some exported types and traits. Embedders which use Pollable, InputStream, OutputStream, Subscribe, HostInputStream, HostOutputStream, PollableFuture, or ClosureFuture from that crate will need to rename those imports to their new names, describe in PR. #10036
- Components using a 64-bit linear memory should never have worked before, but they're now rejected earlier in the validation process. #9952
- Module validation is now deterministic in the face of multiple errors. #9947
- Wasmtime's minimum supported version of Rust is now 1.82.0. #9956
- Cranelift will now deduplicate trap[n]z instructions. #10004
- The --emit-clif option to wasmtime compile now emits post-optimization CLIF. #10011
- The signals-based-traps Cargo feature has been removed in favor of auto-detection of available features based on the #[cfg] directives available for the target platform. #9941
- The async_stack_zeroing configuration knob now covers all stack allocations, not just those from the pooling allocator. #10027
- Wasmtime should work-by-default on more platforms, even those where Cranelift has no support for the architecture. This is done by ensuring some architecture and platform-specific bits are removed on unknown platforms (and Pulley is used instead). #10107
- Wasmtime now compiles on platforms missing 64-bit atomics. #10134
Fixed
- Fixed a missing case for Ref::matches_ty should return true. #9985
- A bug with using the single_pass register allocation algorithm on x64/s390x has been fixed by refactoring how branches are represented. #10086 #10087
- A bug with argument extensions on riscv64 has been fixed. #10069
- The PartialEq implementation for RegisteredType has been fixed. #10091
- The output of component::bindgen! now works with #![no_std] crates. #10105
- Fix wasmtime wast when combined with --fuel. #10121
- The wat feature of the C API is now plumbed correctly in a few more locations. #10124
- Spurious wake-ups in blocking_* methods of InputStream and OutputStream have been fixed. #10113

Added
- The wasmtime explore subcommand now supports *.wat files. #8314
- Wasmtime now supports DWARF Fission *.dwp files. #8055
- The wasmtime crate now supports #![no_std], and more information about this transition can be found in #8341. #8463 #8483 #8485 #8528 #8533
- A Config knob is now available for one-entry call_indirect caching to speed up modules with lots of call_indirect instructions. #8509
- Cranelift's riscv64 backend has initial support for the Zfa Extension. #8536
- The WebAssembly tail-calls proposal is now enabled by default when using the Cranelift backend, except for the s390x architecture. #8540
Changed
- Support for NaN canonicalization on x64 has been optimized to avoid branches. #8313
- The bindgen! macro now defaults to assuming imports cannot trap, but this behavior is configurable at macro-generation time. #8310
- The fd_{read,write} implementations in wasmtime-wasi have been optimized. #8303
- The wasmtime-wasi-http crate has been refactored and has improved documentation. #8332 #8347
- Unused with parameters in bindgen! now generate an error. #8371
- The fd_read implementation in wasmtime-wasi now only reads into a single iovec per call. #8415
- The wasmtime_val_t type in the C API no longer holds any allocations. This type must still be manually managed to properly unroot values, however. #8451
- Add an optimized "sleep" path for poll_oneoff to wasmtime-wasi. #8429
- The Wasmtime-internal wasmtime-runtime crate has been removed. #8501
- The pooling allocator now allows twice as many elements as before. #8527
- Using CMake to build the C API has been improved along a number of axes. #8490 #8497 #8549
Fixed
- Pooling allocator CLI options are now respected with the wasmtime serve subcommand. #8525

Released 2024-05-03.
Added
- Make the c-api CMakeLists.txt easier to import. #8496

Added
- Support for shared WebAssembly memories has been added to the C API. #7940
- A Component::component_type method has been added to reflect on the imports and exports of a component. #8078
- The with key in bindgen! now supports remapping entire packages and namespaces. #8083
- Winch now supports the component model by using Cranelift to generate trampolines. #8082 #8109
- The WASI-NN backend now supports ONNX. #7691
- The wasmtime CLI now has an -S inherit-env flag for inheriting the entire process environment. #8168
- Winch now supports the WebAssembly memory64 proposal. #8194
- Embedders can now opt-in to allowing wasmtime-wasi to block the current thread with file operations, for example. #8190
- A wasmtime::CodeBuilder type has been added to refine the configuration of compiling a Module or a Component. #8181
- The wasmtime serve subcommand now enables configuring preopened directories and environment variables. #8279
Changed
- Support for WebAssembly GC is in the process of being implemented which has required refactoring and reimplementing the existing gc support for externref. Many APIs in this area has changed, see linked PRs for more details. Note that the wasm_* parts of the C API no longer support externref. #8011 #8196
- The wasmtime::component::Val type no longer stores type information and instead must be interpreted in the context of a type. #8062
- The arguments required for ResourceAny::try_from_resource have been simplified by refactoring the internal representation. #8061
- The arguments required for wasmtime::component::Linker::func_new have been simplified by refactoring the internal representation. #8070
- The pooling allocator is now enabled by default with wasmtime serve. #8073
- The error message for missing imports in has been improved with components. #7645
- Wasmtime's MSRV is now 1.75.0. #8205
- Wasmtime's translation of table-related instructions has improved codegen in some common cases, especially with call_indirect. #8063 #8125 #8124 #8134 #8137 #8162 #8159 #8172 #8171 #8139 #8206
- Book-based documentation has been reordered and refactored. #8130
- The -S common flag is renamed to -S cli, to better reflect that it provides the wasi-cli APIs. -S common is still accepted for now, and will be deprecated in the future. #8166
- The tail-call calling convention now supports callee-saved registers to improve performance and allow enabling this WebAssembly proposal by default in the future. #8246
- The wasmtime-wasi crate has been refactored to restructure some items and documentation has been added for most items. #8228
- Support for the WebAssembly threads proposal is now gated by an on-by-default Cargo feature named threads. #8260
- Borrow-checking in wiggle has been optimized to not be as fine-grained any more. This is a breaking change if users are relying on the ability to safely mutably borrow disjoint regions of memory. #8277
Fixed
- Connection timeouts with wasi-http have been fixed. #8085
- Generating bindings with bindgen! now works correctly when some WIT types are not used. #8065
- Errors in wasi-http are no longer accidentally returned as traps. #8272

Added
- C API bindings for the sampling-based profiler in Wasmtime have been added. #7854
- Add the WasiP1Ctx to ease the use of wasmtime-wasi in place of wasi-common #8053
- The Winch compiler backend is now feature-complete for x64. Note that minor issues and fuzz bugs are still being addressed, but now's a good time to test if you're interested. #7894 #7909 #7927 #7932 #7949 #7974 #8001
- The typed function references proposal to WebAssembly is now fully implemented. #7943
- The component::Linker type is now "semver aware" in that it enables loading components referring to past or future versions of interfaces so long as the types are compatible. #7994
- Wasmtime can now be built for "custom platforms" which is intended for bare-metal builds. #7995
- The wasmtime-wasi-nn crate now has a backend based on WinML. #7807
- The wasmtime CLI now has flags for configuring limits of the pooling allocator. #8027
Changed
- The wasmtime serve command no longer binds its port with SO_REUSEADDR meaning that if it is invoked twice only one will succeed. #7863
- The sampling-based profiler in Wasmtime now takes an explicit argument of the time delta between samples. #7873
- Many accessors for type information now require an &Engine argument to be specified in preparation for an implementation of wasm GC. #7892
- The host header is now forbidden in wasi-http. #7905
- Stronger type-checks are now performed for host-owned resources when interacting with the component model to help catch mistakes earlier. #7902
- Demangling Rust and C/C++ symbols in WebAssembly modules is now done by default in the C API. #7962
- Preview2-based APIs are now located at the root of the wasmtime_wasi crate instead of a submodule. #7933
- Components now reserve index 0 for handle tables to match the component model specification. #7661
- Support for externref has been moved behind a new gc Cargo feature. This will also gate support for wasm gc in the future. #7975
- Require the WASMTIME_WASI_CONFIG_PREOPEN_SOCKET_ALLOW environment variable to bet set to allow the use of wasi_config_preopen_socket via the c api, as it will be deprecated in 20.0.0. #8053
Fixed
- WIT interface names that are Rust keywords now correctly generate bindings. #7790
- PKRU state is now restored across await points. #7789
- Wasmtime now correctly supports global.get in all constant expressions within a module. #7996

Released 2024-02-28.
Fixed
- Fix an egraph rule bug that was permitting an incorrect ireduce rewrite to unary and binary operations, leading to miscompilations. #8005

Released 2024-02-20.
Fixed
- Fixed a mistake in the CI release process that caused the crates.io publication of the 18.0.0 release to not succeed. #7966

Added
- The wasmtime-c-api-impl crate is now published on crates.io. #7837
- A new EngineWeak type enables holding a weak pointer to an engine with the ability to dynamically and fallibly upgrade it to an Engine. #7797
- The WebAssembly tail calls proposal can now be enabled through the C API. #7811
- The import and export types of a Component can now be inspected at runtime. #7804
- New APIs/types have been added to support a faster version of looking up module exports without using string lookups with Module::get_export_index. #7828
Changed
- Owned resources represented with ResourceAny can now be passed as arguments to functions that require a borrow<T> parameter. #7783
- Generated structures from wasmtime::component::bindgen! for exported interfaces are now all renamed to Guest to avoid conflicting with WIT names. #7794
- Guest profiler output will now automatically demangle symbols. #7809
- The wasmtime crate now has a runtime Cargo feature which, if disabled, enables building Wasmtime with only the ability to compile WebAssembly modules. This enables compiling Wasmtime's compilation infrastructure, for example, to WebAssembly itself. #7766
- Support for the old wasi-common crate and the original implementation of "WASIp1" aka "preview1" is being deprecated in the wasmtime-wasi crate. Users should migrate to the wasmtime_wasi::preview2 implementation, which supports both WASIp1 and WASIp2, as in the next release the wasi-common-based reexports of wasmtime-wasi will be deleted. #7881

Fixed
- Fix an egraph rule bug that was permitting an incorrect ireduce rewrite to unary and binary operations, leading to miscompilations. #8005

The major feature of this release is that the WASI support in Wasmtime is now considered stable and flagged at an 0.2.0 version approved by the WASI subgroup. The release was delayed a few days to hold off until the WASI subgroup voted to approve the CLI and HTTP worlds and they're now on-by-default! Additionally the component model is now enabled by default in Wasmtime, for example an opt-in flag is no longer required on the CLI. Note that embeddings still must opt-in to using the component model by using the wasmtime::component module.

Added
- Cranelift optimizations have been added for "3-way comparisons", or Ord::cmp in Rust or <=> in C++. #7636 #7702
- Components now use Wasmtime's compilation cache used for core wasm modules by default. #7649
- The Resource<T> and ResourceAny types can now be converted between each other. #7649 #7712

Changed
- Minor changes have been made to a number of WITs as they progressed to their official 0.2.0 status. #7625 #7640 #7690 #7781 #7817
- The component model is now enabled by default. #7821
- The implementation of memory.atomic.{wait,notify} has been rewritten. #7629
- The wasmtime_wasi::preview2::Table type has been moved to wasmtime::component::ResourceTable. #7655
- Creating a UDP stream now validates the address being sent to. #7648
- Defining resource types in Linker<T> now takes the type to define as a runtime parameter. #7680
- Socket address checks can now be performed dynamically at runtime. #7662
- Wasmtime and Cranelift's MSRV is now 1.73.0. #7739

Fixed
- Bindings for WIT APIs where interfaces have multiple versions are now fixed by putting the version in the generated binding names. #7656
- The preview1 fd_{read,write} APIs are now fixed when a shared memory is used. #7755
- The preview1 fd_{read,write} APIs no longer leak an intermediate stream created. #7819

Added
- Add yielding support in wasmtime_store_epoch_deadline_callback in the C API. #7476
- Support for the wasi_unstable module ("wasi preview0" canonically) has been added to the -Spreview2 support in the CLI. #7548
- The original module can now be obtained from an "instance pre" in the C API. #7572
- Usage of Mach ports on macOS can now be disabled in the C API. #7595
Changed
- The preview1-to-preview2 component adapters now import a smaller number of interfaces by default. #7543 #7544
- Wasmtime and Cranelift now require Rust 1.72.0 to build. #7554
- The default world supported by wasmtime serve has been slimmed down to exactly what wasi:http/proxy specifies by default. Support for other WASI APIs can be included with the -S common command-line flag. #7597
- The wasmtime --version CLI output will now include date/commit information when Wasmtime is built from a git checkout. #7610
Fixed
- MPK support is now explicitly disabled on AMD-based CPUs since the implementation does not currently support it. #7513
- Initialization of a WebAssembly data segment with a negative offset is fixed to zero-extend the offset instead of sign-extend. #7559
- The reported offset of O_APPEND files in preview1 has been fixed. #7586
- MPK support does a better job of compacting memories to minimize virtual memory used. #7622
Cranelift
- Union node bitpacking has been fixed with egraph optimizations to ensure the minimal cost node is selected. #7465
- Equivalent-cost expressions now have ties broken with expression depth in egraphs to prefer "shallow" expression trees. #7456
- Long-and-narrow chains of expressions are now optimized into shallow-and-wide trees. #7466

Fixed
- The wasi:random/insecure{,_seed} interfaces are now available through the CLI. #7614
- A stray debugging println! was removed. #7618

Added
- Multiple versions of interfaces are now supported in bindgen!. #7172
- UDP has been implemented in wasi:sockets. #7148 #7243
- Support for custom stack memory allocation has been added. #7209
- The memory_init_cow setting can now be configured in the C API. #7227
- The splice method of WASI streams has been implemented. #7234
- Wasmtime binary releases now have a wasmtime-min executable in addition to libwasmtime-min.* libraries for the C API. These showcase a minimal build of Wasmtime for comparison. #7282 #7315 #7350

Changed
- Many changes to wasi:http WITs have happened to keep up with the proposal as it prepares to reach a more stable status. #7161 #7406 #7383 #7417 #7451
- Add an error resource to WASI streams. #7152
- Syntax in bindgen!'s trappable_error_type configuration has changed. #7170
- TCP errors in wasi:sockets have been simplified and clarified. #7120
- Wasmtime/Cranelift now require Rust 1.71.0 to compile. #7206
- Logging in Wasmtime is now configured with WASMTIME_LOG instead of RUST_LOG. #7239
- Fuel-related APIs on Store have been refactored and reimplemented with two new methods set_fuel and reset_fuel. Previous methods have been removed. #7240 #7298
- The forward method of WASI streams has been removed. #7234
- The WebAssembly threads, multi-memory, and relaxed-simd proposals are now enabled by default. #7285
- Logging is now implemented for wasmtime serve. #7366
- Filesystem locking has been temporarily removed from WASI. #7355
- Wasmtime's implementation of WASI preview1 built on top of preview2 (-Spreview2) has been enabled by default. #7365
- The wasi:clocks interface now has two subscribe functions and a duration type. #7358
- The wasi:io/poll interface has seen some refactoring. #7427

Fixed
- Profiling the first function in a module now works. #7254
- Consecutive writes to files in preview2 have been fixed. #7394
- Copy-on-write initialization of linear memories has been fixed for components. #7459

Cranelift
- Support for proof-carrying code has been added to Cranelift to assist with an extra layer of validation about properties such as WebAssembly memory accesses in the future. #7165 #7180 #7219 #7231 #7262 #7263 #7274 #7280 #7281 #7352 #7389 #7468
- Rematerialization of values no longer accidentally overrides LICM. #7306
- Inline stack probes no longer make Valgrind unhappy. #7470

Fixed
- Using the --dir argument combined with a ::-remapped path no longer prints a warning about compatibility with the old CLI and works with remapping. #7416
- Consecutive file writes in preview2 have been fixed. #7394

Fixed
- The wasmtime executable will now attempt to more gracefully handle the transition from the 13.0.0 CLI arguments and parsing to the changes in 14.0.0. CLI commands should now warn if they no longer work with the new parser, but still execute as they previously did. This behavior can be controlled via a new WASMTIME_NEW_CLI environment variable if necessary. #7385
- The serve subcommand of the wasmtime CLI is now enabled by default for the wasmtime executable. #7392

Fixed
- Make the wasmtime::unix module accessible on macOS again. #7360
- Inter-crate dependencies between cranelift-* crates now disable the default feature meaning that it's possible for embedders to depend on cranelift-codegen as well without the default feature. #7369

One of the larger changes in this release is a redesign of Wasmtime's CLI arguments and where arguments are passed. This means that previous invocations of the wasmtime CLI executable will need to be updated. No functionality was removed but most of it is behind new flags. One major change is that Wasmtime CLI flags are now grouped behind short options like -O. For example

wasmtime run --opt-level 2 foo.wasm

is now:

wasmtime run -O opt-level=2 foo.wasm

Additionally options prefixed with --enable-* or --disable-* now consistently are considered boolean setters. For example:

wasmtime run --disable-cache foo.wasm

is now:

wasmtime run -C cache=n foo.wasm

Options can be explored with wasmtime -C help for example, and wasmtime -h will show all option groups that can be expanded.

Another major change in the CLI is that any CLI argument which positionally comes after the wasm file specified will be passed as an argument to the guest module. For example this invocations

wasmtime run foo.wasm --epoch-interruption

was previously accepted as enabling epoch interruption for the foo.wasm file. This is now interpreted as if it were ./foo.wasm --epoch-interruption, however, passing the flag to the wasm file itself. Flags to Wasmtime must now come after Wasmtime's subcommand (in this case run) and before the wasm file that's being run, for example:

wasmtime run -W epoch-interruption foo.wasm

More information about this change can be found on #6925 and #6946.

Added
- Added the wasmtime::FrameInfo::module method, which returns the wasmtime::Module associated with the stack frame.
- The wasmtime::component::Linker type now implements Clone. #7032
- Wasmtime's TypedFunc API now supports the v128 WebAssembly type on x86_64 and aarch64. #7010
- Support for resources exported from a WebAssembly guest has been added to the component bindgen! macro. #7050
- The C API now supports learning about a module's image_range. #7064
- Passing values between components is now possible with a more complete implementation of type-checking of values. #7065
- Types representing resources can now be customized with bindgen!. #7069
- Wasm-defined globals and memories are now included in core dumps, and the wasmtime::WasmCoreDump type is now serializable. #6935 #7078
- Initial experimental support for Intel MPK has been added to support running more instances concurrently. #7072
- The implementation of wasi:http now supports inbound requests in addition to outbound requests. A new wasmtime serve command is an example way of handling http requests with wasm files. #7091
- The C API now supports Wasmtime's "host memory creation" API to customize the allocation of linear memories. #7115
- The C API now supports asynchronous invocation of WebAssembly programs. #7106
- The C API now supports Wasmtime's InstancePre<T> type. #7140
- The wasi:sockets/ip-name-lookup interface is now implemented by Wasmtime. #7109

Changed
- Wasmtime's CLI has been significantly overhauled. See the note above. #6925 #6946
- The wasmtime::FrameInfo::module_name has been removed, however you can now get identical results by chaining wasmtime::FrameInfo::module and wasmtime::Module::name: my_frame.module().name().
- WASI interfaces have seen significant work since the previous release. Streams for example have a new backpressure and flushing design. Additionally WIT resources are now used ubiquitously throughout the specification and implementation. #6877 #7029 #7090
- The implementation of wasi:http now uses {input,output}-stream from the wasi:io/streams interface. #7056
- Lifting and lowering of the list<u8> component values has been significantly optimized. #6971
- The wasmtime-c-api crate is now additionally built as an rlib as well as the previous cdylib/staticlib combo. #6765

Fixed
- Support referencing stack slots in the DWARF debug info. #6960
- Printing unicode to stdio on Windows has been fixed. #6825
- Building for x86_64-linux-android has been fixed. #7055
- Fixed stdout/

Fixed
- Make the wasmtime::unix module accessible on macOS again. #7360

Added
- Configuration of mach ports vs signals on macOS is now done through a Config instead of at compile time. #6807
- Engine::detect_precompiled{,_file} can be used to to determine whether some bytes or a file look like a precompiled module or a component. #6832 #6937
- A new feature "wmemcheck" has been added to enable Valgrind-like detection of use-after-free within a WebAssembly guest module. #6820 #6856
- The wasmtime CLI now supports executing components. #6836
- Support for WASI preview2's TCP sockets interface has been added. #6837
- Wasmtime's implementation of the wasi-nn proposal now supports named models. #6854
- The C API now supports configuring native_unwind_info, dynamic_memory_reserved_for_growth, target, and Cranelift settings. #6896 #6934
- The wasmtime crate now has initial support for component model bindings generation for the WIT resource type. #6886
- Cranelift's RISC-V backend now has a complete implementation of the WebAssembly SIMD proposal. Many thanks to Afonso Bordado for all their contributions! #6920 #6924
- The bindgen! macro in the wasmtime crate now supports conditional configuration for which imports should be async and which should be synchronous. #6942

Changed
- The pooling allocator was significantly refactored and the PoolingAllocationConfig has some minor breaking API changes that reflect those changes.
Previously, the pooling allocator had count slots, and each slot had N memories and M tables. Every allocated instance would reserve those N memories and M tables regardless whether it actually needed them all or not. This could lead to some waste and over-allocation when a module used less memories and tables than the pooling allocator's configured maximums.
After the refactors in this release, the pooling allocator doesn't have one-size-fits-all slots anymore. Instead, memories and tables are in separate pools that can be allocated from independently, and we allocate exactly as many memories and tables as are necessary for the instance being allocated.
To preserve your old configuration with the new methods you can do the following:

let mut config = PoolingAllocationConfig::default();

// If you used to have this old, no-longer-compiling configuration:
config.count(count);
config.instance_memories(n);
config.instance_tables(m);

// You can use these equivalent settings for the new config methods:
config.total_core_instances(count);
config.total_stacks(count); // If using the `async` feature.
config.total_memories(count * n);
config.max_memories_per_module(n);
config.total_tables(count * m);
config.max_tables_per_module(m);

There are additionally a variety of methods to limit the maximum amount of resources a single core Wasm or component instance can take from the pool:
- PoolingAllocationConfig::max_memories_per_module
- PoolingAllocationConfig::max_tables_per_module
- PoolingAllocationConfig::max_memories_per_component
- PoolingAllocationConfig::max_tables_per_component
- PoolingAllocationConfig::max_core_instances_per_component
These methods do not affect the size of the pre-allocated pool. #6835
- Builder methods for WASI contexts now use &mut self instead of self. #6770
- Native unwinding information is now properly disabled when it is configured to be turned off. #6547
- Wasmtime's minimum supported Rust version (MSRV) is now 1.70.0. Wasmtime's MSRV policy of supporting the last three releases of Rust (N-2) is now additionally documented. More discussion can additionally be found on the PR itself. #6900
- Wasmtime's support for DWARF debugging information has seen some fixes for previously reported crashes. #6931

Removed
- Wasmtime's experimental implementation of wasi-crypto has been removed. More discussion of this change can be found on #6732 and #6816
- Support for union types in the component model has been removed. #6913

Fixed
- CVE-2023-41880 - Miscompilation of wasm i64x2.shr_s instruction with constant input on x86_64

Added
- Wasmtime now supports having multiple different versions of itself being linked into the same final executable by mangling some C symbols used by Wasmtime. #6673
- The perfmap profiling option is now supported on any Unix platform instead of just Linux. #6701
- The wasmtime CLI now supports --env FOO to inherit the value of the environment variable FOO which avoids needing to do --env FOO=$FOO for example. #6746
- Wasmtime now supports component model resources, although support has not yet been added to bindgen!. #6691
- Wasmtime now supports configuration to enable the tail calls proposal. Platform support now also includes AArch64 and RISC-V in addition to the previous x86_64 support. #6723 #6749 #6774
- Wasmtime's implementation of WASI Preview 2 now supports streams/pollables with host objects that are all backed by Rust async. #6556
- Support for core dumps has now been added to the wasmtime crate. #6513
- New {Module,Component}::resources_required APIs allow inspecting what will be required when instantiating the module or component. #6789

Fixed
- Functions on instances defined through component::Linker::func_new are now defined correctly. #6637
- The async_stack_size configuration option is no longer inspected when async_support is disabled at runtime. #6771
- WASI Preview 1 APIs will now trap on misaligned or out-of-bounds pointers instead of returning an error. #6776
- Optimized the cranelift compilation on aarch64 for large wasm modules. #6804

Changed
- Empty types are no longer allowed in the component model. #6777

Fixed
- CVE-2023-41880 - Miscompilation of wasm i64x2.shr_s instruction with constant input on x86_64

Changed
- The WASI Preview 2 WasiCtxBuilder type has been refactored, and WasiCtx now has private fields. #6652
- Component bindgen! now generates owned types by default instead of based on how they're used #6648
- Wasmtime/Cranelift on x86-64 can now execute Wasm-SIMD on baseline SSE2, which all x86-64 processors support (as part of the base x86-64 spec). Previously, SSE4.2 extensions were required. This new work allows Wasm with SIMD extensions to execute on processors produced back to 2003. #6625

Fixed
- Only export the top-level preview2 module from wasmtime-wasi when the preview2 feature is enabled. #6615

Cranelift changes
- Tail call implementation has begun in Cranelift #6641 #6666 #6650 #6635 #6608 #6586
- Work continues on SIMD support for the riscv64 backend #6657 #6643 #6601 #6609 #6602 #6598 #6599 #6587 #6568 #6515
- Fix AuthenticatedRet when stack bytes are popped in the aarch64 backend #6634
- The fcvt_low_from_sint instruction has been removed, as it its current behavior can be recovered through a combination of swiden_low and fcvt_from_sint #6565

Fixed
- CVE-2023-41880 - Miscompilation of wasm i64x2.shr_s instruction with constant input on x86_64

Fixed
- Only export the top-level preview2 module from wasmtime-wasi when the preview2 feature is enabled. #6615

Added
- Expose the Config::static_memory_forced option through the C api #6413
- Basic guest-profiler documentation for the book #6394
- Merge the initial wasi-preview2 implementation #6391
- The wasi-preview2 component adapter has been pulled into the main wasmtime repository. It is available for the first time as part of this release, but should be treated as as a beta at this time. Patch releases will not be made for bug fixes. #6374
- A callback invoked when an epoch deadline is reached can now be configured via the C API. #6359
- PR auto-assignment policies have been documented, to clarify the expectations of reviewers. #6346
- Support for the function references has been added #5288
Changed
- An epoch_deadline_callback now returns an UpdateDeadline enum to allow optionally yielding to the async executor after the callback runs. #6464
- The --profile-guest flag has now been folded into --profile=guest #6352
- Initializers are no longer tracked in the type information for globals, and instead are provided when creating the global. #6349
- The "raw" representation of funcref and externref in the embedding API has been updated from a usize to a *mut u8 to be compatible with Rust's proposed strict provenance rules. This change is additionally reflected into the C API as well. #6338
Fixed
- Fixed a soundness issue with the component model and async #6509
- Opening directories with WASI on Windows with NONBLOCK in flags has been fixed. #6348
Cranelift changes
- Performance improvements in regalloc2 have landed, and compilation time has improved #6483 #6398
- Renamed abi::Caller to abi::CallSite #6414
- Work has begun on SIMD support for the riscv64 backend #6324 #6366 #6367 #6392 #6397 #6403 #6408 #6419 #6430 #6507

Fixed
- Fix Wasi rights system to work with wasi-testsuite, which exposed a corner case that was missed by the fixes in the 9.0.2 release. #6479

Fixed
- Fix Wasi rights system to work with wasi-libc. This regression was introduced in the 9.0.0 release. #6462 #6471

Fixed
- A panic which happened when enabling support for native platform profilers was fixed. #6435

Added
- Initial integration of the Winch baseline compiler into Wasmtime is implemented. Note that Winch still does not support much of WebAssembly, but intrepid explorers may have an easier time playing around with it now. #6119
- The wasmtime CLI now has flags to limit memory, instances, and tables. For example --max-memory-size or --max-tables. Additionally it has a new --trap-on-grow-failure option to force a trap whenever a memory.grow would otherwise fail which can be useful for debugging modules which may be encountering OOM. #6149
- An initial implementation of the wasi-http proposal was added to Wasmtime in the shape of a new wasmtime-wasi-http crate and a --wasi-modules=experimental-wasi-http CLI flag. Note that this is not on-by-default and still in an experimental status at this time. #5929
- Wasmtime's bindgen! macro for components now has interfaces and with options to configure use of interfaces defined externally in separate crates. #6160 #6210
- Wasmtime's bindgen! macro emits trace events for arguments and results when enabled. #6209
- A new Engine::precompile_compatibility_hash method has been added to assist with hashing artifacts to be compatible with versions of Wasmtime. #5826
- Wasmtime's C API now has functions for enabling the WebAssembly relaxed-simd proposal. #6292
- A new --emit-clif flag has been added to wasmtime compile to see the CLIF corresponding to a WebAssembly module to be used for debugging. #6307
- Support for an in-process sampling-based profiler has been added to Wasmtime. This is intended to be used in conjunction with epochs to enable relatively simple implementations of profiling a guest module. #6282

Changed
- Overhauled the way that Wasmtime calls into Wasm and Wasm calls back out to the host. Instead of chaining together trampolines to convert between calling conventions, we now represent funcrefs with multiple function pointers, one per calling convention. This paves the way for supporting Wasm tail calls and also results in ~10% speed ups to a variety of function call benchmarks, however there are some slight compiled Wasm module code size regressions (which can be alleviated by disabling optional .eh_frame generation). Additionally, in the C API the wasmtime_func_call_unchecked function gained one more parameter, which is the capacity of the args-and-results buffer. #6262
- The wasmtime compile command will now default to producing executables for the native host and its CPU features instead of the baseline feature set of the host's architecture. #6152
- The ResourceLimiter trait and its async equivalent now support returning errors from growth to force a trap in the wasm module rather than reporting -1 to the wasm module. Note that this is primarily intended for debugging. #6149
- The non-egraph-based optimization pipeline has been removed from Cranelift, and the corresponding Config::use_egraphs option is also removed. #6167
- Generated types for WIT files now always generates owned types by default. #6189
- Wasmtime's baseline x86_64 CPU features required for SIMD support has been lowered from SSE 4.2 to SSE 4.1. #6206
- The fd_allocate implementation in Wasmtime will now always fail with ENOTSUP. #6217
- The "rights" system in WASI has been removed and rights are no longer inspected in the implementation of any WASI functions. #6265

Fixed
- WASI can now open directories without O_DIRECTORY. #6163
- The poll_oneoff function has been fixed when handling non-regular files. #6258
- The behavior of path_readlink on too-small buffers has been fixed to truncate. #6225

Cranelift changes
Note: this section documents changes to Cranelift, a code generator backend that Wasmtime uses. These changes are not always applicable to Wasmtime as a WebAssembly runtime but may be interesting to other projects which embed or use Cranelift.
- New {u,s}{add,sub,mul}_overflow instructions have been added. #5784
- The iadd_cout and isub_bout instructions have been removed. #6198
- ISLE now suppo

Changed
- Breaking: Files opened using Wasmtime's implementation of WASI on Windows now cannot be deleted until the file handle is closed. This was already true for open directories. The change was necessary for the bug fix in #6163.
Fixed
- Fixed wasi-common's implementation of the O_DIRECTORY flag to match POSIX. #6163
- Undefined Behavior in Rust runtime functions GHSA-ch89-5g45-qwc7

Added
- Allow the MPL-2.0 and OpenSSL licenses in dependencies of wasmtime. #6136
- Add a bounds-checking optimization for dynamic memories and guard pages. #6031
- Add support for generating perf maps for simple perf profiling. Additionally, the --jitdump and --vtune flags have been replaced with a single --profile flags that accepts perfmap, jitdump, and vtune arguments. #6030
- Validate faulting addresses are valid to fault on. As a mitigation to CVEs like GHSA-ff4p-7xrq-q5r8, check that the address involved in a fault is one that could be contained in a Store, or print a scary message and abort immediately. #6028
- Add the --default-values-unknown-imports option to define unknown function imports as functions that return the default value for their result type. #6010
- Add Clone for component::InstancePre. #5996
- Add --dynamic-memory-reserved-for-growth cli flag. #5980
- Introduce the wasmtime-explorer crate for investigating the compilation of wasm modules. This functionality is also exposed via the wasmtime explore command. #5975
- Added support for the Relaxed SIMD proposal. #5892
- Cranelift gained many new machine-independent optimizations. #5909 #6032 #6033 #6034 #6037 #6052 #6053 #6072 #6095 #6130

Changed
- Derive Copy on wasmtime::ValType. #6138
- Make StoreContextMut accessible in the epoch deadline callback. #6075
- Take SIGFPE signals for divide traps on x86_64. #6026
- Use more specialized AVX instructions in the x86_64 backend. #5924 #5930 #5931 #5982 #5986 #5999 #6023 #6025 #6060 #6086 #6092
- Generate more cache-friendly code for traps. #6011

Fixed
- Fixed suboptimal code generation in the aarch64 backend. #5976 #5977 #5987 #5997 #6078
- Fixed suboptimal code generation in the riscv64 backend. #5854 #5857 #5919 #5951 #5964 #6087

Fixed
- Undefined Behavior in Rust runtime functions GHSA-ch89-5g45-qwc7

Added
- An initial implementation of the wasi-threads proposal has been implemented and landed in the Wasmtime CLI. This is available behind a --wasi-modules experimental-wasi-threads flag. #5484
- Support for WASI sockets has been added to the C API. #5624
- Support for limiting Store-based resource usage, such as memory, tables, etc, has been added to the C API. #5761
- A top level alias of anyhow::Result as wasmtime::Result has been added to avoid the need to explicitly depend on anyhow. #5853
- Initial support for the WebAssembly core dump format has been added to the CLI with a --coredump-on-trap flag. #5868

Changed
- The S type parameter on component-related methods has been removed. #5722
- Selection of a world to bindgen has been updated to select any default world in a WIT package if there is only one. #5779
- WASI preopened file descriptors can now be closed. #5828
- The host traits generated by the bindgen! macro are now always named Host, but are still scoped to each individual module. #5890

Fixed
- Components which have type imports are now supported better and error/panic in fewer cases. #5777
- Types referred to by wasmtime::component::Val are now reexported under wasmtime::component. #5790
- A panic due to a race between memory.atomic.{wait32,wait64,notify} instructions has been fixed. #5871

Fixed
- Undefined Behavior in Rust runtime functions GHSA-ch89-5g45-qwc7

Fixed
- Guest-controlled out-of-bounds read/write on x86_64 GHSA-ff4p-7xrq-q5r8
- Miscompilation of i8x16.select with the same inputs on x86_64 GHSA-xm67-587q-r2vw

Added
- Wasmtime's built-in cache can now be disabled after being enabled previously. #5542
- Older x86_64 CPUs, without SSE4.1 for example, are now supported when the wasm SIMD proposal is disabled. #5567
- The Wasmtime C API now has WASMTIME_VERSION_* macros defined in its header files. #5651
- The wasmtime CLI executable as part of Wasmtime's precompiled release artifacts now has the all-arch feature enabled. #5657

Changed
- Equality of wasmtime::component::Val::Float{32,64} now considers NaNs as equal for assistance when fuzzing. #5535
- WIT syntax supported by wasmtime::component::bindgen! has been updated in addition to the generated code being updated. #5565 #5692 #5694
- Cranelift's egraph-based optimization framework is now enabled by default. #5587
- The old PoolingAllocationStrategy type has been removed in favor of a more flexible configuration via a new option PoolingAllocationConfig::max_unused_warm_slots which is more flexible and subsumes the previous use cases for each strategy. #5661
- Creation of InstancePre through Linker::instantiate_pre no longer requires a Store to be provided. Instead a Store-related argument is now required on Linker::define-style APIs instead. #5683

Fixed
- Compilation for FreeBSD on x86_64 and AArch64 has been fixed. #5606

Fixed
- Guest-controlled out-of-bounds read/write on x86_64 GHSA-ff4p-7xrq-q5r8
- Miscompilation of i8x16.select with the same inputs on x86_64 GHSA-xm67-587q-r2vw

Added
- A wasmtime::component::bingen! macro has been added for generating bindings from *.wit files. Note that WIT is still heavily in development so this is more of a preview of what will be as opposed to a finished feature. #5317 #5397
- The wasmtime settings CLI command now has a --json option for machine-readable output. #5411
- Wiggle-generated bindings can now generate the trait for either &mut self or &self. #5428
- The wiggle crate has more convenience APIs for working with guest data that resides in shared memory. #5471 #5475

Changed
- Cranelift's egraph support has been rewritten and updated. This functionality is still gated behind a flag and may become the default in the next release. #5382
- The implementation of codegen for WebAssembly linear memory has changed significantly internally in Cranelift, moving more responsibility to the Wasmtime embedding rather than Cranelift itself. This should have no user-visible change, however. #5386
- The Val::Float32 and Val::Float64 variants for components now store f32 and f64 instead of the bit representation. #5510

Fixed
- Handling of DWARF debugging information in components with multiple modules has been fixed to ensure the right info is used for each module. #5358

Fixed
- Guest-controlled out-of-bounds read/write on x86_64 GHSA-ff4p-7xrq-q5r8
- Miscompilation of i8x16.select with the same inputs on x86_64 GHSA-xm67-587q-r2vw

Added
- Dynamic memories are now supported with the pooling instance allocator which can possibly reduce the number of page faults throughout execution at the cost of slower to run code. Page faults are primarily reduced by avoiding releasing memory back to the system, relying on bounds checks to keep the memory inaccessible. #5208
- The wiggle generator now supports function-level control over tracing calls. #5194
- Support has been added to wiggle to be compatible with shared memories. #5225 #5229 #5264 #5268 #5054
- The wiggle generator now supports a "trappable error" configuration to improve error conversions to guest errors and ensure that no host errors are forgotten or accidentally become traps. The wasi-common crate has been updated to use this. #5276 #5279
- The memory.atomic.{notify,wait32,wait64} instructions are now all implemented in Wasmtime. #5255 #5311
- A wasm_config_parallel_compilation_set configuration function has been added to the C API. #5298
- The wasmtime CLI can have its input module piped into it from stdin now. #5342
- WasmBacktrace::{capture,force_capture} methods have been added to programmatically capture a backtrace outside of a trapping context. #5341

Changed
- The S type parameter on Func::typed and Instance::get_typed_func has been removed and no longer needs to be specified. #5275
- The SharedMemory::data method now returns &[UnsafeCell<u8>] instead of the prior raw slice return. #5240
- Creation of a WasiCtx will no longer unconditionally acquire randomness from the OS, instead using the rand::thread_rng() function in Rust which is only periodically reseeded with randomness from the OS. #5244
- Codegen of dynamically-bounds-checked wasm memory accesses has been improved. #5190
- Wasmtime will now emit inline stack probes in generated functions for x86_64, aarch64, and riscv64 architectures. This guarantees a process abort if an engine was misconfigured to give wasm too much stack instead of optionally allowing wasm to skip the guard page. #5350 #5353

Fixed
- Dropping a Module will now release kernel resources in-use by the pooling allocator when enabled instead of waiting for a new instance to be re-instantiated into prior slots. #5321