Skip to content

Conversation

@charlesHetterich
Copy link

@charlesHetterich charlesHetterich commented Nov 5, 2025

  • still need to finalize diagrams and give better context of them

📝 Description

Provide a clear and concise description of your changes.

🔍 Review Preference

Choose one:

  • ✅ I have time to handle formatting/style feedback myself
  • ⚡ Docs team handles formatting (check "Allow edits from maintainers")

🤖 AI-Ready Docs

If content changed, regenerate AI files:

  • ✅ I ran python3 scripts/generate_llms.py
  • ⚡ Docs team will regenerate (check "Allow edits from maintainers")

✅ Checklist

- still need to finalize diagrams and give better context of them
Copy link

@github-actions github-actions bot left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Automated style guide suggestions (1-4 of 4)

…tions

- improved timeline graphs of inclusion pipeline
@charlesHetterich charlesHetterich changed the title first pass async backing technical reference Async backing technical reference Nov 7, 2025
@charlesHetterich charlesHetterich marked this pull request as ready for review November 7, 2025 15:45
@charlesHetterich charlesHetterich requested a review from a team as a code owner November 7, 2025 15:45
Copilot AI review requested due to automatic review settings November 7, 2025 15:45
@charlesHetterich charlesHetterich changed the title Async backing technical reference Add async backing technical reference Nov 7, 2025
Copy link
Contributor

Copilot AI left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Pull Request Overview

This PR adds new documentation for Polkadot's asynchronous backing and inclusion pipeline features, explaining how rollup blocks are processed and validated in the relay chain.

  • Introduces comprehensive documentation for asynchronous backing, including configuration options and visual comparisons between synchronous and asynchronous processing
  • Adds a new page explaining the inclusion pipeline stages (Generation, Backing, and Inclusion)
  • Updates the llms.txt index to reflect the new documentation pages

Reviewed Changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 9 comments.

File Description
reference/parachains/consensus/inclusion-pipeline.md New documentation page explaining the multi-step pipeline for rollup block processing, including Generation, Backing, and Inclusion stages
reference/parachains/consensus/async-backing.md New comprehensive documentation on asynchronous backing, including governance configurations, processing diagrams, and multi-core scenarios
llms.txt Updated documentation index with new page entries and incremented page count from 269 to 271

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

@charlesHetterich
Copy link
Author

This is ready for feedback. I split this up into two technical reference pages

  • Async Backing
  • Inclusion Pipeline

Everything is in good condition besides the section titled Synchronous VS. Asynchronous Processing. Before I continue spending time on it, I wanted to get feedback how to structure this section, where it should live, or if it should just be removed entirely. The intention of the section is to provide a visual understanding of what async backing is.

Additionally there are 3 empty links in inclusion-pipeline.md

  • candidate receipt
  • erasure code chunks
  • approval process (in reference to the final approval process of the inclusion pipeline)

Which, I was hoping there are definition these could link to?

@charlesHetterich charlesHetterich added A0 - New Content Pull request contains new content pages B0 - Needs Review Pull request is ready for review labels Nov 10, 2025
Copy link
Contributor

@brunopgalvao brunopgalvao left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Left my review. Overall I would focus on making sure the concept of async backing flows well for readers. I left some comments that can help in the direction.


Notice how `P2` starts before the backing stage of `P1`

In the multi-core scenario
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This heading has no explanatory text - just a diagram. Need to add context explaining what the multi-core/elastic scaling scenario demonstrates.


*in progress*

In the synchronous scenario, both the collators and validators draw context from the relay parent of the prior parablock, which lives on the relay chain. This makes the Backing and Generation steps tightly coupled to the prior parablock completing the inclusion pipeline. As a result, one parablock can be processed every other relay block, and only `0.5` seconds are assigned for execution.
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I would recommend adding context here for developers who are new to Polkadot - noting that synchronous backing was the old way, and the new, better way which is baked into the protocol is asynchronous backing. Something like this:

The Polkadot-parachain protocol originally operated in synchronous mode, where both collators and validators drew context exclusively from the relay parent of the prior parablock, which lives on the relay chain. This made the Backing and Generation steps tightly coupled to the prior parablock completing the entire inclusion pipeline. As a result, one parablock could only be processed every other relay block, with just 0.5 seconds assigned for execution.

The modern protocol now uses asynchronous backing, where both collators and validators have access to /reference/parachains/consensus/inclusion-pipeline as an additional context source. The Backing and Generation steps are no longer coupled to the prior block completing the full inclusion pipeline. Instead, the prior parablock only needs to complete the generation step and be added to the Unincluded Segments before the next parablock can begin the Backing and Generation steps.

This results in one parablock being processed every relay block (instead of every other relay block), and allows for more time to execute during the Generation step (0.5s → 2s).

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

And add links to key terms.

Copy link
Collaborator

@nhussein11 nhussein11 left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

LGTM! Left some minor comments but approved :) @charlesHetterich, please ensure you mark the conversions as solved once you've fixed those comments, whether Bruno's or mine.

## Synchronous VS. Asynchronous Processing

<!-- In the synchronous scenario, both the collators and validators draw context from the relay parent of the prior parablock, which lives on the relay chain. This makes the Backing and Generation steps tightly coupled to the prior parablock completing the inclusion pipeline. As a result, one parablock can be processed *every other* relay block, and only `0.5` seconds are assigned for execution. -->
Copy link
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Please remove all these commented lines.


* **Unincluded Segments**: Chains of candidate parablocks that have yet to be included in the relay chain, i.e. they can contain blocks at any stage pre-inclusion. The core functionality that [Async Backing](/reference/parachains/consensus/async-backing) brings is the ability to build on these unincluded segments of block ancestors rather than building only on ancestors included in the relay chain state. This context source lives on the collators.

**Generation**: Collators *execute* their blockchain's core functionality to generate a new block, producing a [proof-of-validity](https://paritytech.github.io/polkadot-sdk/book/types/availability.html?#proof-of-validity) (PoV), which is passed to validators selected for backing. The PoV is composed of:
Copy link
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Not sure how up to date is this link, or if it's maintained. I saw that Reinhard used a link to the wiki for the ticket he was addressing, maybe it'd be good if we use the same one here just to keep consistency

@eshaben eshaben assigned 0xlukem and unassigned Telucero Dec 1, 2025
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

A0 - New Content Pull request contains new content pages B0 - Needs Review Pull request is ready for review

Projects

None yet

Development

Successfully merging this pull request may close these issues.

6 participants