DLMM VS AMM

TL;DR

• AMM (e.g., Uniswap v2): continuous pricing curve (often constant-product (x \cdot y = k)). Great UX and simplicity, but LP capital is spread across all prices → more slippage for the same TVL and lower fee APR in many markets.
• DLMM (e.g., Trader Joe Liquidity Book / Meteora DLMM): liquidity is placed into discrete price bins. Trades consume the active bin and hop bin-to-bin as liquidity depletes → better capital efficiency, but LPing can be more active/strategy-driven and price moves can leave you holding mostly one asset.

1) What is an AMM and how it works (with an example)

An Automated Market Maker (AMM) is a smart-contract-based market where prices are determined by a mathematical rule (an invariant), not by matching buyers and sellers from an order book.

The canonical AMM: constant-product pools

The classic AMM design (popularized by Uniswap v2) keeps two token reserves:

• (x): amount of token A in the pool
• (y): amount of token B in the pool

and tries to maintain:

[ x \cdot y = k ]

When you swap token A in, (x) increases, so (y) must decrease to keep (k) constant (after fees). That “movement along the curve” is what causes:

• Slippage: your average execution price worsens with trade size relative to liquidity.
• Price impact: the pool price changes after your trade.

Where the “price” comes from

The instantaneous (marginal) price in a constant-product pool is derived from the reserve ratio:

[ P_{A \rightarrow B} \approx \frac{y}{x} ]

As you trade, (x) and (y) change, so the price changes smoothly along the curve.

LPs: how liquidity providers earn

LPs deposit both tokens (e.g., ETH + USDC) and receive LP shares. They earn:

• Trading fees (e.g., 0.3% per swap, depending on the pool), proportional to their share of liquidity.

But LPs also face impermanent loss (IL): if the market price moves, the AMM rebalances the LP’s holdings (selling the winner, buying the loser), so the LP may underperform simply holding.

Example project: Uniswap v2

Uniswap v2 is the archetype of constant-product AMMs. If you’ve ever swapped on many DEX aggregators, you’ve likely routed through a Uniswap v2-style pool at least once.

Key “v2-style AMM” traits:

• One continuous curve for all prices
• Passive LPing (no range selection)
• Simple and robust (great composability, predictable math)

2) What is a DLMM and how it works (with an example)

DLMM usually refers to a Discretized Liquidity Market Maker: instead of providing liquidity across a continuous curve, liquidity is allocated into discrete price buckets (“bins”).

You can think of it as taking “concentrated liquidity” ideas and making the price grid explicit and step-based.

Core concept: bins + an active price bin

A DLMM defines a set of price bins indexed by (i). Each bin represents a price level (or a small price interval). A common parameterization is:

[ P_i = P_0 (1+\delta)^i ]

where:

• (P_0) is a reference price
• (\delta) is the bin step (e.g., 0.01%, 0.05%, 0.1%…)

At any time there is an active bin (the current “market” price bin). Liquidity is stored per-bin, so each bin has its own reserves ((x_i, y_i)).

How swaps work in a DLMM (bin-to-bin execution)

The typical execution flow looks like this:

• Swap consumes liquidity in the active bin at that bin’s price.
• If the trade is large enough to empty one side of the active bin, the swap moves to the next bin (higher or lower price) and continues.

This creates a price path that is piecewise / step-based:

• Inside a single bin, the price is approximately constant (depending on the DLMM design).
• When you cross bins, the price jumps discretely by the bin step (\delta).

Intuitively:

• More liquidity in the active bin ⇒ less slippage for small trades.
• More bins populated around the active bin ⇒ better execution for larger trades (fewer “gaps”).

How LPs provide liquidity (strategies are first-class)

In a DLMM, LPs usually choose where (which bins) to place capital:

• Wide distribution (many bins): more passive, closer to “v2 feel”, but lower capital efficiency.
• Narrow distribution (few bins near active price): higher fee density and better efficiency, but you can go “out of range” faster.
• Single-sided / asymmetric: some DLMMs make it easy to provide mostly one asset in certain bins.

This is why DLMM LPing often looks more like “running a strategy” than “deposit and forget”.

Example project: Trader Joe Liquidity Book (LB)

Trader Joe’s Liquidity Book (LB) is one of the most well-known DLMM implementations (initially popular on Avalanche and expanded to other chains).

Conceptually:

• Liquidity lives in bins around an active price.
• Swaps execute bin-by-bin.
• LPs can choose bin distributions (tight, wide, shaped), enabling different risk/return profiles.

Example project: Meteora DLMM (Solana)

On Solana, Meteora’s DLMM is a widely used discretized-liquidity design.

If you’ve seen pools described with “bins” / “strategies” / “dynamic fee” style UX, that’s the DLMM mental model: place liquidity where you expect price to trade, and earn fees when volume goes through those bins.

3) DLMM vs AMM: differences, pros/cons, and when to use each

To avoid confusion: many people use “AMM” to mean all non-orderbook DEX designs. In this post:

• AMM = classic continuous-curve pools (e.g., constant-product v2-style).
• DLMM = discretized bins + active-bin execution.

Key differences (mechanics)

Pros and cons: AMM (v2-style)

• Pros
  • Simple mental model: deposit two assets, earn fees.
  • Great composability: predictable invariant math used everywhere in DeFi.
  • Passive LPing: no range management.
  • Resilient liquidity: always provides a price for any trade size (though increasingly worse).
• Cons
  • Lower capital efficiency: liquidity is spread over prices that may never be reached.
  • More slippage for the same TVL (especially in volatile pairs).
  • Impermanent loss is unavoidable when prices move; fees must out-earn it.

Pros and cons: DLMM

• Pros
  • Higher capital efficiency: liquidity concentrated where trading happens.
  • Better execution near active price (tighter spreads / less slippage).
  • Flexible LP strategies: shaped liquidity, asymmetric positioning, etc.
  • Often supports fee models better aligned with volatility and flow (implementation-dependent).
• Cons
  • More complex LPing: performance depends on bin selection and rebalancing.
  • Out-of-range risk: if price moves away from your bins, your capital can stop earning fees.
  • Inventory concentration: after directional moves, you can end up mostly holding one asset (a form of IL / rebalancing outcome).
  • More parameters (bin step, strategy, ranges) can confuse users and increase “strategy risk”.

Practical guidance: which one should you use?

• If you’re a trader
  • AMM (v2-style): great for long-tail pairs and simple routing, but expect more slippage in thinner pools.
  • DLMM: often better pricing when liquidity is well concentrated; just watch for “bin gaps” and liquidity depth beyond the active bin.
• If you’re an LP
  • Choose AMM (v2-style) if you want set-and-forget exposure and are okay with lower efficiency.
  • Choose DLMM if you’re willing to manage ranges/strategies (or use an auto strategy) to seek higher fee density.

A quick intuition checklist

• High volatility + active volume: DLMM can shine if strategy keeps you near the action.
• Low volume or very uncertain price: v2-style can be safer because you’re not betting on a narrow region.
• Stablecoin pairs: either can work well; DLMM/concentrated designs often win on efficiency, but details matter (fees, incentives, active liquidity).

Closing thoughts

AMMs made on-chain trading simple by turning pricing into math. DLMMs push further by making liquidity placement explicit and discretized, often improving capital efficiency—but shifting more responsibility (and risk) to LP strategies.

If you only remember one thing: AMM is “one curve for everyone,” while DLMM is “many bins you choose.”