Progressive Disclosure¶
Core Idea¶
Progressive disclosure is the structural move of revealing information or options in stages, calibrated to the receiver's current need-to-know, rather than presenting the full space at once. Each stage is complete enough to act on; deeper layers exist but are hidden behind a recognizable affordance that lets the receiver descend on demand. The pattern is a layered surface whose visible layer is always the minimum sufficient for the present task, paired with a clear path to the next layer. The two load-bearing parts are the layering — a sequence of self-contained surfaces, each adequate for a coherent unit of decision — and the affordance — a visible signal that more exists and roughly what kind, so the receiver can choose to go deeper without being forced to.
The essential commitment is the distinction between information available and information presented, two things that everyday talk of "transparency" and "completeness" tends to collapse. A system can be fully transparent — everything is disclosable — while being progressively disclosed, so that only what is needed is shown at each stage. The move is therefore not about hiding information in the sense of withholding it, but about sequencing its presentation against need. This is what separates progressive disclosure from mere omission: omission hides without an affordance, leaving the receiver unaware that anything is missing, whereas progressive disclosure hides with a visible path down, so the receiver knows that more exists and how to reach it. The visible path is the structurally indispensable element, because without it the receiver does not know what they do not know, and the layering degrades into concealment. The structural skeleton has a small set of recurring parts: a layered information surface; each layer self-contained and sufficient for a coherent task; a visible affordance from each layer to the next; defaults at each layer chosen so that not descending is itself a reasonable action; complexity hidden but not removed — reachable, not invisible; and a characteristic failure mode in which the layers are arbitrary, the affordances are weak, or the hidden content is consequential.
How would you explain it like I'm…
Lift-the-Flap
A Little at a Time
Layers With a Visible Path
Structural Signature¶
a layered information surface — each layer self-contained and sufficient for a coherent task — a visible affordance from each layer to the next — defaults making non-descent a reasonable action — complexity hidden but reachable, not removed — a separation of information-available from information-presented
The pattern is present when each of the following holds:
- A layered surface. A sequence of presentation layers over a body of information or options, the visible layer always the minimum sufficient for the present task.
- Self-contained sufficiency per layer. Each layer supports a coherent unit of decision on its own; a receiver who stops at any layer can act correctly without descending.
- A visible affordance down. A recognizable signal that more exists and roughly what kind, so the receiver may descend on demand without being forced to. This is the structurally indispensable element.
- Well-chosen defaults. At each layer the defaults are what a typical receiver at that depth would choose, so that not descending is reasonable rather than a trap.
- Hidden-but-reachable complexity. Deeper content is deferred, not deleted; it remains fully present behind the layers, its attentional cost incurred only by receivers who need it.
- An availability/presentation invariant. Information available and information presented are distinct: the system can be fully transparent while progressively disclosed. The load-bearing line against omission is the visible path down — omission hides without an affordance, leaving the receiver unaware anything is missing.
These compose into layered sufficiency. The characteristic failures are arbitrary layers, weak affordances, and the dark-pattern misuse of burying consequential content behind an unobtrusive affordance.
What It Is Not¶
- Not layering as such. See
layering. Layering is the general structuring of a system into stacked levels. Progressive disclosure is the receiver-facing presentation discipline: layers calibrated to need-to-know, each sufficient to act on, with a visible affordance down. Architectural layers need none of those receiver-centric properties. - Not information hiding. See
information_hiding. Information hiding encapsulates internals so a consumer need not — and often cannot — see them. Progressive disclosure keeps deeper content visible-as-existing and reachable on demand. The defining difference is the affordance: hiding conceals the existence of the layer; disclosure advertises it. - Not scaffolding. See
scaffolding. Scaffolding is temporary support removed as competence grows. Progressive disclosure is persistent layered presentation; its deeper layers are permanent and reachable, not training wheels withdrawn over time. - Not abstraction. See
abstraction. Abstraction discards detail to form a simpler concept that stands on its own. Progressive disclosure defers detail — it remains fully present behind the surface, not abstracted away — and the discarded-versus-deferred distinction is load-bearing. - Not mere omission. Omission hides without an affordance, leaving the receiver unaware anything is missing. Progressive disclosure hides with a visible path down. Strip the affordance and it degrades into concealment — or, when consequential content is buried, into a dark pattern.
- Common misclassification. Calling any "show less, click for more" layout progressive disclosure. The catch: test by stopping. If a receiver who halts at a layer is materially worse off — the layer was a truncated fragment, not a sufficient surface — it is truncation, not progressive disclosure, however clean the expand control looks.
Broad Use¶
- Human-computer interaction. Menus that show common options first and "More…" for the rest; wizards that ask one question per screen; documentation with summary-then-details collapsibles.
- Teaching. Spiral curricula that introduce a concept in simplified form, return to it with added structure, and return again with full formal apparatus — the same idea told at successively greater depth.
- Policy and legal communication. Plain-language summaries layered on top of statutes, "key terms" boxes on top of full contracts, and citizen-facing forms that hide legal cross-references behind question flows.
- Software architecture and APIs. High-level facade calls that delegate to lower-level primitives reachable only when needed; sensible defaults overlaid on a rich configuration surface.
- Scientific writing. Abstract, then introduction, then methods, then full detail — each layer self-contained for a reader who stops there, with affordances down to the next.
- Onboarding and organizational training. New hires are exposed to procedures, then policies, then exceptions, then underlying reasoning, on a schedule matched to the situations they actually encounter.
Clarity¶
The frame's first clarifying move is to separate information available from information presented, a distinction that "transparency" and "completeness" routinely collapse. Recognizing that a system can be simultaneously fully transparent and progressively disclosed resolves an apparent tension: the demand for completeness need not mean showing everything at once, only making everything reachable. This frees a designer from the false choice between an overwhelming full surface and a dishonestly truncated one. The frame's second clarifying move is to separate omission from progressive disclosure, with the visible path down as the load-bearing difference. Omission and progressive disclosure can look identical at the surface — in both, most content is not shown — but they are structurally opposite: omission leaves the receiver ignorant that anything is missing, while progressive disclosure advertises the existence and rough kind of the deeper content, preserving the receiver's ability to descend. Naming this distinction makes a specific kind of dishonesty visible, namely the dark-pattern misuse in which consequential information — fees, terms, consequences — is hidden behind an unobtrusive affordance dressed up as ordinary progressive disclosure. The frame is intervention-neutral about what should be hidden; its clarifying contribution is to make the affordance's honesty the explicit test, so that hiding-with-a-weak-path and hiding-consequential-content can be named as failures rather than passing as good layering.
Manages Complexity¶
The cost of information is not only the cost of acquiring it but the cost of attending to the irrelevant — the working-memory burden of holding more than the present decision requires. Progressive disclosure manages this cost by sizing each layer to a coherent unit of decision and deferring the rest, so the receiver's attention is spent only on what the current task needs. The structural budget is paid in two specific places. It is paid in layering: designing a sequence of self-contained surfaces, each of which supports a coherent decision or action on its own, is real design work, and doing it badly — splitting a single topic arbitrarily across layers — produces the "click-here-for-more" that no one clicks. And it is paid in affordances: making the path down discoverable, so the receiver can tell from the surface whether more exists and roughly what kind, is the second cost, and skimping on it produces hidden tabs, missing "advanced" buttons, and unmarked exceptions that break the contract between surface and depth. When the budget is paid well, the payoff is that the receiver's working memory is freed to act on the current layer rather than being taxed by the full space, and the system can present arbitrary depth without overwhelming anyone, because depth is reachable rather than displayed. The complexity is not removed — it remains fully present behind the layers — but its attentional cost is incurred only by the receivers who actually need it, and only when they need it.
Abstract Reasoning¶
Reasoning about progressive disclosure is reasoning about layered sufficiency, and the frame supplies a stable set of questions that hold across substrates. What is the smallest amount of information sufficient for the present decision — the minimum that lets the receiver act correctly without descending further? What signals tell the receiver they need to go deeper, and are those signals present at the surface or only discoverable after a mistake? What affordance reveals the next layer without forcing it, preserving the receiver's choice to stop? And are the layers themselves coherent units, each supporting a genuine decision, or are they arbitrary cut-points that fragment a single task across surfaces? These are recognizably the same questions in interface design, curriculum design, legal drafting, and API design, which is the mark of a prime reasoning over structure rather than over a particular medium. The frame also licenses a specific audit discipline: test by stopping. One evaluates a layered surface by asking, at each layer, whether a receiver who stops there is materially worse off; if they are, the layer is truncated rather than progressive, because a genuine layer must be sufficient for the task it claims to serve. This converts the otherwise vague question of whether a design is "well-layered" into a checkable test. And it licenses reasoning about defaults as a structural component: each layer's defaults should be the choice a typical receiver at that depth would make, so that not descending is a reasonable action rather than a trap, which means default design and layer design are not separable concerns.
Knowledge Transfer¶
The pattern carries a set of concrete interventions that transfer across substrates because each acts on the layering-and-affordance structure rather than on any substrate-specific content. The first is to layer by task, not by topic: each layer should support a coherent decision or action, and splitting a topic across layers arbitrarily produces affordances no one uses — a diagnostic that applies identically to a menu, a curriculum module, a contract section, and an API surface. The second is to make the affordance honest: the receiver must be able to tell from the surface whether more exists and roughly what kind, so hidden tabs, missing "advanced" controls, and unmarked exceptions break the contract whether they occur in software, a legal document, or a training program. The third is to default well, choosing each layer's defaults so that a typical receiver at that depth is well served by not descending, which transfers from UI defaults to a curriculum's "what every student must know" core to an API's sensible-defaults overlay. The fourth is to test by stopping, auditing each layer by asking whether a receiver who halts there is materially worse off. The fifth is to watch for dark-pattern misuse, since the same structure that helpfully defers irrelevant detail can be weaponized to bury consequential information behind an unobtrusive affordance — the pattern is neutral, and its ethics depend entirely on what is hidden and why.
The role mappings that make these transfers reliable are direct. The surface layer maps to the common-options menu, the simplified first pass of a spiral curriculum, the plain-language summary, the facade call, the abstract, the new-hire procedure. The deeper layers map to the "More…" submenu, the later formal apparatus, the full statute, the lower-level primitives, the methods and derivation, the underlying policy reasoning. The affordance down maps to the expand control, the "we will return to this," the cross-reference, the documented escape hatch into the lower API, the citation. Because the structure is shared, a practitioner who has internalized progressive disclosure in one substrate recognizes it in another: a textbook chapter that runs headline to worked example to exercise to derivation, a court filing that runs caption to relief-sought to factual background to legal argument, and a database driver that runs query() to prepare() to cursor-level options are, structurally, the same move — a surface sufficient to act on, an honest affordance to the next layer, and the full apparatus reachable behind. What transfers is the discipline of asking, of any body of information or options, what the minimum sufficient surface is and how the receiver who needs more is to find it, together with the audit — test by stopping — that keeps each layer genuinely sufficient rather than merely truncated.
Examples¶
Formal/abstract¶
A spiral curriculum for teaching recursion is progressive disclosure in pedagogy, and it instantiates the signature cleanly enough to test each element. The layered surface is the sequence of passes over the single concept: a first pass introduces recursion as "a function that calls itself, like counting down to zero"; a second pass returns with the call stack and base-case reasoning; a third returns with formal induction, tail-call optimization, and the equivalence to iteration. The self-contained sufficiency per layer is the load-bearing test — a student who stops after the first pass can write and trace a simple countdown correctly, so the layer supports a coherent unit of competence on its own rather than dangling. The visible affordance down is the explicit "we will return to this with the underlying mechanism," which tells the learner that more exists and roughly of what kind, distinguishing the move from omission (silently teaching a simplified model as if it were the whole truth, leaving the student unaware anything was withheld). The well-chosen defaults are the canonical first examples — countdown, factorial — chosen because a typical learner at that depth is well served by them. The availability/presentation invariant is exact: the full formal apparatus was always available in the discipline; the curriculum controls only what is presented at each stage. The intervention the frame prescribes — test by stopping — is precisely how a curriculum designer audits the sequence: at each layer, is a student who halts there materially worse off, or genuinely able to act? A layer that fails this test is truncation masquerading as a pass, the curricular analogue of a "click-here-for-more" no one can use.
Mapped back: Each pass over recursion is a self-contained layer, "we will return to this" is the honest affordance down, the simplified first model is the well-chosen default, and the full formalism is hidden-but-reachable — layered sufficiency calibrated to the learner's current need-to-know.
Applied/industry¶
A consumer-facing software installer is the originating HCI home of the pattern, and it shows both the benign use and the dark-pattern failure the frame names. The layered surface is the install flow: a first screen offers "Express install (recommended)" with everything else folded away, and an "Advanced" affordance descends to a screen exposing install location, component selection, and integration options. The self-contained sufficiency is that a typical user who never touches "Advanced" gets a correct, working installation — the surface layer is the minimum sufficient for the present task. The visible affordance down is the labeled "Advanced" or "Customize" control, which is the structurally indispensable element: it advertises that more exists and roughly what kind, so the power user can descend on demand without the novice being forced to. The well-chosen defaults are the express settings, sized so that not descending is a reasonable action rather than a trap. The same structure governs an API facade (client.connect() as the surface call, with a richer configuration object reachable behind it) and a plain-language summary layered atop a full contract. But the frame's negative clarity is what earns its keep here: the availability/presentation distinction makes a specific dishonesty nameable. When an installer hides a consequential default — a bundled toolbar opted-in by default, an auto-renewing charge — behind an unobtrusive affordance dressed up as ordinary progressive disclosure, it has crossed from layered sufficiency into a dark pattern. The frame's audit (is the affordance honest about what it conceals, and is the hidden content consequential?) is exactly the test that separates a helpful "Advanced" button from a buried fee, and it transfers identically to a contract's fine print and a settings page's defaults.
Mapped back: The express-install screen is the surface layer sufficient to act on, "Advanced" is the honest affordance down, the recommended settings are the well-chosen defaults, and a consequential charge buried behind an innocuous toggle is the dark-pattern failure the availability/presentation distinction exposes.
Structural Tensions¶
T1 — Information Available versus Information Presented (the Defining Split). The whole move rests on prying apart what is disclosable from what is shown, but these collapse under the everyday demand for "transparency." The failure mode runs both ways: equating transparency with showing everything at once, producing an overwhelming surface, or satisfying "completeness" by making content technically available while presenting nothing, so it is unreachable in practice. The diagnostic is to ask, of each piece of deferred content, whether it is genuinely reachable from the surface — available-and-presented are distinct, and a system can be fully transparent while disclosing progressively only if every hidden layer has a real path to it.
T2 — Deferral with Affordance versus Omission (the Honest-Path Boundary). Progressive disclosure and omission look identical at the surface — both show only part — but differ structurally on one element: the visible path down. Omission leaves the receiver unaware anything is missing; disclosure advertises the existence and rough kind of deeper content. The failure mode is hiding without an affordance and calling it layering, so receivers do not know what they do not know. The diagnostic is to ask whether the surface signals that more exists: if a receiver who stops at a layer cannot tell there is a layer below, the design has crossed from disclosure into concealment, regardless of whether the content is technically retrievable.
T3 — Helpful Deferral versus Dark Pattern (What Is Hidden, Not Just How). The same structure that mercifully defers irrelevant detail can bury consequential content — fees, auto-renewals, opt-outs — behind an unobtrusive affordance dressed as ordinary layering. The pattern is ethically neutral; its honesty depends on the consequence of what sits below. The failure mode is treating layering as self-justifying, so any hiding-with-a-path passes as good design even when the hidden content is exactly what the receiver needed at the surface. The diagnostic is to ask whether the deferred content is consequential to the receiver's decision: irrelevant detail belongs below an affordance, but a material cost or commitment belongs on the surface, and demoting it is a dark pattern however clean the layering looks.
T4 — Sufficient Layer versus Truncated Layer (the Stopping Test). Each layer must be self-contained — a receiver who stops there must be able to act correctly — but a layer can instead be an arbitrary cut-point that strands the receiver mid-task. The failure mode is splitting a single coherent decision across layers, producing the "click-here-for-more" no one clicks because stopping leaves them unable to proceed. The diagnostic is to test by stopping: at each layer, ask whether a receiver who halts there is materially worse off. If they are, the layer is truncation masquerading as disclosure, and the fix is to re-layer by task rather than by topic so each surface genuinely supports a unit of action.
T5 — Default Path versus Descent Path (Two Coupled Design Problems). Layering and defaults are not separable: a layer's defaults must be what a typical receiver at that depth would choose, so that not descending is reasonable rather than a trap. The failure mode is designing the layers well but the defaults badly, so the receiver who sensibly declines to descend is silently mis-served — the express path quietly does the wrong thing for them. The diagnostic is to ask, of each layer's defaults, whether the modal receiver at that depth is well served by accepting them without going deeper: if good outcomes require descending, the defaults have made non-descent a trap, and the layering's promise of safe stopping is broken.
T6 — Audience Calibration versus Fixed Layering (Need-to-Know Varies). Layers are calibrated to "the receiver's current need-to-know," but receivers differ — what is the minimum sufficient surface for a novice buries a power user, and the layering that serves one mis-serves the other. The failure mode is designing a single fixed layering for a heterogeneous audience, so the surface is either too shallow for experts (forcing constant descent) or too deep for novices (defeating the deferral). The diagnostic is to ask whose need-to-know set the layer boundaries: where the audience spans expertise levels, a single static layering cannot be minimal-sufficient for all, and the design must either segment by audience or let receivers reset their own default depth.
Structural–Framed Character¶
Progressive disclosure sits on the framed side of the structural–framed spectrum — a framed prime with a 0.5 aggregate at the boundary, framed because the single decisive diagnostic maxes out. There is a clean structural skeleton beneath it — a layered surface whose visible layer is the minimum sufficient for the present task, with a visible affordance down to deeper layers reachable on demand — but the pattern is constitutively a presentation move, something done for a perceiving audience, and that pins it framed.
The decisive diagnostic is human_practice_bound, which reads a full 1. Progressive disclosure is not a pattern that runs in an indifferent physical substrate; it exists only relative to a receiver whose need-to-know is being calibrated against. Every canonical home — UI information architecture, spiral curricula, plain-language law, API facades, scientific-writing structure, onboarding flows — involves a perceiving audience descending through layers, and there is no version of the move without someone for whom the disclosure is staged. The remaining diagnostics sit at the middle or below. Vocab_travels is 0.5 because the HCI lexicon (disclosure, affordance, layer) translates into curricular "scaffolding" or legal "plain-language summary plus detail" with mild friction, so the vocabulary carries but with a design-practice residue. Institutional_origin is 0.5 because the prime was codified in human-computer-interaction practice, a real but soft origin. Import_vs_recognize is 0.5 because invoking it half-imports a presentation methodology (layer, default, advertise the path down) and half-recognizes the underlying staged-revelation structure. And evaluative_weight is flatly 0 — progressive disclosure is neither good nor bad until you specify what is being staged; arbitrary layers or weak affordances are named as a structural failure mode, not an inherent evaluative charge. The structural skeleton is genuine, but because the pattern cannot exist outside a human presentation practice with an audience, the framed label with its 0.5 boundary aggregate is the faithful placement.
Substrate Independence¶
Progressive disclosure is a strongly substrate-independent prime — composite 4 / 5 on the substrate-independence scale. Its breadth is good: the layered-surface-with-on-demand-descent move recurs across HCI information architecture, spiral curricula, plain-language law layered atop statutes, software facades and API design, scientific writing's abstract-to-detail structure, and onboarding. The signature is highly relational — a layered surface, per-layer self-contained sufficiency, a visible affordance down, well-chosen defaults, hidden-but-reachable complexity, the availability/presentation distinction — stated medium-neutrally, so the audit discipline ("test by stopping") and the dark-pattern boundary carry intact across substrates. Transfer is concrete and documented, carried as a single set of interventions (layer by task not topic, make the affordance honest, default well, watch for dark-pattern misuse) with clean role mappings (surface layer, deeper layers, affordance down). What holds it below a pure 5 is that the move is constitutively a presentation pattern: every instance presupposes a perceiving receiver whose need-to-know is being calibrated against, so it does not run in indifferent physical substrates the way percolation or postponement do. Its structural shape is clear and recognized rather than translated across its range, but the audience-relative ceiling places it at a high composite 4 rather than at the top.
- Composite substrate independence — 4 / 5
- Domain breadth — 4 / 5
- Structural abstraction — 4 / 5
- Transfer evidence — 4 / 5
Relationships to Other Primes¶
Parents (1) — more general patterns this builds on
-
Progressive Disclosure is a kind of Layering
The file: progressive_disclosure is 'the SPECIFIC, receiver-facing SPECIES of layering' defined by three added constraints (per-layer sufficiency, minimum-sufficient visible layer, a visible affordance down) generic layering lacks. Genus=layering.
Path to root: Progressive Disclosure → Layering
Neighborhood in Abstraction Space¶
Progressive Disclosure sits among the more crowded primes in the catalog (36th percentile for distinctiveness): several abstractions describe nearly the same structure, so a description that fits it will tend to fit its neighbors too — transporting it usually means disambiguating within this family rather than landing on it exactly.
Family — Levels, Scale & Decomposition (29 primes)
Nearest neighbors
- Layering — 0.75
- Information Asymmetry — 0.73
- Primary vs. Secondary Sources — 0.72
- Reductionism — 0.71
- Hierarchical Decomposability — 0.71
Computed from structural-signature embeddings · 2026-06-14
Not to Be Confused With¶
The most consequential confusion is with information_hiding, because both defer content a consumer is not currently using, and at the surface a hidden internal and a collapsed layer can look the same. The structural commitments are nearly opposite on one decisive point: the affordance. Information hiding encapsulates implementation behind an interface precisely so the consumer need not, and frequently cannot, see what is inside — the whole value is that the internals are concealed, free to change, and irrelevant to the caller. Its load-bearing invariant is the boundary that the consumer does not cross. Progressive disclosure keeps the deeper content advertised and reachable: the visible affordance down is structurally indispensable, telling the receiver that more exists and roughly what kind, so they may descend on demand. A module that hides its internals is doing the right thing by leaving the consumer unaware of them; a progressively disclosed surface that leaves the receiver unaware of its deeper layers has failed — it has degraded into omission. What information hiding captures that progressive disclosure does not is insulation against change and coupling; what progressive disclosure captures that information hiding does not is graduated reachability under the receiver's control. The tell is to ask whether the receiver is supposed to be able to find the deferred content: if yes, it is progressive disclosure; if the design's whole point is that they never need to, it is information hiding.
A second confusion is with layering itself, since progressive disclosure presents layers and "layered" is the natural word for it. But layering is the general move of organizing any system into stacked levels — a network stack, a sediment column, an architectural tier diagram — with no inherent commitment to a receiver, to sufficiency, or to on-demand descent. Progressive disclosure is the specific, receiver-facing species of layering defined by three added constraints that generic layering lacks: each layer must be self-contained and sufficient for a coherent task (a network layer is emphatically not "sufficient on its own" for the user), the visible layer must be the minimum sufficient for present need-to-know, and there must be a visible affordance permitting but not forcing descent. A protocol stack has layers but no affordance for a user to "descend" and no requirement that any single layer be actionable alone. Collapsing progressive disclosure into "layering" loses exactly the calibration-to-need and the honest-path-down that are the prime's whole contribution; conversely, importing progressive disclosure's stopping-test into a purely architectural layering misapplies a receiver-centric audit to a structure that has no receiver.
A third confusion worth drawing is with abstraction, which a designer may reach for because both produce a simpler surface over a complex body. The difference is discard versus defer. Abstraction forms a simpler concept by throwing away detail deemed irrelevant to the level of description — the abstraction stands on its own precisely because the omitted detail is gone from view and, ideally, no longer needed. Progressive disclosure retains all the detail, fully present behind the surface, and merely defers its presentation against need; nothing is discarded, and the deferred apparatus is reachable in its entirety. A spiral curriculum's first pass on recursion is not an abstraction that has permanently dropped the call stack — the call stack is deferred to a later pass and will be presented in full. This is why progressive disclosure carries the availability/presentation invariant (everything available, only the sufficient subset presented) while abstraction carries a genuine loss-of-detail. Treating a deferred layer as an abstraction wrongly suggests the hidden content is gone or unrecoverable; treating an abstraction as mere deferral wrongly suggests the discarded detail is sitting one click away.
For a practitioner, these distinctions assign the right tool and the right audit. If the consumer should never need the internals, hide them (information hiding) and do not bolt on a misleading "show more." If the structure has stacked levels but no receiver choosing a depth, it is plain layering and the stopping-test does not apply. If the simpler surface genuinely drops detail, it is abstraction and you owe no path back to what was discarded. Reserve progressive disclosure — with its affordance, its per-layer sufficiency, and its dark-pattern ethics — for the case where a receiver, calibrated to current need, must be able to act on the surface yet reach the full, retained depth on demand.
Solution Archetypes¶
No catalogued solution archetypes reference this prime yet.