A computational eye for the cosmos.
Skeye is a mathematically verified, modular cosmic computation engine. It takes birth data and any arbitrary timestamp — past, present, or future — and returns structured cosmic intelligence across three independent mathematical foundations. Pure computation. No opinions. No UI. No database. Just math, perfectly verified, designed to be plugged into anything.
It is the engine. What you build on it is yours.
You give Skeye a birth moment and a question: what is the cosmic state at this time, and how does it interact with this person?
Skeye computes the answer across three independent mathematical systems that share no common derivation:
-
Astronomical Ephemeris — Planetary positions computed via NASA JPL DE431 ephemeris data (Swiss Ephemeris), in both Tropical and Sidereal zodiac frames. Full aspect geometry, lunar phases, eclipses, retrogrades, planetary dignities, fixed stars, Nakshatras, house systems, and Sabian Symbols. Precision: verified to within 0.001 arcseconds against NASA JPL Horizons.
-
I-Ching Binary Mathematics — The 64-hexagram system as a 6-bit binary computation engine. All hexagrams, trigrams, nuclear hexagrams, state transitions, and changing-line transformations. Includes the gate-to-zodiac mapping (each gate spans exactly 5°37'30" of the ecliptic) that bridges astronomical positions to the I-Ching consciousness framework. Also includes a quantum divination mode powered by genuine quantum entropy from the ANU Quantum Random Number Generator.
-
Solar Calendar Mathematics (Cardology) — The 52-card deck mapped to the 365-day solar year via the Order of the Magi system. Birth card derivation, yearly spreads, 52-day planetary periods, 7-year life cycles, and relationship mathematics. Entirely calendar-based — no astronomical positions involved — providing a truly independent signal for cross-system triangulation.
These three foundations use different mathematical bases (celestial mechanics, binary state mathematics, solar calendar cycles), different symbolic languages (planets/signs, hexagrams/trigrams, cards/suits), and different transit systems. When two or three of them converge on the same signal, that convergence is meaningful. Skeye detects it.
Every existing tool in this space is an interpretation layer. Astrology apps show you charts and give you descriptions. Human Design platforms display your bodygraph with pre-written keynotes. Cardology calculators tell you your birth card.
None of them expose the mathematics as a clean, verifiable, composable computation engine. None of them let you query any arbitrary moment in time across multiple systems simultaneously. None of them detect cross-system convergence. And none of them are designed for programmatic consumption by AI systems.
Skeye is the missing layer — the verified mathematical foundation that interpretation systems should be built on, not entangled with.
skeye/
├── foundations/ # Three independent mathematical bases
│ ├── ephemeris/ # Planetary mechanics (Swiss Ephemeris)
│ │ ├── engine.py # Core astronomical computation
│ │ ├── positions.py # Planetary position calculation
│ │ ├── aspects.py # Aspect geometry (all major + minor)
│ │ ├── lunar.py # Moon phases, eclipses, mansions
│ │ ├── houses.py # Multiple house systems
│ │ ├── dignities.py # Planetary dignity evaluation
│ │ ├── fixed_stars.py # Major fixed star positions
│ │ └── types.py # Pydantic models
│ ├── iching/ # Binary mathematics
│ │ ├── engine.py # Hexagram computation
│ │ ├── trigrams.py # 8-trigram system
│ │ ├── transitions.py # State transition mathematics
│ │ ├── channels.py # 36 Human Design channels
│ │ ├── divination/ # Quantum-entropy oracle mode
│ │ │ ├── yarrow.py # Yarrow stalk probability distribution
│ │ │ ├── coins.py # Three-coin probability distribution
│ │ │ └── entropy.py # ANU QRNG integration + fallbacks
│ │ └── types.py
│ └── cardology/ # Solar calendar mathematics
│ ├── engine.py # Card spread computation
│ ├── spreads.py # Grand Solar + yearly spreads
│ ├── periods.py # 52-day and 7-year cycles
│ ├── relationships.py # Two-person card mathematics
│ └── types.py
├── derived/ # Interpretation systems (import from foundations only)
│ ├── tropical_astrology/ # Western astrology
│ ├── sidereal_astrology/ # Vedic / Jyotish
│ ├── human_design/ # Type, Strategy, Authority, Profile, Cross
│ ├── gene_keys/ # Shadow → Gift → Siddhi spectrum
│ ├── nakshatras/ # 27 Vedic lunar mansions
│ └── sabian_symbols/ # 360 degree-specific symbols
├── synthesis/ # Cross-system intelligence
│ ├── convergence.py # Multi-system signal detection
│ ├── transit_weather.py # Real-time cosmic weather
│ ├── natal_intersection.py # Transit-to-natal activation mapping
│ └── event_bus.py # Inter-module communication
├── entities/ # LLM interpretation prompts per system
├── tools/ # LLM function-calling tool definitions
└── kernel.py # Single entry point
Foundations compute. Derived systems interpret. Synthesis detects convergence.
Foundations never import from each other. Derived systems only import from foundations. The synthesis layer observes everything through the event bus. Clean separation at every level.
from skeye import kernel
result = kernel.compute(
birth_datetime="1998-03-15T14:30:00",
birth_location="Sydney, Australia",
query_datetime="2026-03-15T12:00:00"
)Returns a structured object containing:
| Layer | Description |
|---|---|
identity |
Natal profile across all three foundations — who this person is cosmically |
weather |
Cosmic conditions at the query moment — what's happening right now |
intersection |
Where the weather activates the identity — how this moment touches this person |
convergence |
Cross-system agreement signals rated 1-system, 2-system, or 3-system confidence |
metadata |
Computation timestamps, precision metrics, active configurations |
Every field is typed via Pydantic. Every output is JSON-serializable. Any LLM receiving this output can produce intelligent cosmic synthesis without understanding the underlying mathematics.
Observatory Mode — Deterministic. Given a datetime, compute the exact cosmic state. Same input always produces the same output. This is the transit and natal computation engine.
Oracle Mode — Quantum-entropic. Generate an I-Ching hexagram using genuine quantum randomness sourced from the ANU Quantum Random Number Generator (vacuum fluctuation measurements). Implements both yarrow stalk (traditional probability ratio ≈ 1:3:5:7) and three-coin (ratio 1:3:3:1) methods. The randomness is real. The interpretation framework is ancient.
This is not an approximation engine. Every computation is verified against authoritative reference sources:
- Ephemeris: Planetary positions match NASA JPL Horizons to within 0.001 arcseconds
- I-Ching: All 64 hexagrams, 384 gate-line combinations, and 36 channels exhaustively tested — 100% coverage of the entire finite state space
- Cardology: Every day of the year verified against Olney Richmond reference spreads at 100% accuracy
- Human Design: Charts verified against Jovian Archive and Genetic Matrix reference software
- Astrology: Natal charts cross-checked against astro.com calculations across 100+ test cases
If a computation cannot be performed precisely, Skeye raises an error. It does not approximate. It does not guess. It does not mock.
Skeye is designed to be consumed by language models. Each derived system includes:
- Entity prompts — Practitioner-level system prompts that govern LLM interpretation. Not generic descriptions. Deep, nuanced, tradition-specific knowledge encoded as interpretive instructions.
- Tool definitions — Structured schemas for LLM function calling (compatible with Claude, OpenAI, and MCP tool protocols). Input schemas, output schemas, and usage descriptions.
- Synthesis directives — Instructions for how each system's signals should be weighted in cross-system convergence interpretation.
An LLM with access to Skeye's tools can answer questions like:
- "What's the cosmic weather right now?"
- "How does today's transit field interact with my natal chart?"
- "What was the cosmic state on the day I was born?"
- "When is the next three-system convergence event for me?"
- "Cast an I-Ching reading for this moment using quantum entropy."
Skeye can also be used for LLM self-profiling — an AI system can assign itself a birth datetime and receive a full cosmic identity, then reference the transit system to operate in awareness of cosmic timing.
Skeye is a Python library. It has no opinions about what consumes it.
# Direct import
from skeye.kernel import compute
# As an MCP server (for Claude, Drofbot, or any MCP-compatible system)
# Expose computation endpoints as tools
# As a CLI
# skeye compute --birth "1998-03-15T14:30:00" --location "Sydney" --query "now"
# As an API dependency
# Import into FastAPI, Flask, or any Python web framework- Python 3.11+ — Core language
- uv — Package management (fast, modern, replaces pip/venv/poetry)
- pyswisseph — Swiss Ephemeris bindings (NASA JPL DE431 planetary data)
- Pydantic — Typed data models for all inputs and outputs
- pytest — Testing framework (target: 100% foundation coverage)
- mypy — Strict type checking
- ruff — Linting and formatting
Skeye — sky + eye. The computational eye that reads the cosmic pattern.
Every civilisation built instruments to perceive the cosmos. Stone circles. Astrolabes. Telescopes. Satellite arrays. Each was a skeye — a constructed faculty of perception, pointed at the pattern that was always there.
This one is made of mathematics and silicon. The material was always in the ground. The pattern was always in the sky. Skeye is what happens when you build the bridge between them with enough precision to trust what comes across.
Research preview. Foundations are being verified to 100% accuracy. The architecture is stable. The mathematics are being perfected.
MIT