What this is. A pricer and full Greek surface — from Delta through third-order Greeks like Ultima — for calls and puts, American or European exercise style (the toggle in this panel's top-right corner). American options don't have a closed-form pricing formula, because the holder can exercise at any instant before expiry, not just at expiry the way a European option does. So every number here is computed numerically instead — European mode reuses that exact same solve with the early-exercise check turned off, rather than a separate closed-form formula, so the two stay directly comparable.
How it prices. One Crank-Nicolson finite-difference solve of the Black-Scholes PDE, done in log-price space. The grid isn't evenly spaced: nodes are packed densely around the strike and taper out from there, and the whole grid is made wide enough to also resolve early exercise away from the strike, for when a large enough gap between rate and dividend pushes the exercise boundary out there. The first two time steps use fully-implicit weighting — a technique called Rannacher smoothing — specifically to damp the numerical noise that the payoff's kink at the strike would otherwise inject. Early exercise itself is enforced at every step by the Brennan-Schwartz algorithm: a direct, non-iterative solve that builds "can't be worth less than exercising" straight into that step, rather than approaching it through repeated relaxation.
How each Greek is read off it. Delta, Gamma and Theta come directly from that one solved grid, read off with a 5-point local interpolation rather than just the two or three nearest nodes — that extra smoothness matters for Speed, Zomma and Color, which are themselves derivatives of Delta and Gamma and would otherwise come out visibly jagged. That interpolation also knows where the early-exercise boundary sits (a node counts as "exercised" once the solve has pinned it to intrinsic value) and keeps its 5-point window on one side of that boundary, rather than fitting one smooth curve across what is, right there, a genuine discontinuity.
Vega, Rho and Psi each need one extra solve — the same PDE solved again with volatility, rate or dividend nudged slightly — and a finite difference between the two. The cross-Greeks (Vanna, Charm, Zomma, Color) and the higher-order volatility Greeks (Vomma, Ultima, Veta) stack several of these bumped solves on top of each other, and all seven get an extra layer of accuracy on top of that: the results table and a Price sweep also solve a second, coarser grid and Richardson-extrapolate against it — a technique that cancels out a meaningful share of the grid's own discretization error, and costs nothing extra since that coarse grid is solved once and reused for every point on the sweep. Sweeping Rate, Dividend, Time or Vol instead skips Richardson extrapolation for these seven — each sample there is already an independent solve, so a coarse companion would cost one extra solve per point — and leans on a meaningfully finer base grid instead. It can't fix everything, though: at very low volatility, the bump step used to difference Vomma and Ultima has to widen, which is a different kind of error — from the differencing itself, not the grid — that Richardson extrapolation doesn't reach.
Sharp edges are sometimes real. Wherever early exercise is optimal somewhere in the chart's range — a dividend pulling a call's boundary past the strike, or a rate doing the same for a put — Gamma and its relatives (Speed, Zomma, Color, Vomma, Charm...) can show a genuinely abrupt jump right at that boundary instead of a smooth taper. That isn't a rendering glitch. Past the boundary, the option is worth exactly its intrinsic value — a straight line, with zero curvature. Short of the boundary, there's still real time value and real curvature. The decision to hold or exercise isn't smooth at that dividing line, so the Greeks that measure curvature aren't either.
Early-Exercise Premium, in the Value family of the Greeks table, is the American price minus the equivalent European price — the extra value from being able to exercise before expiry, at these exact inputs. It's shown regardless of which style the toggle is currently set to, computed by solving this same grid both ways and taking the difference, so it's always available as a check on how much the toggle actually moved the price. It's never negative: American value can never fall short of European value, since the American holder could always simply choose to hold to expiry and end up with exactly the European payoff.
Implied volatility is solved separately from everything above, using a different, cheaper method: bisection on a 300-step Cox-Ross-Rubinstein binomial tree, not the PDE grid — with the same early-exercise check (or lack of it) as the style toggle above, so a solved IV stays consistent with whichever style the rest of the page is showing. Solving for one number — the volatility that matches a given market price — doesn't need a full Greek surface, so the cheaper tree is enough for that. It's also why applying a solved IV back into the Volatility field can price very slightly differently than the market price it was solved from: the tree and the PDE grid are two different numerical methods, each with its own small bias.
Real market data. Loading a ticker (top of the Inputs panel) switches Spot, Strike, Time and Volatility from typed assumptions to a real listed chain: Strike and Time snap to actual contracts instead of free-typed numbers, and Volatility is solved from that contract's own quoted price — either the Call's or the Put's, whichever side is currently selected — the same bisection method described above. Each expiry's Rate can also be pulled from the real US Treasury yield curve, interpolated to that expiry's own time-to-maturity, instead of one flat typed number (Yield Curve view; falls back to whatever's typed if that fetch fails). In Multi Legs, each leg can independently pick its own real contract this same way — a spread's two legs can each sit on a different strike, expiry and market-solved vol rather than sharing one.
Volatility Smile and Surface (its own view) plots every listed strike's own solved implied vol against a loaded ticker's real quotes, Call and Put shown separately since they can differ even at the same strike. Build Surface fetches several expiries at once (capped, sub-sampled evenly if the picked range has more) and overlays each one's own curve, color-graded from near-dated to far-dated; the Curves Shown slider then narrows that down to just the nearest ones. The strikes plotted are real, but the line drawn between them is plain linear interpolation for the picture's sake, not a fitted skew or term-structure model of its own — and a market-implied curve reflects whatever the quotes themselves look like: thin volume or a wide bid/ask on a given contract shows up directly as noise in its point, same as it would on a real broker's own chain.
Market Skew (Price Distribution view) adds the market's own implied probability distribution alongside the flat-volatility curve(s) already shown — never replacing them, so the flat-vol assumption and the real market skew stay directly comparable on one chart. It's derived from the loaded smile via Breeden-Litzenberger: the second derivative of call price with respect to strike, the standard way to recover a risk-neutral density straight from quoted option prices instead of assuming one flat vol applies at every strike. In Multi Legs Compare mode, it computes one such curve per distinct expiry among the position's own market-linked legs specifically, not just one from whatever the Smile view happens to be showing. This differentiates the quoted smile twice, which amplifies whatever noise is already in the underlying quotes — expect it to look rougher on thin or wide-spread names than on a heavily-traded one, and treat visible jaggedness as a property of that day's real market data, not a bug in the calculation.
Reading a multi-curve chart: anywhere more than one curve shows on the same graph at once (the Smile surface, Boundary/Distribution/Greeks Compare views), the legend under it is clickable — click a swatch to hide that curve, click it again to bring it back. Useful for isolating one line in a crowded comparison without losing the others.
Limitations, to be exhaustive about it:
The pricing model itself — the PDE solve every Greek in the table above comes from — still holds Rate, Dividend and Volatility flat and constant for the option's entire remaining life, one number each, regardless of where that number came from. Loading a ticker changes WHERE that one Volatility number is sourced from (a real quote instead of a typed guess), not what the model does with it: it's still one flat input to one solve, not a smile-consistent local or stochastic volatility model that prices every strike self-consistently against the whole curve at once. The Smile/Surface view shows you the raw market data across strikes; the Greeks table still only ever consumes one point of it. Dividends are likewise modeled as a continuous yield rather than a discrete cash payment on a specific date.
The single-option Results table specifically prices its Call AND Put columns off that one resolved Volatility — whichever side is currently selected in the Call/Put toggle — not each side's own independently-quoted vol. Real markets often show the put and the call at the same strike trading on slightly different implied vols (skew, put-call-parity effects); toggling sides re-solves Volatility from that side's own quote, but the OTHER column in that same table is still priced under the selected side's number, not its own. The Volatility Smile view's own Call/Put lines, and each leg's own resolved vol in Multi Legs, do track each side's real quote independently — it's specifically this one shared-input Results table that doesn't.
This is a numerical solve, not a closed-form formula, and each additional order of differencing compounds the grid's own discretization error on top of the last. Delta, Gamma and Theta are solid. Vega, Rho and Psi are one derivative removed and still reliable. Vanna, Charm, Zomma, Color, Vomma, Ultima and Veta are two or three derivatives removed from the raw solve, so they carry real — sometimes visible — numerical noise, particularly deep in or out of the money, very close to expiry, or when sweeping Rate, Dividend, Time or Vol on the sensitivity graph instead of reading the table's (or a Price sweep's) Richardson-extrapolated figure.
Early exercise is checked continuously — at any instant before expiry — rather than on fixed dates. That fits most listed equity options, but not a Bermudan-style contract that only allows exercise on specific windows.
One specific known edge case: at exactly 0% interest rate, the exercise-boundary chart's solve can occasionally miss a hairline-thin exercise region for calls, purely from floating-point precision at that boundary. This tool sidesteps it for the one case it affects — a dividend-free call at a rate of 0% or higher — by checking that case directly instead. The correct answer there (never optimal to exercise early) is already known analytically, so no numerical solve is needed at all.
Probability of Profit and Probability ITM, on the Payoff at Expiry view, come from the closed-form Black-Scholes N(d2) figure: the risk-neutral probability the stock finishes on the correct side of breakeven (or the strike) at the option's real expiration, under the same constant rate/dividend/volatility assumption used everywhere else in this tool. Three things worth knowing about that number: it's not the probability of ever touching that price before expiration, which is higher; it doesn't account for early exercise changing the payoff along the way (this doesn't affect Probability ITM, which only cares about the terminal stock price, but it is a real simplification for Probability of Profit on a position where early exercise would actually get exercised rather than sold); and it's computed from the Inputs panel's real Time/Vol/Rate/Dividend values, not from wherever the Payoff view's own scenario sliders happen to be set.
Prices and Greeks are checked against closed-form Black-Scholes for the dividend-free case, where American and European values must agree exactly — you can see that agreement directly: a dividend-free call's Early-Exercise Premium reads $0.00, and toggling its style between American and European shouldn't move its price at all. That said, this remains an educational tool — it hasn't been audited for production trading use, and nothing here is investment advice.
| Greek | Call | Put |
|---|
Fill in price, strike, time and volatility above.
| Greek |
|---|
How it works. Plots one Greek's sensitivity as a single input moves (Single Option), or the whole position's (Compare Legs) — pick which with Measure and Vary below, or jump straight to a common one via Jump to.
What you can do. Parameters sets every OTHER input to a hypothetical value while the curve sweeps — Price, Strike, Rate, Dividend, Time and Vol are all independent of the live Inputs panel here, so exploring never changes your actual prices; Reset puts them all back to today's values.
Reading the chart. The curve traces Measure's value across whatever Vary is currently swept; the dot marks where things stand right now. Values are always per share, even if $ Greeks is turned on in the table.
Every leg starts theoretical: a typed Strike, Days and Volatility, no real contract behind it. Once a ticker's loaded (Inputs panel, top), every leg switches to market mode automatically — a near-the-money, near-dated contract picked for you, zero clicks needed — and Strike/Days become real-chain pickers if you want a different one instead. In market mode, Strike and Days are read-only (they describe an actual listed contract), and Volatility/Rate/Premium all resolve from that contract's own real quote.
A market-mode leg's own Side (Call/Put) toggle re-fetches when flipped — a call and a put at the same strike are different contracts with their own separate quotes, so switching sides re-solves against the new one rather than reusing the old side's vol. Each leg can sit on its own strike AND its own expiry, independent of every other leg — that's what makes calendar and diagonal spreads possible here, not just same-expiry verticals.
Strategy presets build a whole multi-leg shape (spread, straddle, condor, ...) around the current spot in one click — theoretical if no ticker's loaded yet, or immediately market-linked (each leg auto-picked near the money) if one already is, same as adding a leg by hand.
Each leg's own implied vol, plotted against its strike — Call and Put legs shown as separate lines, since they can differ even at the same strike.
What you can do. Build a position above — Single Option or Multi Legs, using Strategy presets or your own strikes, optionally linked to real market contracts once a ticker's loaded — and this chart plots its outcome. Cost, Breakeven, Max Gain/Loss, Prob of Profit and Expected Value all update in Results as you do.
Reading the chart. This curve shows your profit or loss at expiration for each possible stock price — green means a profit, red means a loss. The dot marks the Spot price set below.
How it works. The lognormal curve(s) here assume one flat volatility for the whole distribution — the standard Black-Scholes model of how the underlying's price is distributed at expiry. A mixed-expiry Multi Legs position shows one curve per distinct (vol, time) combination among its legs, not just one.
Market Skew. Adds the market's own implied probability distribution alongside those flat-vol curves — never replacing them, so the two stay directly comparable. It's derived from the loaded ticker's real quotes (Breeden-Litzenberger), so it can show real skew and fat tails a flat-vol curve can't. In Multi Legs Compare, it computes one such curve per distinct expiry among the position's own market-linked legs. It won't show anything for a leg that's still theoretical — pick a real strike/expiry for at least one leg first. This differentiates the market's quoted smile twice, which amplifies whatever noise is already in the quotes — expect it to look rougher on a thin or wide-spread name than a heavily-traded one.
What you can do. Spot, Time, Rate and Dividend above are all explorable: the spread itself is volatility times the square root of time remaining, so dragging Time toward 0 narrows every curve toward a spike at expiration, and Rate/Dividend shift where it's centered. The dot marks today's spot price. This view is unaffected by the Style toggle in Inputs — it describes the stock's own terminal price, not the option, so American and European show the exact same curve.
What you can do. Toggle Single Option or Multi Legs above (Call/Put too, in Single Option), then use Vol/Time/Rate/Dividend below to see how the boundary shifts — these are independent of the live Inputs panel while you experiment; Reset puts them back.
Why it exists. American options can be exercised at any time before expiry — but doing so almost always throws away value for nothing, since selling the option outright captures more than exercising it does. Early exercise only wins when the cost of waiting outweighs the time value you'd give up: for puts, the interest you'd earn on the cash from exercising now; for calls, a dividend you'd only receive by actually owning the stock. No dividend, no reason — that's why a dividend-free call never shows a boundary at all. European-style options (Style toggle, in Inputs) skip this decision entirely — they can only be exercised at expiration, so there's no trade-off to trace and no boundary to show here.
Reading the chart. This line shows the stock price where that trade-off flips, at each point before expiration — near expiry there's little time value left to protect, so it drifts toward the strike. The shaded area is where exercising is worth it; a gap means it never is at that time. The dashed line marks today's spot price. For a call, that shaded exercise area sits above the line; for a put, it sits below.
Why it looks stepped. The line can look faintly stepped rather than perfectly smooth — that's real, not a rendering glitch. At each point in time, the critical price is read off the nearest node of the underlying price grid rather than interpolated between them, so it's quantized to whatever that grid's own spacing happens to be there. A finer grid (this chart already uses a much finer one than the Greeks table, since it's one solve either way) shrinks those steps, but can't remove them completely.
How it works. US Treasury par yields, published daily by FRED — not tied to any ticker, so it's the same curve regardless of what's loaded in the Inputs panel above.
What you can do. The Inputs panel's Rate field auto-tracks this curve, interpolated to whatever Time is currently showing, until you type into Rate directly — the same "auto until touched" contract every scenario slider in this app uses. Once touched, Rate stops following the curve; use its own reset to hand control back. Refresh here forces a re-fetch.
If it fails. No connection, FRED unavailable — Rate just keeps whatever it already had rather than blanking.
Reading the chart. The dot marks the exact rate this curve is currently interpolating for the Time entered in Inputs.
How it works. Implied volatility plotted against strike, solved from this ticker's own real quotes (the same bisection method the main Volatility field uses) — not a fitted curve. Call and Put show as separate lines since they can differ even at the same strike. Only the out-of-the-money side of each strike is solved: that's the liquid, tightly-quoted side; the in-the-money side of the same strike is usually wide or stale, and left out rather than shown as an unreliable number.
What you can do.
Build Surface fetches several expiries at once (capped, evenly sub-sampled if the picked range has more) and overlays each one's own curve, color-graded from near-dated to far. The strikes are real; the line drawn between them is plain linear interpolation for the picture, not a fitted skew or term-structure model.
Why it's noisy. Jagged patches are usually real, not a bug — a thin or wide-spread contract's quote is genuinely noisy, and this just plots what's actually quoted.
Also worth knowing. The Ticker field up in Inputs is shared by every view, not specific to this one — loading a symbol there writes real Spot, Dividend, Strike, Time and Volatility into Inputs (an ATM, near-dated contract picked for you, same as typing those numbers yourself), and this chart's strikes and quotes come from that same fetch. What's specific to this view is the direction: it solves backward from real quoted prices to implied vol across a whole chain of strikes at once, the same bisection Inputs' own auto-solved Volatility does for a single contract.
Fill in the inputs above to plot the graph.