Vedaksha for Python — Vedic astrology & ephemeris

The clean-room Vedaksha Vedic-astronomy and Jyotish engine, runnable from Python with no Rust toolchain and no per-platform build. Compute kundali / janam kundali (natal charts), panchanga, vimshottari and other dashas, nakshatras, vargas (divisional charts), shadbala, ashtakavarga, muhurta, and transits / gochara — from a sub-arcsecond ephemeris (VSOP87A, ELP/MPP02, JPL DE440s/DE441).

This package is not a reimplementation. It ships the real Rust engine compiled to WebAssembly and runs it via wasmtime. Every value it returns is the Rust engine's own — verified bit-for-bit against the native build, including the sub-arcsecond JPL ephemeris tier. Because the engine is a single architecture-independent .wasm blob, one py3-none-any wheel works on every OS and CPU wasmtime supports (Linux glibc/musl, macOS, Windows, Android — x86-64 and arm64), on any Python ≥ 3.9.

Install

pip install vedaksha

Library

from vedaksha import Vedaksha

vk = Vedaksha()

# Every engine tool is available; the catalog is the engine's own.
for tool in vk.list_tools():
    print(tool["name"])

# Typed wrapper for a natal chart / kundali (analytical ephemeris tier).
# Every Julian Day on the tool surface is UT1 (Universal Time) — not TT, not
# TDB. The engine converts to TT internally for the dynamical terms and uses
# UT1 directly for the Earth's rotation, which sets the ascendant and all
# twelve house cusps; passing TDB rotates every cusp by ~0.29 degrees.
chart = vk.natal_chart(julian_day=2451545.0, latitude=28.6139, longitude=77.2090)

# Every tool is callable by name — inspect its inputs with list_tools():
vargas = vk.call_tool("compute_vargas", julian_day=2451545.0,
                      latitude=28.6, longitude=77.2, divisions=["D9"])
# compute_panchanga needs an observer: the vara (weekday) is reckoned from
# LOCAL SUNRISE, so latitude and longitude are required, and elevation_m /
# tz_offset_minutes refine which sunrise and what it is called.
panchanga = vk.call_tool("compute_panchanga", jd=2451545.0, sun=280.0, moon=120.4,
                         latitude=28.6139, longitude=77.2090,
                         elevation_m=216.0, tz_offset_minutes=330)
dasha = vk.call_tool("compute_dasha", birth_jd=2451545.0, moon_longitude=120.4)

Sub-arcsecond positions (SPK tier)

The tool surface uses the built-in analytical ephemeris (< 25″ planets, < 1″ Moon), which needs no data files. For sub-arcsecond accuracy, supply a JPL DE440s kernel:

with open("de440s.bsp", "rb") as f:
    vk.load_ephemeris(f.read())

# NOTE: this one Julian Day is TDB, not UT1. It is a raw SPK segment query —
# the kernel's coefficients are tabulated against TDB and no Delta T
# conversion is applied on this path.
vk.state_vector("moon", julian_day=2451545.0)
# {'x': ..., 'y': ..., 'z': ..., 'vx': ..., 'vy': ..., 'vz': ...}  # AU, ICRS

Command line

vedaksha tools
vedaksha chart --julian-day 2451545.0 --latitude 28.6 --longitude 77.2
vedaksha call compute_vargas --args '{"julian_day":2451545.0,"latitude":28.6,"longitude":77.2}'

MCP server

Self-host the engine as a Model Context Protocol server — the original motivation for this package, since it needs no Rust toolchain anywhere. Three equivalent ways to start it over stdio:

uvx vedaksha mcp      # no install — what the MCP Registry launches
vedaksha-mcp          # after `pip install vedaksha`
python -m vedaksha.mcp

HTTP is available from the python -m form only, with bearer-token auth on by default:

VEDAKSHA_MCP_TOKEN=secret python -m vedaksha.mcp --http --port 3100

Unlike the Rust engine's HTTP server, this one requires auth by default and binds to 127.0.0.1; pass --insecure-no-auth and --host 0.0.0.0 only behind a trusted boundary.

REST (optional)

pip install "vedaksha[rest]"
python -m vedaksha.rest      # FastAPI app; each tool is POST /v1/<tool_name>

Licensing

Business Source License 1.1, identical terms to the Rust engine. Production deployment is a commercial use — confirm your commercial licence before go-live.

How it relates to the Rust engine

The Rust engine at arthiqlabs/vedaksha is normative. This package pins a specific engine commit, compiles it to wasm, and ships the blob. Version numbers track the engine. See docs/ for the design and the SPK-over-wasm validation.