HELIIO

Fixed income, differentiated.

Blazing-fast pricing and risk for rates, bonds, credit, inflation and FX. Risk is the exact derivative of the price, taken by adjoint algorithmic differentiation (AAD), not a bump-and-reprice. Open source, under the MIT license.

Explore the docs
  • 61 executed examples
  • Python and Rust print the same figures
  • Open source, MIT

61 executed examples · every number is the release's own output

01 / 61 · swap.py
# calibrate SOFR from six quotes; risk a 2Y2Y swap

import datetime
import helixio as hlx

valuation = datetime.date(2026, 9, 25)

# Par SOFR swap quotes, 24 Sep 2026 close, one swap
# per tenor on the template's conventions.
quotes = {"1Y": 0.0445, "2Y": 0.0468, "3Y": 0.0477,
          "5Y": 0.0474, "10Y": 0.0477, "30Y": 0.0478}
rungs = hlx.calibration.par_rungs(
    "USD-SOFR-OIS", valuation, quotes)
curve = hlx.calibration.curve(valuation, rungs).curve()
market = (
    hlx.MarketContext(valuation)
    .with_discount("USD", curve)
    .with_projection("USD-SOFR", curve)
)

sofr = hlx.templates.get("USD-SOFR-OIS")
swap = sofr.vanilla_swap(
    valuation, "2Y2Y", fixed_rate=0.048,
    notional=100_000_000,
)
book = hlx.Book().add("SWAP-001", swap, 1.0)
book.attach_market(market)  # it carries its market

book.npv()  # -52_542.27...
print(book.report(
    [hlx.risk.NPV, hlx.risk.rates.PAR_LADDER],
))
# one risk pass, both measures, each ladder row by
# the tenor it was quoted at, in bp:
#
#   NPV                      -52,542.28
#
#   PAR_LADDER
#    1Y                            6.66
#    2Y                       19,063.12
#    3Y                      -13,718.61
#    5Y                      -22,560.81
#   10Y                            0.00
#   30Y                            0.00

Risk is a derivative of the price, not the difference between two prices.

What you get

Four ideas the documentation states first, each demonstrated by an example that runs against the release.

  1. Risk with no bump size to tune

    Nothing is bumped and revalued. The engine differentiates the valuation itself by AAD, recording one pass on a tape and sweeping it back, so every sensitivity comes out with the value: sparse, with no bump size to choose, and consistent with the value by construction.

    Read: The Jacobian
  2. Prices and risk in the same process

    Pricing code is written once against a generic scalar and instantiated at the call site with the numeric mode the problem needs. No crate wide alias, no Cargo feature: one process prices without derivatives and takes risk in the same run.

  3. Trades that cannot drift from their market

    A trade is a notional, a rate and dates. Calendar, day count, frequency and roll come from the index the trade names, so the same dates in three markets are three different trades, and nothing restated at the call can drift.

    Read: Conventions and templates
  4. The same figures from Rust and Python

    One implementation, in Rust. The Python package marshals and calculates nothing, and the two are required to agree bit for bit. Every result is a record set that converts to rows, CSV, polars or pandas.

    Read: API reference

From a quote sheet to a risk report in three steps

The swap example on this page, in its three calls. Each line here is taken from an example above.

  1. Build the market from quotes

    Hand the market context a quote sheet per currency. A recipe bootstraps each curve, and the market keeps the ladder it was solved from.

    market = hlx.MarketContext(close)
        .with_recipe_quotes("USD", USD_SOFR_CLOSE)
  2. Book trades from a template

    Name the index and give a notional, a rate and dates. Calendar, day count, frequency and roll come from the template.

    sofr = hlx.templates.get("USD-SOFR-OIS")
    swap = sofr.vanilla_swap(valuation, "2Y2Y",
        fixed_rate=0.048, notional=100_000_000)
  3. Report value and risk in one pass

    Ask the book for its measures. The par ladder comes back by the tenor each quote was given at, in basis points.

    book.report([hlx.risk.NPV,
                 hlx.risk.rates.PAR_LADDER])

51 products, 15 risk axes

Every product prices through one market context and is risked in one pass.

  • Rates

    • Vanilla swaps & OIS
    • Tenor basis & cross currency swaps
    • FRAs, deposits & rate futures
    • Zero coupon & CMS swaps
    • Caps & floors
    • European & Bermudan swaptions
    • Callable swaps
    07
  • Bonds

    • Fixed rate, FRNs & zero coupon bonds
    • Callables, bond options & bond future options
    • Inflation linkers & PIK bonds
    • Structured & repack notes
    • Bond futures, asset swaps & cross currency asset swaps
    • Spread & yield measures, street conventions
    06
  • Financing

    • Repo, reverse repo & buy/sell back
    • Open repo, tri party repo & securities lending
    • Bond forwards
    • Bond total return swaps
    • Loans & callable loans
    • Fees
    • General collateral & specials repo curves
    07
  • Credit

    • CDS & CDS options
    • Index CDS
    • CDO tranches
    • Nth to default
    • Credit linked notes & swaps
    • Survival curves
    06
  • FX & inflation

    • FX forwards & swaps
    • FX options & vol surfaces
    • Non deliverable forwards, swaps & options
    • Zero coupon & year on year inflation swaps
    • Inflation caps & floors
    • Inflation curves & seasonality
    06
  • Equity

    • Equity options
    • Equity total return swaps
    02
  • Strategies

    • Straddles & strangles
    01
  • Curves & calibration

    • Discount, step, spread & survival curves
    • Declarative recipes
    • Bootstrapping & joint solves
    • CSA & cross currency discounting
    • Parametric fits
    • Hull–White & SABR
    • The calibration Jacobian
    07
  • Risk & P&L

    • 15 risk axes, from rate to equity vol
    • Zero & par bases, bucketed ladders
    • Currency aggregation
    • Scenario shifts
    • Quote space perturbation
    • P&L explain & attribution
    06

Read the documentation

The 0.0 line in full, 164 pages, readable now while the package is not. Start with a first trade, or go straight to the product you price.

Questions

What quant developers ask before they read further.

Is helixio free to use?

Yes. helixio is open source under the MIT license, and its source is public on GitHub.

Can I install it today?

Not from a package index yet. The documentation is readable now and the source is public. Leave an address at the foot of this page and we write once, when the package is published.

Which languages does it support?

Rust and Python. There is one engine, written in Rust. The Python package marshals arguments and calculates nothing itself, and the two are required to print the same figures. Python API reference

How are sensitivities computed?

By adjoint algorithmic differentiation (AAD). The valuation is recorded once on a tape and swept back, so every sensitivity arrives with the value and there is no bump size to choose. The Jacobian

What can it price?

51 products across rates, bonds, financing, credit, FX, inflation and equity, on curves it calibrates itself, with risk on 15 axes. The coverage section on this page lists every family.

Is the API stable?

Not yet. The documentation is published as a preview, and every page carries a notice that the API is under testing and may change before the package is published.

What do results come back as?

A record set, which converts to rows, CSV, polars or pandas. A report keeps each ladder row under the tenor its quote was given at.

Where do the figures in the examples come from?

Each example on this page was run against the release in both languages, and every figure shown is copied from that run.

Can a coding agent write helixio code?

Yes. The documentation has a page on setting up a coding agent to write helixio, in its first section. Use it with a coding agent

Start with the documentation

Free to read, no account needed, and the source is on GitHub under the MIT license.

Be told when it is on a package index