The Curious Engineer

All blogs / Rust

Yosh Wuyts

blog.yoshuawuyts.com

Yoshua Wuyts's blog

RustConcurrencyCompilers

’16’17’18’19’20’21’22’23’24’25’26
Posts
110 from 21 Mar 2016 to 29 Oct 2026
Posting
monthly (9 in the last year)
Kind
personal blog
Feed
https://blog.yoshuawuyts.com/rss.xml

2026 8

  1. The Future Trait Has A Missing State
  2. Four levels of in-place initialization
  3. Capture Clauses as Effects
  4. Hoisting Expressions
  5. Why Effects?
  6. An Effect Notation Based on With-Clauses and Blocks
  7. Why WebAssembly Components
  8. A Grand Vision for Rust

2025 14

  1. Syntactic Musings on the Fallibility Effect
  2. Placing Arguments
  3. Placing Functions
  4. Tree-Structured Concurrency II: Replacing Background Tasks With Actors
  5. Async Traits Can Be Directly Backed by Manual Future Impls
  6. The Waker Allocation Problem
  7. Open and Closed Effect Systems
  8. Automatic Interleaving of High-Level Concurrent Operations
  9. Automatic Concurrent Await
  10. Syntactic Musings on Match Expressions
  11. Syntactic Musings on View Types
  12. A Survey of Every Iterator Variant
  13. Musings on Iterator Trait Names
  14. The Gen Auto-Trait Problem

2024 12

  1. What Are Temporal and Spatial Memory Safety?
  2. Why `Pin` is a Part of Trait Signatures (and Why That's a Problem)
  3. Solving my RSI issues
  4. Further simplifying self-referential types for Rust
  5. Ergonomic Self-Referential Types for Rust
  6. In-Place Construction Seems Surprisingly Simple?
  7. Context Managers: Undroppable Types for Free
  8. Tasks Are the Wrong Abstraction
  9. Shipping Jco 1.0, WASI 0.2
  10. Designing an Async Runtime for WASI 0.2
  11. Extending Rust's Effect System
  12. Will it Block?

2023 18

  1. Reframing WIT as Primarily a Machine Format
  2. Reasoning About ABIs
  3. What is a Team?
  4. Iterator as an Alias
  5. Async Iteration III: The Async Iterator Trait
  6. Nesting Allocators
  7. Totality
  8. Bridging Fuzzing and Property Testing
  9. Tree-Structured Concurrency
  10. What is WASI?
  11. Pattern Extensions
  12. Linear Types One-Pager
  13. Linearity and Control
  14. Using HTML as a Compile Target
  15. Capability-Safety I: Prelude
  16. Domain-Specific Error Macros
  17. Rust Should Own Its Debugger Experience
  18. State Machines III: Type States

2022 15

  1. 2022 in Review
  2. Rust 2023 (by Yosh)
  3. Async Iteration II: The Async Iterator Crate
  4. Keywords II: Const Syntax
  5. Inline Crates
  6. Why Async Rust
  7. Futures Concurrency IV: Join Ergonomics
  8. State Machines II: an enum-based design
  9. Announcing the Keyword Generics Initiative
  10. Keywords I: Unsafe Syntax
  11. Async Cancellation II: Time and Signals
  12. Postfix Spawn
  13. Safe Pin Projections Through View Types
  14. More Enum Types
  15. Futures Concurrency III: Select!

2021 7

  1. Uninit Read/Write
  2. Async Cancellation I
  3. Futures Concurrency II: A Trait Approach
  4. Async Overloading
  5. Optimizing Hashmaps Even More
  6. Refcounts
  7. Futures Concurrency Notes: Join and Const-Eval

2020 12

  1. Rust 2021
  2. Async Iteration I: Iteration Semantics
  3. Notebooks
  4. Reliability
  5. Fallible Iterator Adapters
  6. Nine Patches
  7. State Machines: Introduction
  8. Parallel-Stream
  9. IO Delegation for Arc
  10. Async HTTP
  11. Tide Channels
  12. Byte Ordered Streams

2019 22

  1. Streams Concurrency
  2. Rust 2020
  3. Tide
  4. Error Handling Survey
  5. Runtime Diagnostics
  6. Async Builders
  7. Futures Concurrency I: Introduction
  8. Surf
  9. Async Log
  10. Std Time
  11. Rust Streams
  12. Paw
  13. Graphs
  14. Runtime
  15. Contexts
  16. DSLs II: Challenges
  17. Async Ecosystem WG
  18. DSLs I: Introduction
  19. Product Strategy
  20. WASM 2019
  21. Rust 2019
  22. Plans for 2019

2018 1

  1. A New Blog

2016 1

  1. Pull Streams