EIP Lifecycle

The EIP Lifecycle is a structured governance framework defined in EIP-1 that standardizes how protocol upgrades are introduced to Ethereum. It begins with an Idea and progresses through formal stages: Draft, Review, Last Call, Final, and Stagnant. Each stage has specific criteria and community expectations, ensuring rigorous technical vetting and broad consensus before any change is implemented on the network. This process is managed by EIP Editors and involves core developers, client teams, and the wider community.

The lifecycle's core stages ensure quality and safety. A proposal enters Draft once it is properly formatted and published. It moves to Review after initial discussion, where it receives substantive feedback from developers. The Last Call stage is a final review window, typically lasting two weeks, signaling that the proposal is nearly ready for acceptance. Once consensus is reached and all objections are addressed, an EIP moves to Final, indicating it is ready for network inclusion. Proposals that see no activity for six months are marked Stagnant.

Not all EIPs follow the same path; Core EIPs that require a network upgrade (a hard fork) undergo the most scrutiny. These must be accepted by client teams, audited for security, and scheduled into a specific fork. ERC standards for applications follow a similar path but focus on community adoption rather than protocol enforcement. The lifecycle is designed to be transparent and inclusive, with all discussions and revisions tracked publicly on repositories like the Ethereum GitHub.

The final implementation of a Core EIP is coordinated through the Ethereum Cat Herders and client developers. Once an EIP reaches Final status and is included in a scheduled hard fork (e.g., London, Shanghai), it is activated on the Ethereum network at a specific block number. This marks the culmination of the lifecycle, transforming a proposal into live code. The process balances innovation with stability, preventing rushed changes that could compromise the security of the world's largest smart contract platform.

The EIP lifecycle is a formal governance process for introducing changes to the Ethereum ecosystem, modeled after the Bitcoin Improvement Proposal (BIP) and Python Enhancement Proposal (PEP) systems. An EIP is the primary mechanism for proposing new features, collecting community input, and documenting design decisions. The process is managed through the Ethereum Magicians forum and the official EIP repository on GitHub, ensuring transparency and broad participation from core developers, researchers, and the wider community.

The lifecycle begins with the Idea phase, where a concept is informally discussed. It then progresses to Draft, where a formal specification is written following the EIP template. Once ready for peer review, it moves to Review, where it is scrutinized by experts. For core protocol changes, the Last Call stage provides a final window for feedback. Ultimately, an EIP reaches a final state: Final for accepted standards, Living for continuously updated documents, Stagnant for inactivity, or Withdrawn if abandoned by the author.

Key to the process is the role of EIP Editors, who shepherd proposals, assign numbers, and manage state changes. For consensus-layer changes, a successful EIP must undergo rigorous testing and be scheduled into a specific network upgrade, or hard fork, such as London or Shanghai. This structured path from ideation to deployment ensures that changes are technically sound, widely vetted, and implemented in a coordinated manner, maintaining Ethereum's stability and decentralized ethos.

The lifecycle begins with the Idea stage, where a concept is drafted into an EIP (Ethereum Improvement Proposal) document. This draft must follow the official EIP template, specifying the technical specification, rationale, and potential backwards compatibility issues. The author then submits the draft as a pull request to the official EIPs repository, moving it into the Draft stage, where it receives a preliminary number and is open for initial community feedback.

For an EIP to progress, it must reach the Review stage, typically signaled by a request for comments from Ethereum client developers and core contributors. This phase involves rigorous technical discussion on forums and in Ethereum Magicians threads. Key considerations include security implications, implementation complexity, and network effects. An EIP may undergo multiple revisions based on this feedback before a Core EIP is considered for inclusion in a specific network upgrade, or a Standards Track EIP (like ERCs) is deemed ready for finalization.

The final stages are Last Call, a final review period for minor edits, and Final for Standards Track EIPs, indicating acceptance. For Core EIPs, the path to activation is Accepted, where it is slated for a specific hard fork (e.g., Dencun), followed by Live upon successful network activation. Proposals can be Stagnant if inactive for over six months, or Withdrawn by the author. This structured, transparent process ensures that changes to Ethereum are thoroughly vetted and consensus-driven.

The lifecycle begins with the Idea stage, where a concept is drafted and discussed informally, often on forums like Ethereum Magicians. Once formalized, the proposal enters the Draft stage, where it is assigned an EIP number and a dedicated GitHub pull request. The author, or Champion, is responsible for shepherding the proposal through technical refinement and community feedback. This stage is critical for ensuring the proposal is well-specified and addresses a clear need.

A proposal advances to the Review stage when the EIP editors deem it ready for broader scrutiny. Here, it undergoes rigorous examination by client developers, researchers, and the wider community. Key considerations include technical soundness, backward compatibility, security implications, and network effects. For core EIPs affecting the consensus layer, this stage often involves extensive simulation and testing on devnets. The goal is to reach a rough consensus among stakeholders before proceeding.

The final stages are Last Call, Final, and Active. Last Call is a final window for objections before the EIP is considered accepted. For non-core EIPs like ERCs, this leads to a Final status. Core EIPs that are accepted for a network upgrade move to a Stagnant or Living status until they are scheduled and implemented, after which they become Active. Some proposals may be Withdrawn by the author or Rejected if they fail to gain consensus. This structured process ensures that changes to Ethereum are transparent, collaborative, and robust.