---
format: typebulb/v1
name: Reversible Computing FAQ
---

**code.tsx**

```tsx
import React, { useMemo, useState } from "react"
import { createRoot } from "react-dom/client"

type Item = { cat: string; q: string; myth?: string; a: string[] }

const items = tb.json<Item[]>(0)
const cats = items.map(i => i.cat).filter((c, i, a) => a.indexOf(c) === i)

function rich(text: string, key: number) {
  const parts = text.split(/(`[^`]+`|\*[^*]+\*)/g)
  return (
    <p key={key}>
      {parts.map((p, i) =>
        p.startsWith("`") ? <code key={i}>{p.slice(1, -1)}</code>
        : p.startsWith("*") ? <em key={i}>{p.slice(1, -1)}</em>
        : p
      )}
    </p>
  )
}

function Chip(p: { label: string; n: number; on: boolean; flag?: boolean; onPick: () => void }) {
  const cls = "chip" + (p.flag ? " flag" : "") + (p.on ? " on" : "") + (p.n === 0 ? " zero" : "")
  return (
    <button className={cls} onClick={p.onPick}>
      {p.label}<span className="n">{p.n}</span>
    </button>
  )
}

function App() {
  const [query, setQuery] = useState("")
  const [cat, setCat] = useState<string | null>(null)
  const [open, setOpen] = useState<number[]>([])

  const matched = useMemo(() => {
    const needle = query.trim().toLowerCase()
    return items
      .map((it, i) => ({ it, i }))
      .filter(({ it }) =>
        !needle || (it.q + " " + (it.myth ?? "") + " " + it.a.join(" ")).toLowerCase().includes(needle))
  }, [query])

  const shown = useMemo(
    () => matched.filter(({ it }) => cat === null || (cat === "myth" ? !!it.myth : it.cat === cat)),
    [matched, cat])

  function tally(key: string | null) {
    if (key === null) return matched.length
    if (key === "myth") return matched.filter(m => m.it.myth).length
    return matched.filter(m => m.it.cat === key).length
  }

  const allOpen = shown.length > 0 && shown.every(s => open.includes(s.i))

  function toggle(i: number) {
    setOpen(prev => prev.includes(i) ? prev.filter(n => n !== i) : prev.concat(i))
  }

  return (
    <div className="wrap">
      <h1><span className="spin">Reversible</span> Computing FAQ</h1>
      <p className="lede">
        What reversible computing actually claims, and the widespread misconceptions that make it
        sound further off than it is: built from{" "}
        <a href="https://x.com/MikePFrank/status/2087931043747607031" target="_blank" rel="noopener noreferrer">
          corrections by Michael P. Frank
        </a>{" "}
        of Vaire Computing to a stock Opus 5 answer that got most of this wrong.
      </p>

      <div className="tools">
        <input
          className="search"
          placeholder="Search questions and answers"
          aria-label="Search"
          value={query}
          onChange={e => setQuery(e.target.value)}
        />
        <div className="chips">
          <Chip label="All" n={tally(null)} on={cat === null} onPick={() => setCat(null)} />
          {cats.map(c => (
            <Chip key={c} label={c} n={tally(c)} on={cat === c} onPick={() => setCat(c)} />
          ))}
          <Chip label="Misconceptions" n={tally("myth")} on={cat === "myth"} flag onPick={() => setCat("myth")} />
        </div>
      </div>

      <div className="count">
        <span>{shown.length} of {items.length} questions</span>
        <button className="link" onClick={() => setOpen(allOpen ? [] : shown.map(s => s.i))}>
          {allOpen ? "Collapse all" : "Expand all"}
        </button>
      </div>

      {cats.map(c => {
        const group = shown.filter(s => s.it.cat === c)
        if (group.length === 0) return null
        return (
          <section key={c}>
            <h2>{c}</h2>
            {group.map(({ it, i }) => (
              <div className="qa" key={i}>
                <button className="q" aria-expanded={open.includes(i)} onClick={() => toggle(i)}>
                  <span className="mark">{open.includes(i) ? "\u25be" : "\u25b8"}</span>
                  <span className="txt">{it.q}</span>
                  {it.myth ? <span className="badge">myth</span> : null}
                </button>
                {open.includes(i) ? (
                  <div className="a">
                    {it.myth ? (
                      <div className="myth">
                        <span className="lbl">Widely believed</span>
                        <p>{it.myth}</p>
                      </div>
                    ) : null}
                    {it.a.map((para, n) => rich(para, n))}
                  </div>
                ) : null}
              </div>
            ))}
          </section>
        )
      })}

      {shown.length === 0 ? <p className="empty">Nothing matches that.</p> : null}

      <footer className="foot">
        <span className="lbl">About this document</span>
        <p>
          Written by Claude Opus 5, revising its own earlier answer on reversible computing after
          public corrections from Michael P. Frank of Vaire Computing. The technical positions here
          follow those corrections; the questions, wording and structure are Opus 5's.
        </p>
        <p>
          The dates under Outlook are Opus 5's revised estimate, not Frank's. He gave no timeline
          and has not reviewed this document.
        </p>
      </footer>
    </div>
  )
}

createRoot(document.getElementById("root")!).render(<App />)

```
**styles.css**

```css
:root { --accent: #0d7a6f; --flag: #b45309; }
html[data-theme="dark"] { --accent: #34d3bd; --flag: #f0a83c; }

/* Reserve the scrollbar channel always, so filtering to a short list doesn't reflow the page. */
html { scrollbar-gutter: stable both-edges; }

.wrap {
  max-width: 820px;
  margin: 0 auto;
  padding: 28px 18px 44px;
  font: 15px/1.62 system-ui, -apple-system, "Segoe UI", sans-serif;
}
h1 { font-size: 26px; line-height: 1.2; margin: 0 0 10px; letter-spacing: -0.01em; perspective: 700px; }
.spin {
  display: inline-block; transform-style: preserve-3d; will-change: transform;
  animation: axes 12s ease-in-out infinite alternate;
}
@keyframes axes {
  0%, 5%    { transform: rotateX(0turn) rotateY(0turn) rotateZ(0turn); }
  27%, 38%  { transform: rotateX(1turn) rotateY(0turn) rotateZ(0turn); }
  60%, 71%  { transform: rotateX(1turn) rotateY(1turn) rotateZ(0turn); }
  93%, 100% { transform: rotateX(1turn) rotateY(1turn) rotateZ(1turn); }
}
@media (prefers-reduced-motion: reduce) { .spin { animation: none; } }
.lede { margin: 0 0 22px; opacity: .85; }
.lede a {
  color: var(--accent); text-decoration: underline;
  text-underline-offset: 2px; text-decoration-thickness: 1px;
}

.tools { display: grid; gap: 12px; margin-bottom: 16px; }
.search {
  font: inherit; width: 100%; box-sizing: border-box; padding: 9px 12px;
  border-radius: 8px; color: inherit;
  border: 1px solid color-mix(in srgb, currentColor 25%, transparent);
  background: color-mix(in srgb, currentColor 4%, transparent);
}
.search::placeholder { color: inherit; opacity: .5; }
.chips { display: flex; flex-wrap: wrap; gap: 7px; }
.chip {
  font: inherit; font-size: 14px; padding: 5px 12px; border-radius: 999px;
  cursor: pointer; color: inherit; background: transparent; opacity: .7;
  border: 1px solid color-mix(in srgb, currentColor 22%, transparent);
}
.chip:hover { opacity: 1; }
.chip.on {
  opacity: 1; color: var(--accent); border-color: var(--accent);
  background: color-mix(in srgb, var(--accent) 12%, transparent);
}
.chip.flag.on {
  color: var(--flag); border-color: var(--flag);
  background: color-mix(in srgb, var(--flag) 14%, transparent);
}
.chip .n { margin-left: 6px; opacity: .55; font-variant-numeric: tabular-nums; }
.chip.zero { opacity: .32; }

.count {
  display: flex; justify-content: space-between; align-items: baseline; gap: 12px;
  font-size: 14px; opacity: .65;
}
.link { font: inherit; font-size: 14px; border: 0; padding: 0; background: none; color: var(--accent); cursor: pointer; }

h2 {
  font-size: 13px; font-weight: 600; text-transform: uppercase; letter-spacing: .08em;
  opacity: .55; margin: 26px 0 6px;
}
.qa { border-top: 1px solid color-mix(in srgb, currentColor 14%, transparent); }
.qa:last-child { border-bottom: 1px solid color-mix(in srgb, currentColor 14%, transparent); }
.q {
  font: inherit; font-size: 16px; width: 100%; text-align: left; color: inherit;
  background: none; border: 0; padding: 13px 4px; cursor: pointer;
  display: flex; gap: 10px; align-items: center;
}
.q:hover { color: var(--accent); }
.q .mark { flex: none; width: 26px; font-size: 24px; line-height: 1; opacity: .5; }
.q .txt { flex: 1; }
.badge {
  flex: none; align-self: center; font-size: 12.5px; letter-spacing: .04em;
  text-transform: uppercase; color: var(--flag); border-radius: 4px; padding: 1px 6px;
  border: 1px solid color-mix(in srgb, var(--flag) 45%, transparent);
}

.a { padding: 0 4px 18px 40px; }
.a p { margin: 0 0 12px; }
.a p:last-child { margin-bottom: 0; }
.myth { border-left: 3px solid var(--flag); padding: 2px 0 2px 13px; margin: 0 0 14px; }
.myth .lbl {
  display: block; margin-bottom: 3px; font-size: 13px; letter-spacing: .06em;
  text-transform: uppercase; color: var(--flag);
}
.myth p { margin: 0; font-style: italic; opacity: .82; }

code {
  font: 13.5px/1.5 ui-monospace, SFMono-Regular, Menlo, monospace;
  background: color-mix(in srgb, currentColor 9%, transparent);
  padding: 1px 5px; border-radius: 4px;
}
.empty { padding: 22px 4px; opacity: .6; }
.foot {
  margin-top: 34px; padding-top: 14px; font-size: 14px; opacity: .62;
}
.foot .lbl {
  display: block; margin-bottom: 6px; font-size: 13px; font-weight: 600;
  letter-spacing: .08em; text-transform: uppercase; opacity: .8;
}
.foot p { margin: 0 0 8px; }
.foot p:last-child { margin-bottom: 0; }
```
**index.html**

```html
<div id="root"></div>
```
**data.txt**

```txt
[
  {
    "cat": "Basics",
    "q": "What is reversible computing?",
    "a": [
      "Computing arranged so that information is not destroyed. In a logically reversible operation every output state maps back to exactly one input state, so no bit is ever overwritten or thrown away.",
      "That matters physically because destroying information is the step thermodynamics charges you for. If nothing is destroyed, the energy used to represent a signal can in principle be recovered and reused instead of dumped as heat. In CMOS this takes the form of *adiabatic* switching: node charge is moved gradually by a resonant power-clock and returned to it, rather than shorted to ground."
    ]
  },
  {
    "cat": "Basics",
    "q": "What is the Landauer limit?",
    "a": [
      "Erasing one bit of information at temperature T must dissipate at least `kT ln 2`, about 3 zeptojoules at room temperature. It is a floor on *erasure*, not on computation.",
      "Operations that erase nothing have no such floor. Their cost falls the more gradually you carry them out, which is the whole lever reversible computing pulls."
    ]
  },
  {
    "cat": "Basics",
    "q": "Is this quantum computing?",
    "a": [
      "No. Quantum computation happens to be reversible, since unitary evolution is, but that is incidental. Classical reversible computing is ordinary Boolean logic on ordinary silicon, run so that switching energy is recycled rather than dissipated. No qubits, no coherence requirement, no quantum error correction."
    ]
  },
  {
    "cat": "Basics",
    "q": "Is this the same as reversible neural networks (RevNets, normalizing flows)?",
    "a": [
      "No, and the name collision causes real confusion. RevNet-style architectures recompute activations on the backward pass so they need not be stored: a memory-footprint technique, written in software, running on entirely conventional hardware.",
      "Reversible computing is about the physics of the switching devices underneath. You can have either one without the other."
    ]
  },

  {
    "cat": "The energy case",
    "q": "Do you have to reach the Landauer limit before reversible computing pays off?",
    "myth": "Conventional logic runs many orders of magnitude above kT ln 2, so there is enormous headroom left in ordinary CMOS and no reason to reach for reversibility yet.",
    "a": [
      "This mistakes which number reversible logic has to beat. Irreversible logic can never approach `kT ln 2`, because Landauer is not what constrains it: noise margins, threshold voltages, supply headroom, leakage and interconnect capacitance all impose their own costs long before thermodynamics does.",
      "In practice conventional logic bottoms out in the *thousands* of `kT` per operation. That is the target, and it is far nearer than the Landauer limit. Reversible logic does not need to get anywhere close to `kT` to win. It needs to get below a few thousand."
    ]
  },
  {
    "cat": "The energy case",
    "q": "Is adiabatic charge recovery enough on its own, without logical reversibility?",
    "myth": "Charge recovery and logical reversibility are separable prizes, and the near-term commercial bet is charge recovery alone, with full reversibility a more distant goal.",
    "a": [
      "They do not separate. A circuit that recovers charge on some transitions but still destroys node state elsewhere is only *quasi*-adiabatic: recovery is capped by wherever the erasure happens, and what comes back is often not enough to pay for the overheads the adiabatic style brings with it.",
      "The win appears when the architecture is mostly logically reversible, so the recovery path actually runs all the way back. That is why the practical agenda is adiabatic *reversible* CMOS, one thing rather than two."
    ]
  },
  {
    "cat": "The energy case",
    "q": "Where does the energy actually go in a conventional gate?",
    "a": [
      "Mostly into charging node capacitance up to the supply voltage and then shorting it to ground, dissipating roughly `CV²` per full cycle as heat, plus leakage and the cost of driving interconnect.",
      "Adiabatic switching attacks that term directly by returning the charge to the power-clock instead of grounding it. How much comes back depends on how gradually the transition is made relative to the circuit's RC time constant, which is why speed and energy trade against each other here."
    ]
  },

  {
    "cat": "Speed and area",
    "q": "Doesn't adiabatic operation force you to run much slower?",
    "myth": "Adiabatic savings scale with how far you slow down, so holding throughput needs proportionally more silicon. You have converted an energy problem into an area problem, and area is not free.",
    "a": [
      "The energy-versus-speed tradeoff is real. The mistake is assuming a modern chip's throughput is set by device speed. It is not. It is set by package-level power dissipation, which is precisely why *dark silicon* exists: you already cannot switch all the transistors you have.",
      "That inverts the accounting. Area is the resource sitting idle; power is the one you have run out of. Filling underused area with slower, cooler logic spends something abundant on something scarce, and the slowdown needed for a large energy advantage is modest rather than order-of-magnitude."
    ]
  },
  {
    "cat": "Speed and area",
    "q": "What is dark silicon?",
    "a": [
      "After Dennard scaling ended, transistor density kept improving while per-transistor switching power stopped falling in step. The consequence is that only a fraction of a chip's transistors can be active at once inside its power and thermal budget. The idle remainder is dark silicon: transistors you own and cannot afford to switch.",
      "It sets the exchange rate that makes reversible logic attractive, because it prices area low and joules high."
    ]
  },

  {
    "cat": "Engineering",
    "q": "What about multi-phase power-clock generation and on-chip resonator losses?",
    "a": [
      "Genuine engineering problems, and historically the reason adiabatic CMOS stalled: the overhead of generating and distributing resonant clocks, together with finite inductor quality, ate into the gains.",
      "The position from the people currently building it is that these losses reduce the achievable benefit without preventing a substantial net win. They are a design cost to be engineered down, not a wall."
    ]
  },
  {
    "cat": "Engineering",
    "q": "Doesn't the entire EDA ecosystem assume static CMOS?",
    "myth": "There are no standard cells, no timing signoff flow, no scan or ATPG and no verification methodology for adiabatic logic, so bootstrapping it means a decade of investment with no interim market.",
    "a": [
      "The observation is correct as far as it goes. Cell libraries, signoff, test and verification all assume static levels and a DC supply, and all of them do have to change.",
      "The conclusion does not follow. This is a substantial but tractable engineering programme, and it is the work being done now rather than an unaddressed prerequisite sitting in the way."
    ]
  },
  {
    "cat": "Engineering",
    "q": "Does this need reversible memory and new memory compilers first?",
    "myth": "SRAM and interconnect dominate the energy and reversible memory barely exists, so savings are capped by Amdahl's law on the logic fraction.",
    "a": [
      "Reversibility is being applied at the level of functional datapaths, well below anything that touches a memory array. Memory compilers are not on the critical path for that work.",
      "The datapath is where the switching activity being targeted actually lives, so the memory question is a different project rather than a blocking dependency."
    ]
  },

  {
    "cat": "Algorithms",
    "q": "If you cannot erase, what happens to the intermediate results?",
    "a": [
      "They accumulate as garbage, and dealing with them is the classic objection. It has a classic answer: compute forward, use the result, then run the computation backward to un-compute the intermediates, recovering their energy on the way out.",
      "Retractile cascades implement exactly this in hardware, with negligible hardware overhead and roughly a factor of two in switching events. Not free, but nothing like the space-time blowup the objection usually implies."
    ]
  },
  {
    "cat": "Algorithms",
    "q": "Neural networks are full of irreversible operations. Isn't that fatal?",
    "myth": "Softmax, normalization, quantization and stochastic operations like dropout and sampling are irreversible by construction, so a large share of a neural network cannot be made reversible.",
    "a": [
      "Those operations exist, but they are largely irrelevant to the energy question. The great majority of the energy dissipated by these workloads can be eliminated without considering them at all.",
      "You leave the irreversible steps irreversible and still capture most of the win. The objection targets a small slice of the switching activity."
    ]
  },

  {
    "cat": "AI workloads",
    "q": "Isn't AI compute dominated by data movement, where a better datapath doesn't help?",
    "myth": "Neural network energy is dominated by moving weights and activations through the memory hierarchy, so even a perfect arithmetic unit hits an Amdahl ceiling.",
    "a": [
      "Not uniformly. LLM inference has two phases with very different characters. Prefill computes key and value entries for every input token and stays heavily compute-dominated, with high arithmetic intensity per byte fetched. That is exactly the regime where a datapath energy win lands on the dominant cost.",
      "Etched is chasing the same compute-bound regime by a different route, gaining its efficiency through voltage scaling. Decode is the more bandwidth-bound phase. Treating the whole workload as memory-bound conflates the two."
    ]
  },
  {
    "cat": "AI workloads",
    "q": "Why target AI at all?",
    "a": [
      "Because it is the workload where energy has become the binding constraint at scale, and because the compute is regular, dense and datapath-heavy, which is the easiest shape to build reversibly."
    ]
  },

  {
    "cat": "Approaches",
    "q": "What about superconducting reversible logic?",
    "a": [
      "Adiabatic quantum-flux-parametron logic and related superconducting families reach extremely low switching energies, but the cryogenic cooling multiplier is severe and room-temperature I/O is a hard bottleneck.",
      "That is one of several reasons superconducting approaches are not recommended as practical for most applications at present; they remain rather far from practicality. Semiconductor-based adiabatic reversible CMOS is the route being pursued commercially."
    ]
  },
  {
    "cat": "Approaches",
    "q": "Who is working on this?",
    "a": [
      "The research line is long: Landauer on the cost of erasure, Bennett on uncomputation, Fredkin and Toffoli on reversible gates, Hall on retractile cascades, and decades of academic adiabatic CMOS and superconducting work since.",
      "The main commercial effort on adiabatic reversible CMOS is Vaire Computing, where Michael P. Frank, whose corrections this FAQ is built from, works."
    ]
  },

  {
    "cat": "Outlook",
    "q": "When does reversible computing carry the majority of neural network compute?",
    "a": [
      "This FAQ began with a forecast of a median around 2050 and a substantial chance of never. Every reason offered for that lateness turns out to be weaker than assumed: the number to beat is thousands of `kT` rather than one, dark silicon makes the speed-for-area trade cheap instead of costly, the power-clock and toolchain problems are costs rather than walls, and the workload-specific objections mostly do not apply.",
      "Revised for that: a median nearer 2040 for majority share, with commercial parts materially earlier, and much less probability mass on never. What still argues for patience is not physics but logistics, since this is a full ecosystem change competing against incumbents that ship every year.",
      "These numbers are mine, restated after the corrections. Frank offered no date."
    ]
  },
  {
    "cat": "Outlook",
    "q": "What would move the estimate again?",
    "a": [
      "Published net energy wins on a real workload with power-clock overhead counted in rather than excluded. A shipping part. And the first reversible datapath dropped inside an otherwise conventional accelerator, which is how a substrate change usually starts in practice."
    ]
  }
]
```
**config.json**

```json
{
  "description": "What reversible computing claims, and the seven widespread misconceptions that make it sound further off than it is.",
  "dependencies": {
    "react": "^19.2.7",
    "react-dom": "^19.2.7"
  }
}
```