coyote

Coyote is a library and tool for testing concurrent C# code and deterministically reproducing bugs. (by microsoft)

Coyote Alternatives

Similar projects and alternatives to coyote

  1. jaeger

    CNCF Jaeger, a Distributed Tracing Platform

  2. InfluxDB

    InfluxDB – Built for High-Performance Time Series Workloads. InfluxDB 3 OSS is now GA. Transform, enrich, and act on time series data directly in the database. Automate critical tasks and eliminate the need to move data externally. Download now.

    InfluxDB logo
  3. VisualFSharp

    The F# compiler, F# core library, F# language service, and F# tooling integration for Visual Studio

  4. sanitizers

    AddressSanitizer, ThreadSanitizer, MemorySanitizer

  5. tikv

    24 coyote VS tikv

    Distributed transactional key-value database, originally created to complement TiDB

  6. lucene-grep

    Grep-like utility based on Lucene Monitor compiled with GraalVM native-image

  7. loom

    10 coyote VS loom

    https://openjdk.org/projects/loom (by openjdk)

  8. BlockHound

    Java agent to detect blocking calls from non-blocking threads.

  9. SaaSHub

    SaaSHub - Software Alternatives and Reviews. SaaSHub helps you find the best software and product alternatives

    SaaSHub logo
  10. fuzzcheck-rs

    Modular, structure-aware, and feedback-driven fuzzing engine for Rust functions

  11. Automatonymous

    A state machine library for .Net - 100% code - No doodleware

  12. tlaplus-graph-explorer

    A static web application to explore and animate a TLA+ state graph.

  13. paranoid_crypto

    Paranoid's library contains implementations of checks for well known weaknesses on cryptographic artifacts.

  14. Appccelerate - State Machine

    A .net library that lets you build state machines (hierarchical, async with fluent definition syntax and reporting capabilities).

  15. shuttle

    7 coyote VS shuttle

    Shuttle is a library for testing concurrent Rust code (by awslabs)

  16. P

    12 coyote VS P

    The P programming language.

  17. arbtest

    5 coyote VS arbtest

    A minimalist property-based testing library

  18. CsCheck

    Random testing library for C#

  19. fsharp-hedgehog

    Release with confidence, state-of-the-art property testing for .NET.

  20. hedgehog

    5 coyote VS hedgehog

    Release with confidence, state-of-the-art property testing for Haskell.

  21. thread-weaver

    Discontinued A Java framework for testing multithreaded code.

  22. SaaSHub

    SaaSHub - Software Alternatives and Reviews. SaaSHub helps you find the best software and product alternatives

    SaaSHub logo
NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a better coyote alternative or higher similarity.

coyote discussion

Log in or Post with

coyote reviews and mentions

Posts with mentions or reviews of coyote. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2024-07-09.
  • What's the big deal about Deterministic Simulation Testing?
    1 project | news.ycombinator.com | 20 Aug 2024
    For anyone writing services in C# there’s a project from MSR called Coyote that does similar deterministic simulation testing by systematically testing interleavings of async code.

    https://microsoft.github.io/coyote/

  • The Deadlock Empire: An Interactive Guide to Locks
    2 projects | news.ycombinator.com | 9 Jul 2024
    In the context of C#, most code does not actively share mutable state even if it's vastly concurrent and/or parallel via Tasks or explicit threading.

    In the case when the state is still shared, most common scenarios are usually addressed by applying concurrent data structures (ConcurrentDictionary/Stack/Queue) or using a barrier/semaphoreslim.

    In case where more complex mutable state must be shared in a non-thread-safe way, it is nowadays easily addressed by using a mailbox/Channel where a single reader owns an instance of a particular class and handles concurrently submitted requests in a serialized way.

    Otherwise, I agree that correctly writing non-blocking code is extremely non-trivial, and the state space that must be handled for even most trivial cases is enormous and makes my head hurt.

    Some scenarios can be addressed by https://github.com/microsoft/coyote which simplifies the task, but it is still challenging.

  • The sad state of property-based testing libraries
    21 projects | news.ycombinator.com | 4 Jul 2024
    Given F# compiler outputs legal IL that is expected to execute in a particular way, and CoreCLR doesn't fail on importing it, and then executing it, it has probably more to do with either Coyote or other tooling that interacts with this setup.

    That is, if the issue persists. There's one that mentions F# submitted in 2020, but nothing else since: https://github.com/microsoft/coyote/issues/39

    I don't understand why there is less tolerance for having to make accommodations or take extra steps when working with F# than, let's say, when using Kotlin or Scala. Both can't use a huge amount of Java-only tooling and yet it's not seen as such a huge ordeal.

  • Does Your Test Suite Account for Weak Transaction Isolation?
    3 projects | news.ycombinator.com | 4 Jan 2024
    ex: https://github.com/microsoft/coyote/blob/main/Samples/Accoun...
  • Implementing a distributed key-value store on top of implementing Raft in Go
    5 projects | news.ycombinator.com | 25 May 2023
    Microsoft has a library/tool called Coyote* that helps with testing distributed systems; you can write tests/specifications, Coyote will systematically explore nondeterminism in your system and check if your tests still pass. If there's a failure, it'll show the sequence of events that led to the failing test.

    I started a project to implement Raft with a KV-store on top, similar to the article, meaning to use Coyote to test it; I didn't get that far before losing interest, though. It's reassuring to read that it took Phil several months to write the code in the post, it's good to know that this is a decidedly nontrivial problem.

    * https://github.com/microsoft/coyote

  • What's the best way to test parallel jobs?
    2 projects | /r/ExperiencedDevs | 18 Apr 2023
    Something like coyote by MS?
  • Using Java's Project Loom to build more reliable distributed systems
    4 projects | news.ycombinator.com | 9 May 2022
    If you're looking for similar concurrency testing in the dotnet world, checkout Coyote:

    https://microsoft.github.io/coyote/

    https://innovation.microsoft.com/en-us/exploring-project-coy...

  • Best thread sanitizer for dotnet
    1 project | /r/dotnet | 26 Feb 2022
    MS provides a framework for testing for concurrency issues: https://microsoft.github.io/coyote/.
  • Coyote: .NET library tool help ensure that your code is free of concurrency bugs
    2 projects | news.ycombinator.com | 1 Feb 2022
  • Concurrency Testing Frameworks for dotnet.
    1 project | /r/dotnet | 25 Nov 2021
    I suggest you try Microsoft Coyote
  • A note from our sponsor - InfluxDB
    www.influxdata.com | 15 May 2025
    InfluxDB 3 OSS is now GA. Transform, enrich, and act on time series data directly in the database. Automate critical tasks and eliminate the need to move data externally. Download now. Learn more →

Stats

Basic coyote repo stats
17
1,543
5.3
5 months ago

Sponsored
InfluxDB – Built for High-Performance Time Series Workloads
InfluxDB 3 OSS is now GA. Transform, enrich, and act on time series data directly in the database. Automate critical tasks and eliminate the need to move data externally. Download now.
www.influxdata.com

Did you know that C# is
the 10th most popular programming language
based on number of references?