diff --git a/articles/cdr-counterfactual-accounting/components/accounting-graph.js b/articles/cdr-counterfactual-accounting/components/accounting-graph.js
new file mode 100644
index 00000000..cc868b9a
--- /dev/null
+++ b/articles/cdr-counterfactual-accounting/components/accounting-graph.js
@@ -0,0 +1,534 @@
+import React from 'react'
+import {
+ Bar,
+ Chart,
+ Plot,
+ Axis,
+ AxisLabel,
+ Label,
+ Line,
+} from '@carbonplan/charts'
+import { Arrow } from '@carbonplan/icons'
+import calculateNetCDR from './scenario-calculations'
+import { alpha } from '@theme-ui/color'
+import { Box, useThemeUI } from 'theme-ui'
+import { Row, Column } from '@carbonplan/components'
+
+import { Emissions, Hatching, Removals } from './svg-elements'
+
+const iconWidths = [80, 90, 100, 110]
+
+const AccountingGraph = ({ approach, inputs, showNet = true }) => {
+ const { theme } = useThemeUI()
+
+ const results = calculateNetCDR(inputs)
+ const result = results.find((r) => r.acct_approach === approach)
+ if (!result) return null
+ const {
+ E_COUNT_counted = 0,
+ E_COUNT = 0,
+ R_COUNT_counted = 0,
+ R_COUNT = 0,
+ R_PROJ = 0,
+ R_PROJ_counted = 0,
+ E_PROJ = 0,
+ E_PROJ_counted = 0,
+ netCDR = 0,
+ netCDR_Nae = 0,
+ netCDR_ae = 0,
+ } = result
+
+ const netEmissionsNoAvoided = netCDR_Nae > 0 ? netCDR_Nae : 0
+ const netRemovalsNoAvoided = netCDR_Nae < 0 ? netCDR_Nae : 0
+
+ let xLimits = [0, 2.5]
+ let xSpacing = {
+ counterfactual: 0.5,
+ project: 1.25,
+ net: 2,
+ }
+ let barWidth = 0.6
+
+ if (!showNet) {
+ xSpacing = {
+ priorIcon: 1.5,
+ counterfactual: 3,
+ projectIcon: 5.5,
+ project: 7,
+ net: 1,
+ }
+ xLimits = [0, 8]
+ barWidth = 0.2
+ }
+
+ const chartSpacing = 24
+ const chartHeight = 200
+
+ const emissionsDataCounted = [
+ [xSpacing.counterfactual, E_COUNT_counted],
+ [xSpacing.project, E_PROJ_counted],
+ ...(showNet ? [[xSpacing.net, netEmissionsNoAvoided]] : []),
+ ]
+
+ const emissionsDataTotal = [
+ [xSpacing.counterfactual, E_COUNT_counted, E_COUNT],
+ [xSpacing.project, E_PROJ_counted, E_PROJ],
+ ...(showNet ? [[xSpacing.net, 0, netCDR]] : []),
+ ]
+
+ const removalsDataCounted = [
+ [xSpacing.counterfactual, R_COUNT_counted],
+ [xSpacing.project, R_PROJ_counted],
+ ...(showNet ? [[xSpacing.net, netCDR]] : []),
+ ]
+
+ const removalsDataTotal = [
+ [xSpacing.counterfactual, R_COUNT_counted, R_COUNT],
+ [xSpacing.project, R_PROJ_counted, R_PROJ],
+ ...(showNet ? [[xSpacing.net, netRemovalsNoAvoided, netCDR]] : []),
+ ]
+
+ const alphaGrey = alpha('grey', 0.5)(theme)
+ const alphaPurple = alpha('purple', 0.5)(theme)
+
+ const maxValue =
+ Math.max(
+ Math.abs(R_COUNT),
+ Math.abs(R_PROJ),
+ Math.abs(E_COUNT),
+ Math.abs(E_PROJ)
+ ) * 1.2
+ const yLimitsRemovals = -maxValue
+ const yLimitsEmissions = maxValue
+
+ return (
+
+
+ {/* Emissions Chart */}
+
+
+
+
+
+ Emissions{' '}
+
+
+
+
+
+
+ {approach === 4 && showNet && (
+ <>
+
+
+
+
+ )}
+ {approach === 2 && showNet && (
+ <>
+
+
+
+ )}
+
+
+
+ {showNet ? (
+ <>
+
+ {approach === 4 && (
+
+ )}
+
+ ) : (
+ <>
+
+
+
+ )}
+
+
+ {showNet && (
+ <>
+
+ {approach === 2 && showNet && (
+
+ )}
+
+ )}
+
+
+
+ {/* Removals Chart */}
+
+
+
+
+
+ {' '}
+ Removals
+
+
+
+
+
+
+ {approach === 1 && showNet && (
+ <>
+
+
+
+ )}
+
+
+
+
+ {showNet ? (
+ <>
+
+ {approach === 1 && showNet && (
+
+ )}
+
+ ) : (
+ <>
+
+
+
+ )}
+
+
+
+
+ )
+}
+
+export default AccountingGraph
diff --git a/articles/cdr-counterfactual-accounting/components/net-cdr.js b/articles/cdr-counterfactual-accounting/components/net-cdr.js
new file mode 100644
index 00000000..45a50c58
--- /dev/null
+++ b/articles/cdr-counterfactual-accounting/components/net-cdr.js
@@ -0,0 +1,428 @@
+import React, { useState } from 'react'
+import { Box, Flex } from 'theme-ui'
+import { Badge, Column, Row, Select, Slider } from '@carbonplan/components'
+import {
+ Chart,
+ Plot,
+ Bar,
+ Label,
+ Line,
+ TickLabels,
+ Axis,
+ Ticks,
+} from '@carbonplan/charts'
+
+import calculateNetCDR from './scenario-calculations'
+import { Hatching } from './svg-elements'
+import { Arrow } from '@carbonplan/icons'
+
+const inputConfigs = {
+ alkalinityCounterfactual: {
+ color: 'grey',
+ label: 'Counterfactual Alkalinity',
+ min: 0,
+ max: 30,
+ step: 1,
+ },
+ alkalinityProject: {
+ color: 'purple',
+ label: 'Project Alkalinity',
+ min: 0,
+ max: 30,
+ step: 1,
+ },
+ emissionsFactorCounterfactual: {
+ color: 'grey',
+ label: 'Counterfactual Emissions Factor',
+ min: 0,
+ max: 2,
+ step: 0.1,
+ },
+ emissionsFactorProject: {
+ color: 'purple',
+ label: 'Project Emissions Factor',
+ min: 0,
+ max: 2,
+ step: 0.1,
+ },
+ removalFactorCounterfactual: {
+ color: 'grey',
+ label: 'Counterfactual Removal Factor',
+ min: -1,
+ max: 1,
+ step: 0.1,
+ },
+ removalFactorProject: {
+ color: 'purple',
+ label: 'Project Removal Factor',
+ min: -1,
+ max: 1,
+ step: 0.1,
+ },
+}
+
+const approachMap = {
+ 1: 'Simple subtraction',
+ 2: 'Ignore obvious avoided emissions',
+ 3: 'Conservative',
+ 4: 'Separate the replacement',
+}
+
+const InputSlider = ({ name, value, config, onChange }) => (
+
+
+ {value.toFixed(config.step < 1 ? 1 : 0)}
+
+ onChange(name, parseFloat(e.target.value))}
+ />
+
+)
+
+const Graph = ({ results }) => {
+ const yValues = [0, 5]
+
+ const xValues = [-40, 40]
+
+ const totalBar = results.map((result, index) => [
+ 4 - index + 0.35,
+ result.netCDR,
+ ])
+
+ const aeBar = results.map((result, index) => {
+ if (result.netCDR <= 0) {
+ if (result.netCDR_Nae > 0) {
+ return [4 - index + 0.35, result.netCDR]
+ }
+ return [4 - index + 0.35, result.netCDR_Nae, result.netCDR]
+ }
+ return [4 - index + 0.35, 0, 0]
+ })
+
+ const barWidth = 0.4
+
+ return (
+
+
+
+ {' '}
+ Removals
+
+
+ Emissions
+
+
+
+
+
+
+ Math.abs(value)} />
+
+
+
+
+
+
+ {results.map((result, index) => (
+
+ ))}
+
+ {results.map((result, index) => (
+
+
+
+
+ ))}
+
+
+
+ )
+}
+
+const NetCDR = ({ presets }) => {
+ const [inputs, setInputs] = useState(Object.values(presets)[0])
+ const [isPresetActive, setIsPresetActive] = useState(true)
+ const [selectedPreset, setSelectedPreset] = useState(Object.keys(presets)[0])
+
+ const handleInputChange = (name, value) => {
+ setIsPresetActive(false)
+ setInputs((prevInputs) => ({ ...prevInputs, [name]: value }))
+ }
+
+ const results = calculateNetCDR(inputs)
+
+ return (
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Prior liming
+
+
+
+
+ CDR Project
+
+
+
+
+
+
+
+ Preset
+
+
+
+
+
+
+
+
+
+
+ Rock (tons)
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Emissions / ton rock
+
+
+
+
+
+
+
+
+
+
+
+ )
+}
+
+export default NetCDR
diff --git a/articles/cdr-counterfactual-accounting/components/scenario-calculations.js b/articles/cdr-counterfactual-accounting/components/scenario-calculations.js
new file mode 100644
index 00000000..2d690581
--- /dev/null
+++ b/articles/cdr-counterfactual-accounting/components/scenario-calculations.js
@@ -0,0 +1,205 @@
+function calculateNetRemoval(
+ alkC,
+ alkP,
+ rFacC,
+ rFacP,
+ negRemovalsOnly = false
+) {
+ const RPROJ = alkP * rFacP
+ const RCOUNT = alkC * rFacC
+
+ const R2 = negRemovalsOnly ? Math.max(0, RCOUNT) : RCOUNT
+ const RNet = -1 * (RPROJ - R2)
+
+ return {
+ R_net: RNet,
+ R_PROJ: -1 * RPROJ,
+ R_PROJ_counted: -1 * RPROJ,
+ R_COUNT: -1 * RCOUNT,
+ R_COUNT_counted: -1 * R2,
+ }
+}
+
+function calculateNetEmissionsA1(alkC, alkP, eFacC, eFacP) {
+ const EPROJ = alkP * eFacP
+ const ECOUNT = alkC * eFacC
+ const ENet = EPROJ - ECOUNT
+
+ return {
+ E_net: ENet,
+ E_PROJ: EPROJ,
+ E_PROJ_counted: EPROJ,
+ E_COUNT: ECOUNT,
+ E_COUNT_counted: ECOUNT,
+ }
+}
+
+function calculateNetEmissionsA2(alkC, alkP, eFacC, eFacP) {
+ const EPROJ = alkP * eFacP
+ const ECOUNT = alkC * eFacC
+
+ const EPROJCounted = EPROJ
+ const ECOUNTCounted = EPROJ - ECOUNT < 0 ? EPROJCounted : ECOUNT
+ const ENet = EPROJCounted - ECOUNTCounted
+
+ return {
+ E_net: ENet,
+ E_PROJ: EPROJ,
+ E_PROJ_counted: EPROJCounted,
+ E_COUNT: ECOUNT,
+ E_COUNT_counted: ECOUNTCounted,
+ }
+}
+
+function calculateNetEmissionsA3(alkC, alkP, eFacC, eFacP) {
+ const EPROJ = alkP * eFacP
+ const ECOUNT = alkC * eFacC
+
+ return {
+ E_net: EPROJ,
+ E_PROJ: EPROJ,
+ E_PROJ_counted: EPROJ,
+ E_COUNT: ECOUNT,
+ E_COUNT_counted: 0,
+ }
+}
+
+function calculateNetEmissionsA4(alkC, alkP, eFacC, eFacP) {
+ const EPROJ = alkP * eFacP
+ const ECOUNT = alkC * eFacC
+
+ const alkAdditional = Math.max(alkP - alkC, 0)
+ const EPROJAdditional = alkAdditional * eFacP
+ const EPROJReplacement = EPROJ - EPROJAdditional
+
+ const E2 = Math.max(0, Math.round((EPROJReplacement - ECOUNT) * 100) / 100)
+
+ const EPROJCounted = E2 === 0 ? EPROJReplacement + EPROJAdditional : EPROJ
+ const ECOUNTCounted = E2 === 0 ? EPROJReplacement : ECOUNT
+
+ const ENet = EPROJAdditional + E2
+
+ return {
+ E_net: ENet,
+ E_PROJ: EPROJ,
+ E_PROJ_counted: EPROJCounted,
+ E_COUNT: ECOUNT,
+ E_COUNT_counted: ECOUNTCounted,
+ }
+}
+
+function calculateNetCDR({
+ alkalinityCounterfactual,
+ alkalinityProject,
+ emissionsFactorCounterfactual = 1,
+ emissionsFactorProject = 1,
+ removalFactorCounterfactual = 1,
+ removalFactorProject = 1,
+ ignorePositiveCounterfactual = false,
+}) {
+ const removals = [
+ calculateNetRemoval(
+ alkalinityCounterfactual,
+ alkalinityProject,
+ removalFactorCounterfactual,
+ removalFactorProject,
+ false
+ ),
+ calculateNetRemoval(
+ alkalinityCounterfactual,
+ alkalinityProject,
+ removalFactorCounterfactual,
+ removalFactorProject,
+ true
+ ),
+ calculateNetRemoval(
+ alkalinityCounterfactual,
+ alkalinityProject,
+ removalFactorCounterfactual,
+ removalFactorProject,
+ true
+ ),
+ calculateNetRemoval(
+ alkalinityCounterfactual,
+ alkalinityProject,
+ removalFactorCounterfactual,
+ removalFactorProject,
+ true
+ ),
+ ]
+
+ const emissions = [
+ calculateNetEmissionsA1(
+ alkalinityCounterfactual,
+ alkalinityProject,
+ emissionsFactorCounterfactual,
+ emissionsFactorProject
+ ),
+ calculateNetEmissionsA2(
+ alkalinityCounterfactual,
+ alkalinityProject,
+ emissionsFactorCounterfactual,
+ emissionsFactorProject
+ ),
+ calculateNetEmissionsA3(
+ alkalinityCounterfactual,
+ alkalinityProject,
+ emissionsFactorCounterfactual,
+ emissionsFactorProject
+ ),
+ calculateNetEmissionsA4(
+ alkalinityCounterfactual,
+ alkalinityProject,
+ emissionsFactorCounterfactual,
+ emissionsFactorProject
+ ),
+ ]
+
+ const counterfactualCheck =
+ alkalinityCounterfactual *
+ (emissionsFactorCounterfactual - removalFactorCounterfactual)
+
+ let netCDRResults = []
+
+ const approachOrder = [1, 2, 4, 3] // switch 3 and 4
+
+ if (ignorePositiveCounterfactual && counterfactualCheck >= 0) {
+ const netCDRValue = removals[0].R_PROJ + emissions[0].E_PROJ
+
+ netCDRResults = approachOrder.map((approach) => ({
+ ...emissions[approach - 1],
+ ...removals[approach - 1],
+ netCDR: netCDRValue,
+ netCDR_ae: 0,
+ netCDR_Nae: netCDRValue,
+ acct_approach: approach,
+ }))
+
+ netCDRResults.forEach((result) => {
+ result.E_COUNT_counted = 0
+ result.R_COUNT_counted = 0
+ })
+ } else {
+ netCDRResults = approachOrder.map((approach) => {
+ const netCDR =
+ removals[approach - 1].R_net + emissions[approach - 1].E_net
+
+ const netCDRAe =
+ -1 * Math.max(0, emissions[3].E_net - emissions[approach - 1].E_net)
+ const netCDRNae = netCDR - netCDRAe
+
+ return {
+ ...emissions[approach - 1],
+ ...removals[approach - 1],
+ netCDR: netCDR,
+ netCDR_ae: netCDRAe,
+ netCDR_Nae: netCDRNae,
+ acct_approach: approach,
+ }
+ })
+ }
+
+ return netCDRResults
+}
+
+export default calculateNetCDR
diff --git a/articles/cdr-counterfactual-accounting/components/svg-elements.js b/articles/cdr-counterfactual-accounting/components/svg-elements.js
new file mode 100644
index 00000000..c4730d6c
--- /dev/null
+++ b/articles/cdr-counterfactual-accounting/components/svg-elements.js
@@ -0,0 +1,406 @@
+import React from 'react'
+import { Box, useThemeUI } from 'theme-ui'
+
+export const Emissions = ({ isProject, sx }) => {
+ const { theme } = useThemeUI()
+ return (
+ <>
+ {isProject ? (
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ) : (
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ )}
+
+ )
+}
+
+export const Removals = ({ isProject, sx }) => {
+ const { theme } = useThemeUI()
+
+ return (
+ <>
+ {isProject ? (
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ) : (
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ )}
+
+ )
+}
+
+export const Hatching = ({ vertical = true }) => {
+ const { theme } = useThemeUI()
+ return (
+
+
+
+
+
+
+ )
+}
diff --git a/articles/cdr-counterfactual-accounting/index.md b/articles/cdr-counterfactual-accounting/index.md
new file mode 100644
index 00000000..3a8ce137
--- /dev/null
+++ b/articles/cdr-counterfactual-accounting/index.md
@@ -0,0 +1,306 @@
+---
+version: 1.0.0
+title: Crediting challenges when carbon removal comes with avoided emissions
+authors:
+ - Tyler Kukla
+ - Shane Loeffler
+ - Kata Martin
+ - Freya Chay
+date: 11-13-2024
+summary: Some carbon removal projects also result in avoided emissions. This is good for the climate, but can pose challenges for individual projects that are trying to earn carbon removal credits.
+quickLook: Some carbon removal projects also result in avoided emissions. This is good for the climate, but can pose challenges for individual projects that are trying to earn carbon removal credits.
+color: grey
+card: cdr-counterfactual-accounting
+background: articles/029/cairn
+icon: articles/029/cairn-small
+links:
+ - label: Supplemental methods
+ href: /research/cdr-counterfactual-accounting-methods
+components:
+ - name: AccountingGraph
+ src: ./components/accounting-graph.js
+---
+
+It’s possible — and increasingly popular — to achieve carbon removal (CDR) by tweaking an existing process rather than creating a new one. From modifying the use of alkalinity to treat wastewater, to switching what kinds of rocks farmers use to raise the pH of their soils, these projects are now common enough that we’ve started referring to them as CDR “optimization projects.” Optimization projects are exciting because they could help clean up emissions-intensive systems and remove carbon from the atmosphere without requiring a lot of new physical investments. They’re the definition of low-hanging fruit. But supporting them via carbon removal credits requires dealing with some tricky carbon accounting questions.
+
+Optimization projects are meant to remove carbon, but often also end up avoiding emissions associated with the processes they tweak. To issue carbon removal credits, it is therefore necessary to distinguish between the removal and avoided emissions benefits. But there are different ways to separate the benefits, and seemingly small changes to the accounting rules can produce markedly different crediting outcomes.
+
+The rules that are used to credit optimization projects today are often too vague to evaluate whether or not the credits conflate carbon removal and avoided emissions. This ambiguity sets a concerning precedent given the expectation that carbon removal and avoided emissions credits are distinct benefits. To build a credible market for carbon removal credits, these protocols will have to change, establishing clear and precise rules to differentiate removals.
+
+But these issues also highlight the fact that carbon removal credits might not be the best way to finance all optimization projects. Crediting removals offers little incentive to reduce existing process emissions. Moreover, as we’ll show, taking a careful approach to crediting removals can actually penalize optimization projects in cases where separating out the avoided emissions is hard. Optimization projects can bring some easy climate wins that we shouldn’t ignore. But we also shouldn’t bend the definition of carbon removal to make them work. Instead, we should start thinking about other ways to support these projects that don’t require the line between removals and avoided emissions to be so rigidly defined.
+
+## Avoided emissions can hide in carbon removal credits
+
+Emissions reduction represents the bulk of the work needed to slow climate change, but carbon removal will likely be needed to stop climate change or reverse it. Following this logic, the carbon market has coalesced around differentiating credits that represent carbon removal from those representing avoided emissions.See, for example, the [Oxford Principles for Net Zero Aligned Carbon Offsetting](https://www.smithschool.ox.ac.uk/sites/default/files/2024-02/Oxford-Principles-for-Net-Zero-Aligned-Carbon-Offsetting-revised-2024.pdf) and [SBTi’s Corporate Net-Zero Standard](https://sciencebasedtargets.org/resources/files/Net-Zero-Standard.pdf). This distinction has also become a focus of broader CDR policy conversations, with growing advocacy around establishing separate policy targets for emission reductions and carbon removals.In January 2024, over 100 academics, research institutes, NGOs, and companies signed an [open letter](https://carbonmarketwatch.org/wp-content/uploads/2024/01/High-Level-Letter-w_-Logos-signatories-rev.-15_02.pdf) calling for the adoption of separate targets for carbon removal and emission reduction. CarbonPlan was a signatory.
+
+To quantify the climate benefit of a CDR optimization project, it must be compared to the counterfactual — what would have happened if the CDR project did not exist. But the counterfactual, like the project itself, can include both carbon removals and emissions. Because of this complexity, some accounting approaches comparing the project and counterfactual can end up hiding avoided emission benefits within credits that are labeled as carbon removal.
+
+We’re going to use enhanced rock weathering (ERW) as a case study to illustrate how accounting rules might inadvertently conflate avoided emission and carbon removals. ERW uses crushed rock to accelerate natural chemical reactions that remove CO₂ from the atmosphere. Many farmers already spread crushed rock on their fields, usually limestone, to raise soil pH. ERW attempts to optimize this existing agricultural process by changing the quantity or type of rock applied. The fact that “liming” is already widespread is often seen as an advantage of ERW — we already know how to spread crushed rock and we have the infrastructure to do it.
+
+Figure 1 shows a simplified example of an ERW project where traditional liming has been optimized for CDR. In this hypothetical scenario, the traditional liming practice applied 15 tons of rock, whereas the CDR project now applies 20 tons of rock. We assume that traditional liming was climate neutral; the CO₂ removal from rock weathering perfectly balanced out the emissions from sourcing and spreading the rock (gray bars).Note that most liming is done with calcite limestone (CaCO₃) which, when it dissolves, may remove carbon from the atmosphere or emit the carbon previously contained in the rock depending on soil conditions. In contrast, the CDR project removes twice as much carbon than it emits (purple bars). Compared to the traditional liming practice, it achieves more removal with fewer emissions.Our example assumes we know the counterfactual carbon fluxes and can confidently estimate carbon removal from rock weathering. Both of these are [challenging](https://carbonplan.org/research/enhanced-weathering-fluxes) quantification tasks for enhanced weathering projects.
+
+
+
+
+ Emissions and removals for the hypothetical prior liming practice (gray) and
+ CDR project (purple) scenarios. The CDR project applies 20 tons of rock and
+ the prior liming practice applies 15. Project emissions come from activities
+ like sourcing, crushing, transporting, and spreading the rock, and removals
+ occur as the rock weathers.
+
+
+
+In this scenario, how much additional carbon removal has the CDR project achieved? It seems clear that the question requires comparing the project scenario to the traditional liming scenario. But surprisingly, the answer changes based on the details of how the comparison is made. Below, we illustrate four potential approaches that lead to four different answers about how much net CDR has been achieved. The answers range from 10 tCO₂ removed to 5 tCO₂ emitted. For a more detailed explanation of the four approaches and the ability to test them on different project and counterfactual scenarios, see our [supplemental methods](https://carbonplan.org/research/cdr-counterfactual-accounting-methods).
+
+### Approach 1: Simple subtraction
+
+The simplest approach is to compare the net carbon removal achieved by the CDR project to the net carbon removal achieved by the traditional liming. Although this sounds like a reasonable method to identify additional carbon removal, it offers no way to distinguish between avoided emissions and carbon removals. In our example, traditional liming resulted in zero tons of net carbon removal while the CDR project results in 10 tons of net removals. The simple subtraction approach would therefore credit the CDR project for 10 tons of removal (Figure 2, green bar). But under the hood, over half of those credits would represent avoided emissions (Figure 2, hatched green bar). Counting them would lead to over-crediting the carbon removal.
+
+
+
+
+ Net CDR using the simple subtraction approach. Gray and purple bars denote
+ carbon fluxes for the traditional liming and CDR project cases,
+ respectively. The green bar shows the total amount of removals that this
+ accounting approach gives the project credit for. The hatched portion of the
+ green bar represents credited removals owed to avoiding counterfactual
+ emissions. While avoided emissions obviously account for half of the total
+ in green, there are other avoided emissions that are less obvious and still
+ have to be accounted for in crediting.
+
+
+
+### Approach 2: Ignore obvious avoided emissions
+
+In the second approach, the CDR project can ignore emissions that would have occurred in the traditional liming scenario, but it doesn’t get credit for the obvious avoided liming emissions that exceed the total project emissions. In our example, traditional liming emits 5 more tons than the CDR project. Even though those emissions are avoided in the project scenario, the project can’t claim removal credits for them (Figure 3).
+
+
+
+
+ As Figure 2, but for Approach 2 — ignore obvious avoided emissions. The
+ shaded component of the gray emissions bar indicates the part of the total
+ activity that is ignored in the carbon accounting.
+
+
+
+Unfortunately, this approach can still end up over-crediting the removal by counting some of the avoided emissions. To illustrate, recall that the CDR project applies 20 tons of rock while the traditional liming practice applies 15 tons of rock. By weight, we can think about the project as replacing the 15 tons from liming that would have happened anyway, while also adding 5 extra tons of rock on top.We are making the simplifying assumption here that in both the liming scenario and the project scenario, 1 ton of rock results in 1 ton of removal. This removal efficiency is high and, in practice, will vary based on rock types and application rates. But, despite using that extra 5 tons, the CDR project emits less carbon overall. Using Approach 2, that means the project has no emissions burden — the project emissions minus the traditional liming emissions equals zero (Figure 3). Even though the extra 5 tons don’t replace the traditional liming practice, their emissions are “offset” by the avoided liming emissions and that increases the net CDR claimed.
+
+### Approach 3: Separate the replacement portion of the project
+
+If we could differentiate between the “replacement” rock and the “extra” rock, then we could reliably separate out the avoided liming emissions. The third approach does this by comparing only the replacement rock (not the extra rock) against the traditional liming practice. If the replacement rock’s emissions are lower than the traditional liming emissions, the replacement emissions are ignored. In our hypothetical, the project emits 7.5 tons of CO₂ to replace the amount of rock used in the traditional liming practice. The traditional liming emissions offset those 7.5 tons, but they don’t offset the 2.5 tons of emissions required to source the extra 5 tons of rock. This means that whether you add 5 tons of rock or improve the efficiency of the baseline process _and_ add 5 tons of rock, you get the same net CDR result. In our example, this approach would credit the project for 2.5 tons of carbon removal (Figure 4). Unfortunately, there are major practical limitations to this approach.
+
+
+
+
+ As Figures 2 and 3, but for Approach 3 — separate the replacement portion of
+ the project. The CDR project emits 7.5 tons to replace the traditional
+ liming practice, so those emissions are balanced by the avoided liming
+ emissions. The extra 2.5 tons of project emissions are tied to the “extra”
+ rock, so those are not compared to the prior liming activity.
+
+
+
+It can be surprisingly hard to define which part of an optimization project is “replacing” the traditional practice. We assumed the project rock replaces the traditional liming practice by weight (15 tons for 15 tons), but this is usually a bad assumption. The same mass of two rock types can have very different effects on soil pH, soil mineralogy, and carbon removal. Even if the effects are similar by weight, they can dissolve at different rates and lead to different outcomes over time. Swapping one rock for another is usually an apples-to-oranges comparison — it can be hard to define what “replacing” the prior rock even means. In the absence of a clear answer, these complicated dynamics may render Approach 3 impractical.
+
+### Approach 4: Conservative
+
+This leads us to the fourth approach, which reliably separates avoided emissions from removal credits without the practical challenges of Approach 3 — but it comes at a cost. Unlike the other approaches, this approach requires the CDR project to account for _all_ of its associated emissions, whether they replace an existing process or not. The CDR project must deduct the removals from the traditional liming practice, but it cannot deduct any emissions. This “double-whammy” makes it harder for optimization projects to earn removal credits. In our example, even though the CDR project emits less carbon and removes more than traditional liming would have, the conservative approach casts it as net emitting (Figure 5, green bar).
+
+
+
+
+ As Figure 2-4, but for Approach 4 — conservative. The prior liming emissions
+ cannot be used to balance any CDR project emissions. As a result, the
+ project is net emitting and no carbon removal credits are earned (green
+ bar).
+
+
+
+In practice, this means that using the conservative approach could actively disincentivize optimization projects. It doesn’t make sense to modify the baseline activity if it raises your emissions burden and you don’t get any credit for improving the status quo. In that case, a company may be better off allowing the baseline activity to continue, no matter how emissions-intensive it is, and just add extra rock on top of it.
+
+## Takeaways
+
+So long as credits are being sold as carbon removal, it’s important to maintain a clear distinction between CDR and avoided emissions. This means Approaches 1 and 2 don’t work for CDR crediting because they can embed avoided emissions. Approach 3 can work, but only if there is a clear way to define the part of the project which replaces the counterfactual activity. Otherwise, the only option is Approach 4, which could severely limit the range of optimization projects that are viable via carbon removal credit sales.
+
+Of current ERW protocols (Table 1), only Isometric’s clearly addresses this counterfactual accounting problem, and it uses the conservative approach. The counterfactual accounting rules in the other protocols are too vague to interpret. Neither Puro’s nor Carbon Standard International’s protocols offer explicit guidance on how to handle counterfactual rock application. Puro’s protocol generally acknowledges that the counterfactual scenario should be considered, but does not specify how.
+
+
+
+ Registry
+ ,
+
+ Protocol
+ ,
+
+ Accounting approach
+ ,
+ ],
+ [
+ 'Isometric',
+
+ Enhanced Rock Weathering in Agriculture (
+
+ v1.0
+
+ )
+ ,
+ 'Conservative',
+ ],
+ [
+ 'Puro',
+
+ Enhanced Rock Weathering Methodology (2022 edition,{' '}
+
+ v.1
+
+ ;{' '}
+
+ v.2
+
+ )
+ ,
+ 'Unclear; no method specified for weighing counterfactual against project',
+ ],
+ [
+ 'Carbon Standards International',
+
+ Enhanced Rock Weathering in Croplands (
+
+ v0.9
+
+ )
+ ,
+ 'No counterfactual consideration',
+ ],
+ ]}
+ />
+
+ Accounting approaches used for three enhanced rock weathering protocols.
+ Only one, Isometric, provides clear guidance for treating the counterfactual
+ removal scenario.
+
+
+
+Although we’ve focused on the example of liming optimization in enhanced rock weathering, other optimization projects will face similar dynamics. As protocols for optimization projects are developed and refined, we encourage registries to write clear and precise rules for counterfactual accounting — formalized in text and equations — that demonstrably separate avoided emissions from removals.
+
+These changes would clarify the rules and ensure a removal credited means a removal truly made, but this still does not result in a system that strongly supports CDR optimization projects. The strict and complicated rules necessary to separate avoided emissions from removals can end up excluding projects that, in reality, are good for the climate.
+
+We could support optimization projects by treating their avoided emissions as a co-benefit so the removal can be credited at a premium. But that doesn’t solve the whole problem. If a project can’t achieve net removal under the conservative approach (Approach 4), for example, the extra financing won’t make a difference. A better funding mechanism for projects like these might be one that doesn’t require such precision around the quantity and type of climate outcomes. Moving forward, we’re excited to think more about regulatory and sector-specific incentives that intersect with CDR activities, and the ways they could push CDR efforts toward the best overall climate outcomes.
+
+
+
+Tyler wrote the first draft of the article. Tyler and Freya derived the accounting equations. Freya helped write and edit the article. Shane designed the figures with input from Tyler, Kata, and Freya, and Shane built the figures and the interactive tool in the supplemental methods.
+
+Please cite as:
+
+T Kukla et al. (2024) “Crediting challenges when carbon removal comes with avoided emissions.” CarbonPlan [https://carbonplan.org/research/cdr-counterfactual-accounting](https://carbonplan.org/research/cdr-counterfactual-accounting)
+
+
+
+
+
+CarbonPlan’s work on this explainer was supported by [grants](https://carbonplan.org/funding) from Adam and Abigail Winkel and the Grantham Foundation. The authors are solely responsible for the content of this article, which does not reflect the views of any other individuals or organizations.
+
+The article text and figures are made available under a [CC BY 4.0 International license](https://creativecommons.org/licenses/by/4.0/).
+
+
diff --git a/articles/cdr-counterfactual-accounting/methods.md b/articles/cdr-counterfactual-accounting/methods.md
new file mode 100644
index 00000000..b8103150
--- /dev/null
+++ b/articles/cdr-counterfactual-accounting/methods.md
@@ -0,0 +1,131 @@
+---
+date: 11-13-2024
+title: Crediting challenges when carbon removal comes with avoided emissions
+card: cdr-counterfactual-accounting
+quickLook: Some carbon removal projects also result in avoided emissions. This is good for the climate, but can pose challenges for individual projects that are trying to earn carbon removal credits.
+back: /research/cdr-counterfactual-accounting
+components:
+ - name: NetCDR
+ src: ./components/net-cdr.js
+ - name: Figure
+ src: '@carbonplan/components'
+ - name: FigureCaption
+ src: '@carbonplan/components'
+---
+
+# Supplemental Methods
+
+## Interactive calculator
+
+The calculator below lets you explore how different accounting rules converge or diverge when crediting CDR optimization projects. You can compare the crediting outcomes for preset scenarios provided in the drop-down menu, or use the sliders to construct your own ERW project and prior liming scenarios. The default preset scenario (“More rock, more efficiently”) is the example used in the [main article text](https://carbonplan.org/research/cdr-counterfactual-accounting).
+
+
+
+
+
+ Interactive calculator for the four accounting approaches presented in the
+ main text. The green bars show the net carbon removal that each accounting
+ approach gives the project credit for. The hatched portion of the green bars
+ represents credited removals owed to avoiding counterfactual emissions. Select
+ a preset scenario from the dropdown menu, or use the sliders to vary the
+ amount of rock applied and the carbon emissions per ton of rock. For
+ simplicity, calculations assume that one ton of rock corresponds with one ton
+ of removal.
+
+
+
+
+In some cases, different counterfactual accounting rules don’t have a big effect on crediting outcomes. See, for example, the “More rock, less efficiently” preset scenario. In this case, Approaches 1, 2, and 3 converge to the same result. This is because the part of the project that replaces the counterfactual has the same or more emissions than the counterfactual. These three accounting approaches differ in how they treat avoided emissions, but this scenario doesn’t result in any avoided emissions.
+
+On the other end of the spectrum, we can consider a case where a project only avoids emissions. See, for example, the “Same rock, more efficiently” preset scenario. Here, the CDR project only uses enough rock to replace the counterfactual and, as a result, the removal flux does not change. Yet, the project rock is less emissions-intensive than the counterfactual rock. By swapping for the climate-friendly alternative, the optimization project has turned a net-emitting process into a net-removing one. Even so, it only receives CDR credits under Approach 1. No other accounting rules give the project credit for CDR since the project’s benefit relies entirely on avoiding counterfactual emissions.
+
+The final preset scenario, “More rock, same overall emissions,” illustrates a case where the project removes more carbon per unit of emissions, but total emissions don’t change from the counterfactual to the project. Here, Approaches 1 and 2 yield the same result because what distinguishes them is how they handle an overall reduction in emissions from the counterfactual to the project, which is not relevant.
+
+In all scenarios, Approaches 3 and 4 are the only ones that reliably separate avoided emissions from removal credits, resulting in zero contribution of avoided emissions to CDR.
+
+## Accounting equations
+
+The simplest formulation for net carbon dioxide removal (CDR_net) can be written as:
+
+> CDRnet = S – E.
+
+Here, _S_ is the carbon that gets removed from the atmosphere and durably stored and _E_ is the carbon that the project emits in order to operate. We assume that any reversal or leakage of removed carbon is accounted for in the _S_ term. In our simplified enhanced rock weathering example, _S_ captures all the processes that lead to carbon removal after the rock is applied to the field. _E_ captures all the emissions associated with sourcing, grinding, and applying the rock.
+
+### Approach 1: Simple subtraction
+
+This approach simply treats _S_ and _E_ as the difference between the project (_proj_) and counterfactual (_counterfac_), such that:
+
+> S = removalsproj – removalscounterfac
+
+and
+
+> S = emissionsproj – emissionscounterfac.
+
+The full equation for calculating net CDR by Approach 1 can then be written as:
+
+> CDRnet = (removalsproj – removalscounterfac) – (emissionsproj – emissionscounterfac).
+
+There is broad agreement that if downstream processes are net emitting, projects should not get credit for avoiding those emissions. This means that, for remaining accounting approaches 2-4, _S_ becomes:
+
+> S = removalsproj – MAX(0, removalscounterfac).
+
+### Approach 2: Ignore obvious avoided emissions
+
+The second approach ensures that the _E_ term, here capturing the upstream processes, is never negative:
+
+> E = MAX(0, emissionsproj – emissionscounterfac).
+
+This makes the full net CDR equation:
+
+> CDRnet = (removalsproj – removalscounterfac) – MAX(0, emissionsproj – emissionscounterfac).
+
+### Approach 3: Separate the replacement portion of the project
+
+The third approach separates the project emissions into those that are used to replace the counterfactual activity (_proj, replacement_) and those that are used to support anything extra added on top of the counterfactual (_proj, additional_), such that
+
+> emissionsproj = emissionsproj, replacement + emissionsproj, extra.
+
+We can then calculate _E_ by ensuring that only the replacement gets compared to the counterfactual and the avoided counterfactual emissions don’t count towards CDR:
+
+> E = emissionsproj, extra + MAX(0, emissionsproj, replacement – emissionscounterfac).
+
+And the full net CDR equation becomes
+
+> CDRnet = (removalsproj – removalscounterfac) – (emissionsproj, extra + MAX(0, emissionsproj, replacement – emissionscounterfac)).
+
+### Approach 4: Conservative
+
+The conservative approach, unlike the others, does not allow any possible reduction to the project emissions, regardless of how emissions-intensive the counterfactual might be. This gives us, simply
+
+> E = emissionsproj.
+
+And the full net CDR equation is:
+
+> CDRnet = (removalsproj – removalscounterfac) – emissionsproj.
diff --git a/articles/cdr-counterfactual-accounting/references.json b/articles/cdr-counterfactual-accounting/references.json
new file mode 100644
index 00000000..8f9312d5
--- /dev/null
+++ b/articles/cdr-counterfactual-accounting/references.json
@@ -0,0 +1,50 @@
+{
+ "cullenward.2023": {
+ "authors": "D Cullenward et al.",
+ "year": 2023,
+ "title": "Carbon offsets are incompatible with the Paris Agreement",
+ "journal": "One Earth",
+ "editors": "",
+ "url": "https://doi.org/10.1016/j.oneear.2023.08.014"
+ },
+ "haya.2024": {
+ "authors": "B K Haya et al.",
+ "year": 2024,
+ "title": "Voluntary Registry Offsets Database v2024-08-31",
+ "journal": "",
+ "editors": "",
+ "url": "https://gspp.berkeley.edu/research-and-impact/centers/cepp/projects/berkeley-carbon-trading-project/offsets-database"
+ },
+ "beerling.2018": {
+ "authors": "D J Beerling et al.",
+ "year": 2018,
+ "title": "Farming with crops and rocks to address global climate, food and soil security",
+ "journal": "Nature Plants",
+ "editors": "",
+ "url": "https://doi.org/10.1038/s41477-018-0108-y"
+ },
+ "davis.2024": {
+ "authors": "A L Davis",
+ "year": 2024,
+ "title": "How powdered rock could help slow climate change",
+ "journal": "",
+ "editors": "",
+ "url": "https://www.sciencenews.org/article/powdered-rock-help-slow-climate-change"
+ },
+ "dietzen.2018": {
+ "authors": "C Dietzen et al.",
+ "year": 2018,
+ "title": "Effectiveness of enhanced mineral weathering as a carbon sequestration tool and alternative to agricultural lime: An incubation experiment",
+ "journal": "International Journal of Greenhouse Gas Control",
+ "editors": "",
+ "url": "https://doi.org/10.1016/j.ijggc.2018.05.007"
+ },
+ "nordahl.2024": {
+ "authors": "S L Nordahl et al.",
+ "year": 2024,
+ "title": "Carbon accounting for carbon dioxide removal",
+ "journal": "One Earth",
+ "editors": "",
+ "url": "https://doi.org/10.1016/j.oneear.2024.08.012"
+ }
+}
diff --git a/articles/oae-efficiency-explainer/components/regional-comparison.js b/articles/oae-efficiency-explainer/components/regional-comparison.js
index f2a6f80a..ba1c61fb 100644
--- a/articles/oae-efficiency-explainer/components/regional-comparison.js
+++ b/articles/oae-efficiency-explainer/components/regional-comparison.js
@@ -272,7 +272,7 @@ const RegionalComparison = () => {
return (
-
+ {/*
Region
@@ -294,41 +294,39 @@ const RegionalComparison = () => {
'calc(-1.5 * (100vw - 36px * 13 ) / 12 - 36px)', // 1.5 columns + gutter
],
}}
- >
-
-
-
-
+ > */}
+
+
+
+
-
-
-
-
+
+
+
+ {/* {
-
+ */}
)
diff --git a/articles/oae-efficiency-explainer/index.md b/articles/oae-efficiency-explainer/index.md
index 704222f0..59b9cc09 100644
--- a/articles/oae-efficiency-explainer/index.md
+++ b/articles/oae-efficiency-explainer/index.md
@@ -50,7 +50,27 @@ links:
---
-The ocean plays an essential role in the global carbon cycle. It stores about 38,000 billion metric tons of carbon, making it the largest active reservoir of carbon on the planet. It also soaks up about one quarter of the CO₂ emitted annually by humans. Scientists and engineers are currently exploring how to amplify the ocean’s natural ability to absorb and store carbon. One promising approach is called ocean alkalinity enhancement (OAE). OAE mimics natural geochemical processes that shift ocean chemistry to remove CO₂ from the atmosphere. This could be a highly scalable approach to carbon dioxide removal (CDR), but making it work requires a rigorous understanding of ocean processes and how they vary over time and space.
+
+
+
+
+ Regional OAE efficiency data for example polygons in the North Atlantic. The
+ map shows the polygon locations of alkalinity release. Click on a polygon
+ and use the elapsed time slider to see how alkalinity injection leads to
+ additional CO₂ uptake over space and time. The bottom right panel shows the
+ OAE efficiency curves — moles of carbon uptake per mole of alkalinity added
+ — over the 15-year model integrations.
+
+
+The ocean plays an essential role in the global carbon cycle. It stores about 38,000
+billion metric tons of carbon, making it the largest active reservoir of carbon on
+the planet. It also soaks up about one quarter of the CO₂ emitted annually by humans.
+Scientists and engineers are currently exploring how to amplify the ocean’s natural
+ability to absorb and store carbon. One promising approach is called ocean alkalinity
+enhancement (OAE). OAE mimics natural geochemical processes that shift ocean chemistry
+to remove CO₂ from the atmosphere. This could be a highly scalable approach to carbon
+dioxide removal (CDR), but making it work requires a rigorous understanding of ocean
+processes and how they vary over time and space.
OAE relies on adding alkaline materials, like crushed rocks or hydroxides, to the surface ocean — but this action alone does not guarantee carbon removal.Strictly speaking, electrochemical OAE methods actually remove acid from the surface ocean, but this is functionally equivalent to adding a base such as hydroxide. Instead, these materials shift the chemistry of the water, making it able to absorb and store more CO₂. Although this initial chemical shift happens quickly, it takes time for the ocean to absorb CO₂ from the atmosphere. Since the ocean is always in motion, carbon removal can happen far from where alkalinity is added. Furthermore, if ocean circulation moves the alkalinity-treated water away from the surface and out of contact with the atmosphere, the process of absorbing atmospheric CO₂ can be cut short. Natural variations in these physical circulation dynamics mean that alkalinity deployed in different locations or at different times of the year can result in different amounts of carbon removal. Understanding these dynamics is critical for deciding where and when it makes sense to pursue OAE, and estimating how much carbon actually gets removed from the atmosphere.
diff --git a/components/mdx/page-components.js b/components/mdx/page-components.js
index 7ee8bd2f..9479095a 100644
--- a/components/mdx/page-components.js
+++ b/components/mdx/page-components.js
@@ -3,6 +3,13 @@ import dynamic from 'next/dynamic'
// NOTE: This is a dynamically generated file based on the config specified under the
// `components` key in each article's frontmatter.
const components = {
+ 'cdr-counterfactual-accounting': {
+ AccountingGraph: dynamic(() =>
+ import(
+ '../../articles/cdr-counterfactual-accounting/components/accounting-graph.js'
+ ).then((mod) => mod.AccountingGraph || mod.default)
+ ),
+ },
'ab1305-initial-disclosures': {
SummaryTable: dynamic(() =>
import(
@@ -669,6 +676,21 @@ const components = {
).then((mod) => mod.DatabaseTable || mod.default)
),
},
+ 'cdr-counterfactual-accounting-methods': {
+ NetCDR: dynamic(() =>
+ import(
+ '../../articles/cdr-counterfactual-accounting/components/net-cdr.js'
+ ).then((mod) => mod.NetCDR || mod.default)
+ ),
+ Figure: dynamic(() =>
+ import('@carbonplan/components').then((mod) => mod.Figure || mod.default)
+ ),
+ FigureCaption: dynamic(() =>
+ import('@carbonplan/components').then(
+ (mod) => mod.FigureCaption || mod.default
+ )
+ ),
+ },
'forest-offsets-explainer-faq': {
CommonPractice: dynamic(() =>
import(