Retirement Calculator Engine

Instructions

Build financial calculation engines in Rust for retirement planning. All computations run on-device for privacy — no financial data leaves the user’s machine.

Social Security Optimization

Calculate optimal claiming strategies based on:

• Primary Insurance Amount (PIA): Computed from the highest 35 years of indexed earnings
• Claiming age adjustments: PIA reduced for early claiming (62-66), increased for delayed credits (67-70)
• Age 62: ~70% of PIA (exact reduction depends on full retirement age)
• Full Retirement Age (FRA): 100% of PIA — currently age 67 for those born 1960+
• Age 70: ~124% of PIA (8% delayed retirement credits per year past FRA)
• Spousal benefits: Lesser of 50% of higher-earning spouse’s PIA or own PIA
• Survivor benefits: 100% of deceased spouse’s benefit if claimed at survivor’s FRA
• Break-even analysis: Calculate the age at which delayed claiming surpasses early claiming in cumulative benefits
• Tax torpedo: Model the interaction between Social Security income and provisional income thresholds ($25K single / $32K married) that trigger taxation of up to 85% of benefits

struct SocialSecurityInput {
    birth_year: u16,
    earnings_history: Vec<f64>,  // 35 years of indexed earnings
    spouse_pia: Option<f64>,
    target_claiming_ages: Vec<u8>,  // ages to compare (62-70)
}

struct ClaimingStrategy {
    claiming_age: u8,
    monthly_benefit: f64,
    break_even_age: u8,
    cumulative_by_age: BTreeMap<u8, f64>,  // cumulative benefits at each age
    tax_adjusted_benefit: f64,
}

Required Minimum Distributions (RMDs)

• Use the IRS Uniform Lifetime Table (Table III) for unmarried owners and owners whose spouse is not >10 years younger
• Use the Joint Life Table (Table II) when the sole beneficiary is a spouse >10 years younger
• RMD = Account Balance (Dec 31 prior year) / Distribution Period from table
• RMD start age: 73 (for those turning 72 after 2022, per SECURE 2.0); increases to 75 in 2033
• Calculate year-over-year RMD projections assuming a growth rate on the remaining balance
• Handle multiple accounts: aggregate all traditional IRA balances, but 401(k) RMDs must be taken from each account individually

fn calculate_rmd(account_balance: f64, owner_age: u8, spouse_age: Option<u8>) -> f64 {
    let divisor = if let Some(s_age) = spouse_age {
        if owner_age as i8 - s_age as i8 > 10 {
            joint_life_table(owner_age, s_age)
        } else {
            uniform_lifetime_table(owner_age)
        }
    } else {
        uniform_lifetime_table(owner_age)
    };
    account_balance / divisor
}

Roth Conversion Analysis

Model the tax impact of converting traditional IRA/401(k) balances to Roth:

• Conversion ladder: Convert fixed amounts annually to fill up low tax brackets
• Bracket filling: Calculate how much can be converted before pushing into the next marginal tax bracket
• Tax projection: Federal + state income tax on converted amount, accounting for other income sources
• Break-even period: Years until tax-free Roth growth exceeds the upfront tax cost
• Medicare IRMAA impact: Conversions increase MAGI, potentially triggering higher Medicare Part B/D premiums 2 years later

Key variables:

• Current marginal tax rate vs. expected future marginal rate
• Time horizon (years until Roth withdrawals begin)
• Expected investment return rate
• State income tax rate (some states don’t tax retirement income)

IRMAA Bracket Modeling

Income-Related Monthly Adjustment Amount (IRMAA) adds surcharges to Medicare Parts B and D:

• Based on Modified Adjusted Gross Income (MAGI) from 2 years prior
• 2024 brackets (adjust annually for inflation):
• ≤$103K single / ≤$206K married: standard premium
• $103K–$129K / $206K–$258K: +$70/month
• $129K–$161K / $258K–$322K: +$175/month
• $161K–$193K / $322K–$386K: +$280/month
• $193K–$500K / $386K–$750K: +$385/month
• >$500K / >$750K: +$420/month

• Model how Roth conversions, capital gains, and Social Security income affect IRMAA two years out
• Calculate the “IRMAA cliff” — the exact dollar of income that triggers the next surcharge tier
• Identify safe conversion amounts that stay below IRMAA thresholds

Rust Implementation Patterns

• Use rust_decimal crate for financial calculations — IEEE 754 floating point introduces rounding errors in dollar amounts
• All tax tables and life expectancy tables are compile-time constants (const arrays)
• Expose calculations to the frontend via Tauri IPC commands
• Return all intermediate values, not just the final result — users need to understand how the answer was derived
• Every calculation function must be deterministic: same inputs always produce same outputs
• Include unit tests against IRS Publication 590-B examples for RMDs and SSA benefit calculators for Social Security

Privacy Architecture

• Zero network calls from the calculation engine — all data stays on device
• Tax tables and life expectancy tables are bundled in the binary
• User financial data is stored only in the local SQLite database
• No telemetry or analytics on financial inputs or outputs

Inputs Required

• Birth date (and spouse’s birth date if applicable)
• Annual earnings history (for Social Security PIA calculation)
• Retirement account balances by type (Traditional IRA, Roth IRA, 401(k))
• Expected annual return rate and inflation rate assumptions
• Current and projected annual income from all sources
• State of residence (for state tax calculations)
• Target retirement age and life expectancy assumption

Output Format

• Social Security claiming strategy comparison table with break-even ages
• RMD projection table by year (age, balance, RMD amount, remaining balance)
• Roth conversion analysis with bracket-filling amounts and tax impact by year
• IRMAA impact projection showing surcharge triggers
• Combined retirement income projection integrating all sources by year
• All intermediate calculations available for user inspection

Anti-Patterns

• Using f64 for dollar amounts: Floating-point arithmetic causes rounding errors — use rust_decimal or integer cents
• Hardcoding tax brackets in business logic: Tax brackets change annually — store them as versioned data tables loadable at runtime or compile time
• Single-scenario output: Retirement planning requires comparing multiple strategies — always model at least 3 scenarios (early, standard, delayed)
• Ignoring the interaction between income sources: Social Security taxation, IRMAA, and capital gains brackets all interact — optimizing one in isolation sub-optimizes the whole
• Network calls for calculations: Financial data is sensitive — all computation must be local, with no API calls to external services
• Presenting results without assumptions: Every projection depends on return rate, inflation, and life expectancy assumptions — always display these prominently