Integration Guide

Vedic Astrology

Vedākṣha is designed around Jyotish from the ground up. Every classical concept — nakshatra, dasha, varga, yoga, Shadbala — is a typed first-class value in the API, not an afterthought layered on top of a Western engine.

All features documented here are available in Rust, Python, and WASM. They are part of every chart computation, not gated behind a separate module or license.

Nakshatra Lookup

Every sidereal longitude maps to one of the 27 nakshatras. Call nakshatra_from_longitude with a sidereal ecliptic longitude to receive the full nakshatra record.

nakshatra.rs

let sidereal_lon = 83.24; // degrees

let nak = nakshatra_from_longitude(sidereal_lon)?;

println!("Nakshatra : {}", nak.name);       // Mrigashira
println!("Pada      : {}", nak.pada);       // 4
println!("Lord      : {}", nak.lord);       // Mars
println!("Deity     : {}", nak.deity);      // Soma
println!("Guna      : {}", nak.guna);       // Tamas
println!("Gana      : {}", nak.gana);       // Deva

.name

Nakshatra name as a typed Nakshatra enum (e.g. Nakshatra::Mrigashira).

.pada

Quarter of the nakshatra, 1–4. Each pada spans 3°20′.

.lord

Planetary ruler of the nakshatra used in Vimshottari Dasha sequencing.

.deity

Associated deity from traditional sources (BPHS, Taittiriya Brahmana).

.guna

Tamas, Rajas, or Sattva — the three fundamental qualities.

.gana

Deva, Manushya, or Rakshasa — used in compatibility assessment.

Vimshottari Dasha

The Vimshottari system is a 120-year planetary period cycle keyed to the Moon's nakshatra at birth. Vedākṣha computes the full dasha tree to 5 levels of sub-periods (Maha Dasha → Antar → Pratyantar → Sookshma → Prana Dasha). Every node carries exact start and end dates as Julian Day numbers.

dasha.rs

let birth_jd = calendar_to_jd(1990, 6, 15, 6.0);
let moon_sidereal = 113.45; // Moon's sidereal longitude at birth

let tree = vimshottari_dasha(moon_sidereal, birth_jd)?;

// Iterate the top-level maha dashas
for maha in &tree.periods {
    println!(
        "{} dasha: {} to {}",
        maha.lord,
        jd_to_calendar(maha.start_jd),
        jd_to_calendar(maha.end_jd),
    );

    // Each period has .sub_periods with the antar dashas, and so on
    for antar in &maha.sub_periods {
        println!("  {} / {}", maha.lord, antar.lord);
    }
}

Depth Control

Pass a DashaConfig to limit tree depth and reduce memory use. Depth 1 returns only the maha dashas; depth 5 (default) returns all sub-period levels.

Yogini and Chara Dasha

Both alternate dasha systems follow the same tree API. Yogini Dasha runs a 36-year cycle through eight yoginis. Chara Dasha is sign-based rather than nakshatra-based, computed from the position of the Atmakaraka planet.

other_dashas.rs

// Yogini Dasha
let yogini = yogini_dasha(moon_sidereal, birth_jd)?;

// Chara Dasha — requires a full chart with atmakaraka computed
let chart = compute_chart(birth_jd, lat, lon, &ChartConfig::vedic())?;
let chara = chara_dasha(&chart)?;

// Both return the same DashaTree type
for period in &chara.periods {
    println!("{} sign dasha", period.lord);
}

Shodasha Varga — All 16 Divisional Charts

Vedākṣha computes all 16 divisional charts with independently placed planets and house cusps. Each varga is a complete mini-chart, not just a rearrangement of the D-1 positions.

D-1

Rasi — Natal

D-2

Hora — Wealth

D-3

Drekkana — Siblings

D-4

Chaturthamsha — Fortune

D-7

Saptamsha — Children

D-9

Navamsha — Marriage / Dharma

D-10

Dashamsha — Career

D-12

Dvadashamsha — Parents

D-16

Shodashamsha — Vehicles

D-20

Vimshamsha — Spiritual Practice

D-24

Chaturvimshamsha — Education

D-27

Saptavimshamsha — Strength

D-30

Trimshamsha — Misfortune / Debt

D-40

Khavedamsha — Auspiciousness

D-45

Akshavedamsha — General Indications

D-60

Shashtiamsha — Past Life Karma

vargas.rs

let chart = compute_chart(birth_jd, lat, lon, &ChartConfig::vedic())?;

// Access any varga directly
let navamsha = &chart.vargas[Varga::D9];
let dashamsha = &chart.vargas[Varga::D10];

for planet in &navamsha.planets {
    println!("{}: {}° in {}", planet.body, planet.longitude, planet.sign);
}

Yoga Detection — 50 Yogas

Vedākṣha evaluates 50 classical yogas from Brihat Parashara Hora Shastra and Phaladipika. Each yoga in the result carries its formation strength as a score from 0.0 to 1.0, the planets involved, and the source text.

yogas.rs

let yogas = detect_yogas(&chart)?;

for yoga in yogas.iter().filter(|y| y.strength > 0.7) {
    println!(
        "{} (strength: {:.2}) — {}",
        yoga.name, yoga.strength, yoga.description
    );
    for planet in &yoga.planets_involved {
        println!("  {}", planet);
    }
}

Shadbala — Six-Fold Strength

Shadbala is the classical Vedic system for measuring planetary strength across six independent dimensions. Vedākṣha computes all six and their total, plus Bhava Bala (house strength) for each of the 12 houses.

Sthana Bala

Positional strength: exaltation, own sign, moolatrikona, and other dignities.

Dig Bala

Directional strength. Each planet is strongest in a specific angular house.

Kala Bala

Temporal strength based on time of birth: day/night, hora, paksha, etc.

Chesta Bala

Motional strength. Direct, fast-moving planets score higher. Retrograde adds a different component.

Naisargika Bala

Natural strength. A fixed hierarchy: Sun highest, Moon, Venus, Jupiter, Mercury, Mars, Saturn.

Drig Bala

Aspectual strength. Net gain or loss from benefic and malefic aspects received.

shadbala.rs

let shadbala = compute_shadbala(&chart)?;

for entry in &shadbala.planets {
    println!(
        "{}: total = {:.2} rupas  (sthana={:.2}, dig={:.2}, kala={:.2})",
        entry.body,
        entry.total,
        entry.sthana_bala,
        entry.dig_bala,
        entry.kala_bala,
    );
}

Vedic Drishti (Aspects)

Vedic aspects are house-based, not degree-based. Every planet fully aspects the 7th house from itself. Mars additionally aspects the 4th and 8th, Jupiter the 5th and 9th, and Saturn the 3rd and 10th. Vedākṣha computes both full (100%) and partial aspects with their traditional strength weights.

drishti.rs

let drishti = compute_vedic_drishti(&chart)?;

for aspect in &drishti.aspects {
    println!(
        "{} aspects {} with {:.0}% strength",
        aspect.from_body, aspect.to_body, aspect.strength * 100.0
    );
}

← House Systems·Sidereal Zodiac →