Educational tool — not investment advice.
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 volatility and time interact. The volatility you type (or that a loaded quote solves to) is a plain calendar / Act-365 annualized number — the value a textbook Black-Scholes calculator would take — but inside the solve it runs on a business-time clock. Each calendar day left to expiry carries a variance weight: an ordinary weekday 1, a weekend day 0.15 (a stock barely moves in information terms while the market is closed, but news over a weekend isn't nothing), a US market holiday 0. Total variance is that weighted day-count over a year normalized so a full calendar year comes to exactly 1, which is what keeps the quoted number calendar-annualized. The visible effect: a short-dated contract that straddles a weekend or a holiday is priced with slightly less variance than its raw calendar day-count implies; over a full year the weighting averages out and the two agree. Discounting and cost-of-carry — the rate and dividend terms — accrue on every calendar day regardless and stay on Act-365. For a short-dated option the provenance line under the Volatility field shows roughly how many trading days of variance the window actually carries.
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 Scenario Shocks' single-leg view also solve two more, coarser companion grids (half and a quarter of the main resolution) and combine all three via repeated Richardson extrapolation (Romberg's method) — first extrapolating the two adjacent pairs the ordinary way, then extrapolating those two results against each other a second time, canceling a further share of the grid's own discretization error beyond what a single extrapolation reaches. Price sweeps pick up the two extra companion grids for free, since each is solved once and reused for every swept point. Sweeping Rate, Dividend, Time or Vol instead skips this extrapolation entirely for these seven — each sample there is already an independent solve, so extra companions would cost extra solves 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 no amount of Richardson extrapolation reaches. And measured directly against a closed-form reference, the second extrapolation pass is a reliable improvement only for well-conditioned cases (near-the-money, longer-dated); for an off-center strike or a short-dated option it can slightly underperform a single pass, a known grid-alignment quirk of finite-difference option Greeks — in both directions the effect is many orders of magnitude below anything visible in the number shown.
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. Shown in the Value family of the Greeks table, this 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. 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. This 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. On the Price Distribution view, this overlays 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 more numerical noise than the rest of the table — this table now solves those seven on their own much finer grid, double the tier the sensitivity graph's own high-order sweeps use (tuned against real jaggedness stress-cases), plus two coarser companions combined via repeated Richardson extrapolation, rather than the cheap grid every other Greek uses, specifically to keep that noise as small as this method can make it. Sweeping Rate, Dividend, Time or Vol on the sensitivity graph instead of reading this table (or a Price sweep) still uses the coarser sweep-tier grid for these seven, so noise there hasn't changed. That extra accuracy has a real cost: solving three grids just for these seven Greeks takes noticeably longer than the rest of the table — several seconds on an ordinary machine — which is what the "Computing high-order Greeks…" spinner over the table is waiting on after an edit, not a stall.
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, both 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 the terminal distribution it integrates is built from the same volatility the position is actually priced at — the front leg's own (the Payoff view's Vol scenario slider in Single Option, a loaded ticker's solved vol in Multi Legs), on the same business-time clock as the pricing above — with Time, Rate and Dividend taken from the Inputs panel, not the scenario sliders.
Expected Value. On that same view, the probability-weighted P&L: the option's payoff at expiry integrated against that distribution, discounted to today at the risk-free rate, minus the premium paid now. For a position priced at its own fair value the two sides cancel and it reads about zero by construction; it only shows real magnitude when a premium was typed in by hand and differs from what today's volatility says the option is worth.
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 |
|---|
Educational tool — not investment advice.
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.
Vol Source. Only shown for a Strike sweep: a small menu picking what each sampled strike's own vol comes from — Const Vol, Market Vol, or SVI Vol. Const Vol is the default, so a Strike sweep never silently changes what it's plotting just because a ticker happens to be loaded — it holds vol flat at the scenario value exactly like every other axis does, ignoring the smile even once one's loaded. Market Vol reads each sample's own real, market-implied vol by linearly interpolating the quoted smile instead — the "sticky strike" convention real desks use, not a fitted model — falling back to the flat scenario vol (Single Option) or that leg's own vol (Compare Legs) past the smile's own quoted strike range. SVI Vol reads the same sample off the fitted SVI curve instead, extrapolating a little past the quoted strikes the same way the Volatility Smile view's own SVI Fit does, then falling back to Market Vol's own interpolation (and its same flat fallback) beyond that — raw SVI's wings otherwise grow without bound at the extreme, near-zero-strike edge this sweep's own range can reach. The same Market Vol fallback also catches the opposite failure mode, even inside the fitted band: SVI's own formula is floored at zero total variance rather than allowed to go negative, which without this guard would show up as vol plunging to an unnatural near-0% cliff right before that floor rather than a realistic taper — under ~1% is treated as the model having broken down there, not as a genuine reading, and falls back the same way. In Compare Legs, each market-linked leg reads its own real chain independently, not one shared curve applied to every leg. All three stop the moment you drag the Vol scenario slider yourself in Single Option; in Compare Legs each leg's vol is already its own value with no shared slider to defer to, so whichever of the three is picked applies unconditionally whenever a smile's loaded and that one's selected.
Sticky rate. Once the yield curve has loaded, a Time sweep reads each sampled time's own real Treasury rate the same way — in Compare Legs, each leg reads the curve at its own real remaining time, not a shared one — clamped at the curve's own shortest/longest maturity rather than extrapolated past it. Stops the moment you drag the shared Rate scenario slider yourself, in either mode.
Educational tool — not investment advice.
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.
Educational tool — not investment advice.
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.
Educational tool — not investment advice.
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.
Expected Value. In Results below — the probability-weighted average P&L across every possible price at expiry, at today's actual rate/dividend/time and the position's own volatility — the same real-world-vs-risk-neutral caveat as any expected value applies. A fairly auto-priced leg nets close to $0 here almost by construction, since the premium already IS the discounted expected payoff; it moves away from $0 mainly when a leg's premium was typed in by hand and differs from what today's vol says it's worth.
A market-linked leg can show a persistently positive Expected Value without that being a real edge, though. Its premium comes from whatever the chain actually quotes, and a thin or wide-spread contract's quote can be stale or one-sided enough to solve to an implied vol that's genuinely off from where the contract would trade if it were liquid — the same noisy-quote caveat the Volatility Smile view's own "why it's noisy" note describes. Expected Value here is only as good as that solved vol, so it inherits whatever bias the quote itself carries; a positive number from an illiquid leg usually reflects the quote, not a mispricing you could actually capture.
Educational tool — not investment advice.
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.
SVI Density. Same Breeden-Litzenberger method as Market Skew, but reads vol off a smoothed, arbitrage-checked SVI fit of the quotes instead of a curve drawn straight through them — an explicit MODEL of the smile, not the smile itself, so it's its own independent toggle rather than replacing Market Skew. The two can diverge, especially on a thin or wide-spread name; that's the fit smoothing over noise Market Skew shows as-is. It's also defined beyond the quoted strikes, so it can show a wing where Market Skew has nothing to plot at all.
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.
The table below. Single Option only — Multi Legs has no single "current strike" to read it at. Shows Const/Market/SVI implied vol and probability of finishing above the current Strike, side by side, at whatever Spot/Time/Rate/Dividend the sliders above are currently set to — the same three sources as Market Skew/SVI Density above, just as single numbers instead of a whole curve. Market/SVI columns stay empty until a ticker's loaded (Market) or a fit succeeds (SVI, needs 5+ quoted points). Doesn't change how the Results table itself prices this option — it's a comparison, not an alternate pricing input.
| Const Vol | Market | SVI | |
|---|---|---|---|
| Implied Vol | — | — | — |
| P(above strike) at expiry | — | — | — |
Educational tool — not investment advice.
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. When there's a boundary to draw, the 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. If the chart is empty instead, early exercise is never optimal at these inputs (see "Why it exists" above) — nothing is being hidden.
Educational tool — not investment advice.
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.
Educational tool — not investment advice.
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.
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.
SVI Fit. Adds one more line: a parametric SVI (Stochastic Volatility Inspired) model calibrated to the same real quotes — an explicit MODEL of the smile, not the smile itself, so it's off by default and never replaces the real Call/Put lines. It's drawn extrapolated well past the quoted strikes on both ends (in Curve mode as one continuous line; in Surface mode as a dashed line per visible expiry, color-matched to that expiry's raw line) — where the real quotes end is visible from where the Call/Put lines themselves stop. Past that point the SVI curve is less and less reliable the further out it goes: SVI is fitted only where there's data, and its wings are unconstrained — a modest amount of noise near the edge of the quoted range can send the extrapolated tail sharply up or down. Treat anything beyond the last real quote as "the model's guess", not a reading.
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.
Educational tool — not investment advice.
What this does. Applies a hypothetical shock to Spot/Vol/Rate/Dividend/Time and reprices — Baseline is today's actual values, Shocked is with the shock applied, Δ is the difference. No new pricing model: Single Option reuses the exact same PDE construction the Results table itself uses; Multi Legs reuses the same per-leg Greeks/Net aggregation the Payoff view's own Position Greeks table uses.
Shock fields. Spot (%), Vol Δ (percentage points of IV), Rate Δ (percentage points), Dividend Δ (percentage points), Days Forward (time decay — 0 leaves Time exactly where it is today). All start at 0 (no shock). The +/− buttons next to Spot/Vol/Rate/Dividend ADD or SUBTRACT that amount from whatever's already typed there (click twice for double) rather than jumping to a fixed number — type directly for anything else. Days Forward has its own slider, capped at the option's own remaining days so it can't shock past expiry.
Multi Legs. Shows a Baseline/Shocked/Δ block for every leg plus a Net block, across the full Greek set. Spot and Dividend shocks are shared across every leg; Vol, Rate and Time shocks apply to each leg's own value independently, same as everywhere else a leg carries its own vol/rate/time.
Single Option shows whichever side (Call/Put) is currently selected in the Inputs panel.
Fill in the inputs above to plot the graph.
Educational tool — not investment advice.