NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →
crates.io
crates.io, #4235 most downloaded on crates.io
A library for testing concurrent Rust code
Latest stable
0.9.10
Last release 17 days ago
05 Nov 2026
Release timing varies
gaps range from 8 days to 10 months
Nearly every release is documented
notes for 30 of 31 stable releases
Nothing withdrawn
no release was ever pulled
6 years old
31 releases · first in 2020
Drag across the ruler to compare, or tap a release to open it.
A task now returns its continuation, and with it its stack, to the continuation pool as soon as it finishes, instead of keeping it until execution tea
A task now returns its continuation, and with it its stack, to the continuation pool as soon as it finishes, instead of keeping it until execution teardown, so a task spawned later in the same execution reuses it. The stack memory an execution uses therefore grows with the number of tasks alive at the same time rather than with the number of tasks it has ever spawned, which is what made long-running, spawn-heavy executions impractical. Spawning and joining 30,000 threads one after the other in a single execution went from 152 MB resident and 1.9 GB of mapped stacks to 29 MB and 42 MB (release build, without vector clocks, Linux x86-64). Before this change the same program could not get much further: at 33,000 threads it ran out of memory mappings (each stack takes two, and Linux allows 65,530 by default), and the test died in DefaultStack::new with Cannot allocate memory. It now reaches 50,000 threads at 47 MB.
A task gives up only what it cannot use again once it has finished: its stack, and any backtrace captured while it was blocked. Everything whose destructor runs user code — its spans, its tag and its task-local values — is still dropped by execution teardown, as the task, exactly as before, so nothing of the user's runs any earlier than it used to and a finished task's step span still closes at the end of the execution. Everything that can be asked about a finished task is unchanged. Each finished task still keeps its record until the execution ends, which under the vector-clocks feature includes its clock, so a spawn-heavy execution is still quadratic in memory with that feature on.
Fix a thread spawned with thread::Builder::stack_size sometimes running on, and overflowing, a smaller stack than it asked for. The pool reused whichever continuation came first, whatever stack size it had been created with, so a thread could be handed a smaller stack that another task had freed — for instance when threads with different stack sizes were spawned in a different order than in a previous execution, since the pool outlives each execution. The pool now reuses the smallest continuation whose stack is at least as large as the one requested. Reusing stacks within an execution, as above, would have made this much easier to hit. Taking the smallest rather than the first that fits also keeps the pool from growing: handing a large stack to a task that asked for a small one would leave the next large request with nothing to reuse, so the pool would accumulate more large stacks than the execution ever needs at once.
Performance: a thread exiting no longer looks at every task the execution has created, only at the unfinished ones, so its cost no longer grows with the number of threads that finished before it. Together with the stack reuse above, spawning and joining 30,000 threads one after the other in a single execution takes 0.05 s instead of 0.67 s.
Take a scheduling point before an Acquire of a BatchSemaphore that is dropped before it completes leaves the semaphore, when it is queued or holds the reservation. Such an Acquire is still visible to other tasks: a release grants it permits ahead of later requests on a strictly fair semaphore, and on an unfair one no other request can take a permit while it holds the reservation. The drop ran in the same step as the task's previous operation, so Shuttle missed the interleavings in which a release or a try_acquire sees the Acquire still there. This happens whenever a select!, a timeout or an abort cancels a blocked acquire, including the tokio wrapper's Semaphore acquires and its bounded mpsc send and reserve. Add runtime::thread::switch_if_not_stopping, and make BatchSemaphore::release_no_scheduling_point public, for primitives whose release is part of an operation that has already taken its scheduling point. (#412, #407)
shuttle-tokio: add the scheduling points that were missing from Notify, mpsc, oneshot, watch and OnceCell (#262). In each of the operations below, the access to the primitive's state ran in the same step as the task's previous operation, so Shuttle never ran another task between the two and missed the bugs that need such an interleaving; for example, a waiter that read true from a flag that the notifier stored right before notify_one always found a permit stored. Each now takes one scheduling point before the access:
Notify: notify_one, notify_waiters, enable(), a poll of a Notified that does not follow a wake-up, and the drop of a Notified that has not completed. Notify now wakes its waiters through the futures oneshot directly, so it takes no further scheduling points inside these. (#404, #410)mpsc: UnboundedSender::send, Permit::send and OwnedPermit::send, and the drop of the last sender. Each send now pushes its message and releases the receiver's permit in the same step: before, a receiver could run between the two, see the message in len() and get Empty from try_recv(). The drop of the last sender now closes the channel in the same step as it drops the sender count to zero, so is_closed() returns true once recv has returned None, and it no longer panics when the sender is dropped outside of an execution. The number of scheduling points per operation stays the same. (#407)oneshot: Receiver::poll (before the poll, not after a Ready one), Sender::closed, Sender::poll_closed, the drop of a Sender that did not send and the drop of a Receiver. (#410)watch: Sender::send, Sender::subscribe, the drops of the last Sender and of the last Receiver, and the reads of changed, wait_for and Sender::closed after they register for a notification. (#411)OnceCell: the store of the value that the initializer of get_or_init or get_or_try_init returns. (#413)The drops skip their scheduling point outside of an execution and after the execution stops. Query methods such as is_closed, len, receiver_count and has_changed still take none. These scheduling points add schedules to explore, so exhaustive tests of code that uses these primitives can take longer. The drop of a Notified that notify_one picked now also passes the notification on while its task unwinds a caught panic.
Publish shuttle 0.9.10, shuttle-engine 0.1.8 and shuttle-tokio-impl-inner 0.1.7. shuttle-tokio-impl-inner requires shuttle-engine 0.1.8, for switch_if_not_stopping and the public release_no_scheduling_point, and shuttle requires it for the fixes above. shuttle-std 0.1.5 and shuttle-schedulers 0.1.1 are unchanged; they take shuttle-engine as ^0.1.7 and ^0.1.1, so they build against 0.1.8 as they stand. The already-published shuttle-tokio-impl 0.1.2 and shuttle-tokio 1.0.0 require inner as ^0.1.5 and re-export it with a glob, so they pick up the fixes without being republished.
Your coding agent can read these notes before it upgrades. Set up the MCP server →
Add update and try_update to the atomic types, which std added in Rust 1.95. fetch_update is kept and not marked deprecated.
Fix locks and channels when a panic is caught with catch_unwind and the execution goes on. A Mutex or RwLock guard dropped while its task panicked closed the lock's semaphore and dropped its waiters without waking them, so a task waiting for the lock was never woken and Shuttle reported a deadlock that std doesn't have; lock() could also panic on an unwrap instead of returning a PoisonError if another task panicked between its is_closed() check and its acquire, and into_inner() on a poisoned lock panicked. A release while panicking is now an ordinary release that hands the lock to the next waiter, and the inner std::sync lock reports poisoning, as in std. More generally, Shuttle's own Drop handlers now do their bookkeeping while a task unwinds, so that, for example, a channel Sender dropped during a caught panic disconnects the channel and its receiver does not wait forever. ExecutionState::should_stop now returns true only when the execution is being abandoned or there is no execution state to update, not whenever the current thread is panicking. The tokio wrapper's primitives built on BatchSemaphore get the same behavior, which matches tokio's. (#401)
Model the atomics' fetch_update as std does, with a compare_exchange_weak loop, instead of running the callback inside a single step. A callback that accessed another sync primitive introduced a scheduling point between the load and the store, so a concurrent write could be lost; the callback now runs again on the new value, as in std. Add update and try_update to the atomic types, which std added in Rust 1.95. fetch_update is kept and not marked deprecated. (#405)
Add AtomicBool::fetch_not, which std added in Rust 1.81, and the AtomicPtr methods that std added in Rust 1.91: fetch_ptr_add, fetch_ptr_sub, fetch_byte_add, fetch_byte_sub, fetch_or, fetch_and and fetch_xor, and its fmt::Pointer impl. The bitwise operations keep the pointer's provenance, as in std. (#408)
shuttle-tokio: when a Notified that notify_one picked is dropped before it completes (for example by a select! that completes another branch), the notification is now passed on to another waiter, or stored as a permit if there is none, as in tokio. It used to be lost, so another waiter could wait forever and Shuttle reported a deadlock that tokio does not have. (#402)
Publish shuttle 0.9.9, shuttle-engine 0.1.7, shuttle-std 0.1.5 and shuttle-tokio-impl-inner 0.1.6. shuttle-std requires shuttle-engine 0.1.7, since its locks rely on a release while panicking no longer closing the semaphore, and shuttle requires both. shuttle-schedulers is unchanged at 0.1.1; it takes shuttle-engine as ^0.1.1, so it builds against 0.1.7 as it stands. The already-published shuttle-tokio-impl 0.1.2 and shuttle-tokio 1.0.0 require inner as ^0.1.5 and re-export it with a glob, so they pick up the Notify fix without being republished.
Fix shuttle-parking_lot's RwLock blocking plain readers when a second upgradable reader waits behind an existing upgradable read. Upgradable reads use
Fix shuttle-parking_lot's RwLock blocking plain readers when a second upgradable reader waits behind an existing upgradable read. Upgradable reads use the new BatchSemaphore::acquire_bypassable, so read and try_read can take available permits while the second upgradable read waits. (#400)
Publish shuttle-engine 0.1.6, shuttle 0.9.8 and shuttle-parking_lot-impl 0.1.3. shuttle now requires shuttle-engine 0.1.6, and the parking_lot implementation requires shuttle 0.9.8 or later, so updating the implementation also brings in the new semaphore API. shuttle-parking_lot stays at 0.12.5 and picks up the fix through its existing ^0.1.0 implementation dependency.
Implement task_local! in shuttle-tokio, with task::LocalKey and task::TaskLocalFuture. shuttle-tokio used to re-export tokio's, which keeps a scope's
Implement task_local! in shuttle-tokio, with task::LocalKey and task::futures::TaskLocalFuture. shuttle-tokio used to re-export tokio's, which keeps a scope's value in a thread-local that every Shuttle task shares, so tasks saw each other's values. Each task now sees only the values of its own scopes, as in tokio, so a test that read a task-local outside of its own scope, such as in a task spawned from inside one, no longer passes by accident. Requires shuttle 0.9.7. (#380)
Add current::try_get_current_task, a non-panicking get_current_task for Drop handlers and tracing subscribers. It returns None outside of an execution and while Shuttle updates its own state. (#380)
shuttle::thread::LocalKey<T> is now UnwindSafe and RefUnwindSafe for every T, like std::thread::LocalKey. It used to take both from T, so a type that held a reference to a key, such as shuttle-tokio's task::LocalKey, was not UnwindSafe if the key's value was a RefCell. (#380)
shuttle-tokio's task::try_id no longer panics outside of a Shuttle execution or while Shuttle updates its own state, as tokio's never panics. It returns None in both, even in a task, as in a tracing subscriber that handles some of Shuttle's own events, where tokio's would return the task. (#380)
A future task that finishes now drops its future before its thread-locals, as an aborted one already did, so that the destructors of futures it still owns, such as the one inside a timeout that fired, can use them. A shuttle-tokio task_local! scope held that way is now dropped with its value set, as in tokio. Likewise, the output of a detached future task, and what a thread returns once its JoinHandle is gone, are now dropped before the task's thread-locals, as std drops a thread's, so that their destructors can use them. (#380)
Fix a stack overflow when the filter of a global tracing subscriber at TRACE level calls into Shuttle, for example to read a shuttle-tokio task-local. ExecutionState::try_with asked whether its event was enabled, which runs the filters, before it set the flag that stops an access from inside the event's handling from emitting it again. (#380)
Fix a "cannot reinitialize a storage slot" panic on the first use of a thread_local! in a thread, when the key was used again while its slot was being created: by its initializer, or by a tracing subscriber of the TRACE event that Shuttle emits there. The slot created in between is kept. (#380)
Publish shuttle 0.9.7, shuttle-engine 0.1.5 and shuttle-std 0.1.4, which between them have the changes to Shuttle above, and shuttle-tokio-impl-inner 0.1.5 and shuttle-tokio-impl 0.1.2, which have the new task_local!. shuttle-std requires shuttle-engine 0.1.5, and shuttle requires both, so that upgrading to 0.9.7 brings the fixes with it. shuttle-engine 0.1.5 still works with the thread_local! of older shuttles, as LocalKey's fields are unchanged. shuttle-schedulers is unchanged at 0.1.1; it takes shuttle-engine as ^0.1.1, so it builds against 0.1.5 as it stands. Inner requires shuttle 0.9.7, which has current::try_get_current_task, and shuttle-engine 0.1.5, and impl requires inner 0.1.5. Inner stays a 0.1 release, so that crates that take it as ^0.1, as dial9-core does, share it with shuttle-tokio. But it changes what task::futures::TaskLocalFuture is, from tokio's type to its own, and impl 0.1.1 re-exports tokio's task_local! over the glob re-export of inner. So if inner is updated on its own, with cargo update -p shuttle-tokio-impl-inner say, task_local! is still tokio's, and code that names TaskLocalFuture fails to compile. Update shuttle-tokio-impl to 0.1.2 as well then, as a plain cargo update does.
Fix a stack overflow when a global tracing subscriber at TRACE level calls into Shuttle while it handles an event, for example to call current::clock(
Fix a stack overflow when a global tracing subscriber at TRACE level calls into Shuttle while it handles an event, for example to call current::clock(). Every access to the execution state emits a TRACE event, so the subscriber's own access emitted another event, which called the subscriber again, and so on until the stack overflowed, and the failure report and persisted schedule were lost with the process. Accesses made while that event is being handled no longer emit it. (#382)
Execution teardown no longer panics or aborts when destructors use Shuttle. When an execution ends, Shuttle drops the tasks that have not finished, so the destructors of everything they own run then. Almost every Shuttle operation panicked in those destructors, because it looked up the running task and there was none; the panic came from a destructor, so the process aborted, and the failure report was lost with it. Among them were Mutex::lock and try_lock (and the tokio wrapper's), RwLock, BatchSemaphore::try_acquire, atomics, channel sends, spawning, thread::current and block_on. (0.9.5 made current::clock() safe, but the operations that use the clock still looked up the running task right after it.) (#381)
Teardown now drops each unfinished task as if the execution had cancelled it as it ended, and while it does, that task is the current task: destructors can use Shuttle as the task could, and what they do is attributed to it. A task that never ran drops its function, and a future task that is parked between polls drops its future, the way an async runtime drops its tasks' futures when it shuts down, each on the task's own stack. So a destructor that blocks, on a lock that another unfinished task holds say, waits until teardown has dropped that task, and one that yields lets the others run. A future task that stopped in the middle of poll has its stack unwound once no other task can make progress. Its destructors can use Shuttle too, but cannot wait: one that blocks or panics while the stack unwinds aborts the process, as any panic during unwinding does. A task that catches the unwind is unwound again at its next scheduling point. Teardown runs the tasks in a fixed order, without the scheduler, and doesn't extend the schedule, so it is the same when the schedule is replayed. A destructor that panics fails the test like any other panic, with the schedule persisted. So do destructors that block with nothing left to wake them, which is reported like a deadlock, and a destructor that exceeds the step bound, which counts their scheduling points too. Task-local values, tags and the tasks' spans are dropped as their task, and the execution's statics last, as if by the main thread, once no task is left that could still use them. A lock that a task holds when teardown unwinds its stack is released and not poisoned, and condition variables, barriers and channels forget a task that teardown unwinds while it waits on them. A task that teardown drops is finished, and awaiting its JoinHandle returns JoinError::Cancelled.
A parked future is dropped rather than unwound now, so std::thread::panicking() is false in its destructors, and checks that are skipped while panicking now run. A tokio-test Mock with data left to read, say, now fails the test.
A failed execution is now torn down too, before its failure is raised; until now, its task-local values and statics were dropped while the failure unwound, when Shuttle was no longer there to call into. It still leaks its tasks' stacks, like a stopped execution, and with them the futures of its parked future tasks, and the functions of its tasks that never ran, unless UngracefulShutdownConfig::continuation_function_behavior is Drop. Its task-local values and statics are dropped. While a stopped or failed execution is torn down, ExecutionState::should_stop() is true, so Shuttle's own destructors skip their bookkeeping, and panics are ignored: a stopped execution doesn't fail, and a failed one reports its original failure.
Fix a lost panic: a detached task that panicked and switched out while unwinding, to release a lock say, could be dropped at the end of the execution before it finished unwinding. The panic was swallowed, and the thread stayed in a panicking state, which changed how later executions behaved. The execution now waits for a task that is unwinding a panic, even if it is detached, also if it resumed the panic with std::panic::resume_unwind, as the tokio wrapper's watch::Sender::send_modify does. A stopped execution lets such a task finish unwinding as it is torn down, but no further than catching the panic, so that the panic fails the test. A task whose unwind blocks then, on a lock that a task that no longer runs holds say, fails the test too, and its stack is leaked, which leaves the thread panicking. Tasks share the OS thread, so a task that panics while another task is unwinding a panic can't tell its panic from the other one: if it is still unwinding when the execution ends, that fails the test, and its stack is leaked too. (#381)
Fix a use after free when a stopped execution's scoped threads never ran: their functions, which borrow from their parent's stack, were dropped after that stack was freed. (#381)
A panic out of the executor, such as a scheduler's when a replayed schedule doesn't fit the test, no longer skips execution teardown, which aborted the process if a destructor then used Shuttle. (#381)
BatchSemaphore: a task that takes a permit of an unfair semaphore while an Acquire of its own is still queued on it is no longer blocked by that Acquire. Waking a waker of a task of another execution no longer panics. (#381)
Add BatchSemaphore::acquire_reserving, for unfair semaphores. The request holds nothing and waits like an acquire until min_permits permits are available, and then reserves the semaphore in the same step: from then on no other request can take a permit, and the request takes its num_permits as soon as that many are available. The reservation ends when the request is granted or its future is dropped, and while it lasts, available_permits is zero. It models a lock that holds back new requests before it holds everything it asked for, such as a parking_lot RwLock writer, which sets WRITER_BIT and then waits for the readers to leave. BatchSemaphore::upgrade on an unfair semaphore now reserves the semaphore too, as soon as no other request holds the reservation, so that nothing can overtake it while it waits for the tasks that hold permits. (#374)
Publish shuttle-engine 0.1.4 and shuttle-std 0.1.3, which between them have all of the changes above. shuttle-std now requires shuttle-engine 0.1.4, whose teardown support it uses. shuttle-schedulers is unchanged at 0.1.1; it takes shuttle-engine as ^0.1.1, so it builds against 0.1.4 as it stands. shuttle's own source is unchanged too; it now requires shuttle-engine 0.1.4 and shuttle-std 0.1.3, so that upgrading to 0.9.6 brings the fixes with it. No wrapper is republished; they get these fixes through shuttle.
Fix a process abort when a Drop handler touches a modelled Mutex, RwLock or semaphore outside a running task. Every BatchSemaphore operation looks up
Fix a process abort when a Drop handler touches a modelled Mutex, RwLock or semaphore outside a running task. Every BatchSemaphore operation looks up the running task's vector clock, and current::clock() panicked when there was no running task, when ExecutionState was already borrowed, or outside a Shuttle execution. The first case is reached whenever ExecutionState::cleanup force-unwinds a task that was still parked when the execution ended, for example after an ordinary test failure. The panic came from a destructor, so the process aborted, and the failure report and persisted schedule were lost with it. current::clock() now returns an empty clock in all three cases: an operation that belongs to no task has no causality to record. (#357)
Fix spans leaking on the thread's entered-span stack while any thread in the process holds a scoped default subscriber, such as one installed with tracing::subscriber::set_default by a concurrently running test. Shuttle exited a task's spans by calling Span::current() inside tracing::dispatcher::get_default, where it returns Span::none() while a scoped default exists anywhere in the process, so it exited nothing but still entered the execution's span. Every scheduling step leaked one entry and every Runner::run another: a span entered before a context switch was no longer current after it, and once the leaked spans had closed, a later Span::current() panicked with tried to clone a span (Id(..)) that already closed. Spans are now exited and entered through Span::with_subscriber. (#359)
A task's default tracing dispatcher is now saved and restored across context switches, like its span stack. The default dispatcher is per OS thread and every task runs on the same one, so a task that yielded inside tracing::dispatcher::with_default left its dispatcher installed while the scheduler and every other task ran: their events went to that dispatcher instead of the test's subscriber, and the task's spans stayed entered, so later events were attributed to the wrong task. If the execution was stopped or panicked while such a task was switched out, the task's default stayed installed after the execution ended too. Shuttle only parks a task's default when it may differ from the execution's, so runs without a scoped default subscriber skip it. (#359)
Deadlock reports now print blocked tasks' backtraces (captured when SHUTTLE_CAPTURE_BACKTRACE is set) with Display, in the numbered layout panics use under RUST_BACKTRACE=1, instead of with {:#?}, which printed one Debug record per frame wrapped in Some(Backtrace [ .. ]). A task without a captured backtrace prints <not captured>. Output without SHUTTLE_CAPTURE_BACKTRACE is unchanged. (#360)
Publish shuttle-engine 0.1.3, which has all of the changes above. shuttle-std and shuttle-schedulers are unchanged at 0.1.2 and 0.1.1; they take shuttle-engine as ^0.1.2 and ^0.1.1, so they build against 0.1.3 as they stand. shuttle's own source is unchanged too; it now requires shuttle-engine 0.1.3, so that upgrading to 0.9.5 brings the fixes with it.
Fix shuttle-parking_lot's upgradable read locks letting a writer in part-way through an upgrade. RwLockUpgradableReadGuard::upgrade released the permi
Fix shuttle-parking_lot's upgradable read locks letting a writer in part-way through an upgrade. RwLockUpgradableReadGuard::upgrade released the permits it held before taking the rest, so a writer already blocked on the lock was granted it first by the strictly fair semaphore: the value an upgradable reader had just read could change underneath it before its own upgrade completed. Real parking_lot guarantees the opposite — it swaps ONE_READER | UPGRADABLE_BIT for WRITER_BIT in a single atomic step and then waits only for existing readers to drain — and that guarantee is the reason to use an upgradable read at all. The lock is now modelled as permit counts on a single semaphore (shared takes 1, upgradable a strict majority, exclusive all of them), which keeps every transition between the three states atomic. Two further consequences of the old two-semaphore model are fixed along with it: try_upgrade no longer fails spuriously when a writer is merely queued, and downgrade_to_upgradable no longer deadlocks against a task that is waiting to take an upgradable read. (#351)
BatchSemaphore::upgrade now keeps the permits it already holds and acquires only the missing ones, with priority over queued waiters, instead of releasing its permits and re-acquiring the full count from the back of the queue. An upgrade therefore blocks only on tasks that currently hold permits, and cannot be overtaken by a waiter that arrived first. BatchSemaphore::try_upgrade is added as the non-blocking counterpart. (#351)
Fix a process abort when the portfolio runner aborts the remaining executions after finding a counterexample. The drop handlers of the aborted execution then ran in the context of a stopped execution, and any that touched a Shuttle primitive panicked from a drop. A stopped execution now leaks its state on the way out, as a panicking one already did. (#346)
Performance: BatchSemaphore no longer takes a std::sync::Mutex in a release-mode assertion on every Acquire poll, and allocates its Waiter only when an acquire actually blocks. Uncontended synchronization operations (Mutex, RwLock, Semaphore, channels) are 43-50% faster. (#321)
Performance: backtrace_enabled no longer reads the environment on every call. It is called from Task::block and Task::sleep, so on every block and every Poll::Pending, and std::env::var takes a lock on the environment and allocates. Lock-heavy workloads are 9-12% faster. (#322)
Better instrument backtraces for blocked futures. (#215)
Fix the annotation feature. (#334)
Publish shuttle-engine, shuttle-std and shuttle-parking_lot-impl 0.1.2. shuttle-schedulers is unchanged at 0.1.1; it takes shuttle-engine as ^0.1.1, so it builds against 0.1.2 as it stands. shuttle-parking_lot itself stays at 0.12.5, mirroring the parking_lot version it wraps: it requires the impl as ^0.1.0 and re-exports it with a glob, so it picks the RwLock fix up without being republished. The impl now requires shuttle >=0.9.4, since the fix is built on the new BatchSemaphore::upgrade.
Fix BatchSemaphore waking the wrong task when an Acquire future is polled by a task other than the one that created it (the motivating case is an in-f
BatchSemaphore waking the wrong task when an Acquire future is polled by a task other than the one that created it (the motivating case is an in-flight acquire cached inside a longer-lived object, such as a tokio Receiver that is moved between tasks). Waiters left behind by a cancelled Acquire whose task has since finished are now also treated as stale instead of consuming permits or blocking a finished task. (#317)schedule no longer iterates over tasks that have already finished. This does not change scheduling decisions. (#318)shuttle-engine, shuttle-schedulers, shuttle-std and the wrapper crates. Make shuttle-async-stream-impl publishable. (#315)shuttle-engine, shuttle-schedulers and shuttle-std 0.1.1.Add support for 128-bit atomics (AtomicI128/AtomicU128)
AtomicI128/AtomicU128) (#299)Display for TaskId to match tokio's task::Id (#307)shuttle crate into separate internal crates: shuttle-engine (core runtime and the Scheduler trait), shuttle-schedulers (built-in schedulers and check/replay helpers), and shuttle-std (the std replacement primitives) (#286, #290, #292, #294). This is an internal reorganization and does not change the shuttle public API.shuttle-std, shuttle-schedulers and shuttle-engine.Readd README that was lost in refactoring.
Fix: JoinHandle is now Send and Sync even if T is not.
JoinHandle<T> is now Send and Sync even if T is not.vector-clocks feature flag. (#187)Once can now be moved (#188 and #208)std::sync::{LockResult, PoisonError, TryLockError, TryLockResult} are now exported from shuttle::sync (#198)DEBUG (down from INFO) (#211)UniformRandomWalk scheduler added (#200)Config::immediately_return_on_panic is set then we will return immediately on a failure and not finish unwinding the panic. (#202)SHUTTLE_PERSIST_SEED in the RandomScheduler to persist schedule before running the test (to be used for aborting tests) (#201)BatchSemaphore::close_no_scheduling_point (#227)# 0.8.1 (Jun 19, 2025) * Fix bug in BatchSemaphore (#167) * Fix bug in RwLock (#170) * Add current::reset_step_count (#175) * Add spawn_local (#176) *
BatchSemaphore (#167)RwLock (#170)current::reset_step_count (#175)spawn_local (#176)thread::scope (#181)AbortHandle (#182)block_on now has one less thread switch point, which breaks schedules.
BatchSemaphore (#151)block_on now has one less thread switch point, which breaks schedules. (#155)ReplayScheduler::set_target_clock added (#156)Tasks instead of TaskIds (#156)check_random_with_seed (#161)check_random optionally take a seed by providing the environment variable SHUTTLE_RANDOM_SEED (#161)AnnotationScheduler and annotated schedule support added under feature "annotation" (#163)Implement try_send and iterators for mpsc channels
try_send and iterators for mpsc channels (#120)get_mut for Mutex and RwLock (#120)In the meantime, Tags are now implemented with a trait. This is a breaking change from 0.6.1.
Tags are now implemented with a trait. This is a breaking change from 0.6.1. (#111)is_finished() for future::JoinHandle (#118)Add scheduler to check for uncontrolled nondeterminism (#96, #97)
thread::park (#101)sync::Barrier is reused (#102){Mutex, Condvar, RwLock}::new const (#106)FuturesUnordered (#105)futures dependency (#107)This version renames the `silence_atomic_ordering_warning` configuration option to silence_warnings, as well as the corresponding environment variable
This version renames the silence_atomic_ordering_warning configuration option to silence_warnings, as well as the corresponding environment variables, to enable future warnings to be controlled by the same mechanism.
lazy_static support (#93)Tests that use shuttle::rand will need to update to the v0.8 interface of `rand`, which included some breaking changes.
This version updates the embedded rand library to v0.8. Tests that use shuttle::rand will need to update to the v0.8 interface of rand, which included some breaking changes.
rand and other dependencies (#89)future::JoinHandle (#87)Make PCT scheduling not linear in max number of tasks
* Dependency updates
Note that clients using async primitives provided by Shuttle (task spawn, block_on, yield_now) will need to be updated due to the renaming of the asyn
Note that clients using async primitives provided by Shuttle (task spawn, block_on, yield_now) will
need to be updated due to the renaming of the asynch module to future in this release.
thread::park and thread::unpark (#77)std::hint (#78)asynch module to future (#79)Note that failing test schedules created by versions of Shuttle before 0.2.0 will not successfully replay on version 0.2.0, and vice versa, as the cha
Note that failing test schedules created by versions of Shuttle before 0.2.0 will not successfully
replay on version 0.2.0, and vice versa, as the changes below affect Mutex and RwLock
scheduling decisions.
Mutex::try_lock (#71)RwLock::{try_read, try_write} (#72)std::sync::Weak (#69)Implement Condvar::wait_while and Condvar::wait_timeout_while
Condvar::wait_while and Condvar::wait_timeout_while (#59)Sized bounds on Mutex and RwLock (#62)Fix a number of issues in support for async tasks (#50, #51, #52, #54)
thread_local! macro) (#43, #53)Once cells (#49)context_switches and my_clock functions into a new current module (#56)Add shuttle::context_switches to get a logical clock for an execution
std::sync::atomic (#33)shuttle::context_switches to get a logical clock for an execution (#37)Fix a performance regression with tracing introduced by #24
tracing introduced by #24 (#31)rand crate to fix compilation issues (#29)Add a timeout option to run tests for a fixed amount of time
tracing log output (#24)thread::current (#23)Add option to bound how many steps a test runs on each iterations
yield_now a hint to the scheduler to allow validating busy loops (#18)ReplayScheduler::new_from_file (#20)Add option to persist schedules to a file
* Initial release
Nothing published for this version
One column per quarter.