# Gods Eye View Dependencies: Complete Tech Stack Analysis of the Geospatial Console

> Analyze the Gods Eye View tech stack. Discover Cesium and satellite.js dependencies for 3D globes and orbital mechanics, plus Vite and Puppeteer development tools.

- Repository: [Bilawal Sidhu/gods-eye-view](https://github.com/bilawalsidhu/gods-eye-view)
- Tags: tech-stack-analysis
- Published: 2026-08-30

---

**The Gods Eye View project utilizes six production dependencies centered on Cesium for 3D globe rendering and satellite.js for orbital mechanics, plus five development tools including Vite and Puppeteer to enable real-time geospatial intelligence workflows.**

The Gods Eye View application developed by `bilawalsidhu` is a browser-based, real-time geospatial intelligence console that renders photorealistic 3D globes and processes live ADS-B/AIS data. Understanding the gods eye view dependencies reveals a deliberately lean architecture separating heavy computational libraries from the build toolchain. The [`package.json`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/package.json) configuration organizes these into runtime libraries for geospatial processing and dev-dependencies for development velocity.

## Runtime Dependencies for 3D Rendering and Geospatial Intelligence

The production bundle defined in [`package.json`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/package.json) (lines 45-51) consists of six specialized libraries handling everything from vector tile parsing to orbital propagation.

### Cesium 3D Engine and Vector Tile Processing

**Cesium** serves as the core 3D globe engine responsible for photorealistic rendering, tile loading, and scene management according to [`package.json`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/package.json) lines 46-47. The application pairs this with **@mapbox/vector-tile** and **pbf** (Protocol Buffer format) to decode compressed vector tile data efficiently. The `pbf` library (line 50) handles binary deserialization while `@mapbox/vector-tile` (lines 45-46) provides the parsing layer for map feature extraction.

```js
import { createApp } from 'vue';
import { Viewer } from 'cesium';
import 'cesium/Build/Cesium/Widgets/widgets.css';
import viteCesium from 'vite-plugin-cesium';

const viewer = new Viewer('cesiumContainer', {
  terrainProvider: Cesium.createWorldTerrain(),
});
createApp(App).mount('#app');

```

### Geodetic Calculations and Coordinate Systems

Three mathematical libraries provide precision geospatial capabilities:

- **egm96-universal**: Implements the Earth Gravity Model 1996 (EGM96) for accurate altitude calculations above the geoid (package.json line 48)
- **mgrs**: Converts between decimal degrees and Military Grid Reference System (MGRS) coordinates used in tactical environments (package.json line 49)
- **satellite.js**: Performs SGP4/SDP4 orbital propagation for real-time satellite position calculations (package.json line 51)

The [`satellite.js`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/satellite.js) integration enables Two-Line Element (TLE) processing:

```js
import * as satellite from 'satellite.js';

const tleLine1 = '1 25544U 98067A   24244.12345678  .00001234  00000-0  34567-4 0  9991';
const tleLine2 = '2 25544  51.6410 123.4567 0001234  45.6789 234.5678 15.51123456 12345';
const satrec = satellite.twoline2satrec(tleLine1, tleLine2);
const now = new Date();
const positionEci = satellite.propagate(satrec, now.getUTCFullYear(),
                                      now.getUTCMonth() + 1, now.getUTCDate(),
                                      now.getUTCHours(), now.getUTCMinutes(),
                                      now.getUTCSeconds());

```

## Development Dependencies and Build Tooling

The development workflow relies on five tools specified in [`package.json`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/package.json) (lines 53-57) optimized for modern frontend build processes and automated testing.

### Vite Build System and Cesium Integration

**Vite** functions as the fast development server and production bundler (line 55), configured in [`vite.config.js`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/vite.config.js) to handle the application's module graph. **vite-plugin-cesium** (line 56) specifically manages Cesium's static assets, Web Workers, and WASM modules that would otherwise require manual copy operations. This integration allows the heavy 3D engine to tree-shake unused components while preserving essential terrain loading capabilities.

### Testing Infrastructure and Real-Time Data

- **puppeteer**: Provides headless Chrome automation for UI testing and screenshot generation (line 53), executed via `scripts/run-unit-tests.mjs`
- **sharp**: High-performance image processing library for resizing terrain textures and tile assets (line 54)
- **ws**: WebSocket implementation enabling real-time ADS-B and AIS data streams for live aircraft and vessel tracking (line 57)

## Implementation in Core Source Files

The gods eye view dependencies directly power specific architectural components identified in the source tree:

- [`src/worldFocus.js`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/src/worldFocus.js): Central orchestration logic focusing the Cesium Viewer on aircraft, ships, and satellites using `mgrs` coordinate transformations
- [`src/weatherEffectsMath.js`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/src/weatherEffectsMath.js): Atmospheric calculation logic combining `egm96-universal` altitude corrections with [`satellite.js`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/satellite.js) orbital mechanics
- [`vite.config.js`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/vite.config.js): Build configuration leveraging `vite-plugin-cesium` to optimize the 45MB+ Cesium library for web delivery
- `scripts/run-unit-tests.mjs`: Test runner utilizing `puppeteer` and `sharp` for visual regression testing of the geospatial interface

Vector tile parsing appears throughout the mapping layer:

```js
import { VectorTile } from '@mapbox/vector-tile';
import { Pbf } from 'pbf';

fetch('tile.pbf')
  .then(r => r.arrayBuffer())
  .then(buffer => {
    const tile = new VectorTile(new Pbf(buffer));
    // Access layers, features, etc.
  });

```

## Summary

- **Cesium** provides the photorealistic 3D globe engine while **@mapbox/vector-tile** and **pbf** handle efficient map data decoding
- **satellite.js**, **egm96-universal**, and **mgrs** deliver military-grade precision for orbital mechanics and coordinate conversions
- **Vite** and **vite-plugin-cesium** optimize the build pipeline for the large geospatial assets
- **Puppeteer** and **Sharp** enable automated visual testing of the real-time interface
- **ws** supports WebSocket connections for streaming live telemetry data
- The architecture demonstrates separation of concerns between rendering engines ([`src/worldFocus.js`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/src/worldFocus.js)) and mathematical computation ([`src/weatherEffectsMath.js`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/src/weatherEffectsMath.js))

## Frequently Asked Questions

### What is the primary 3D rendering engine in the Gods Eye View dependencies?

**Cesium** serves as the core 3D globe engine. According to the `bilawalsidhu/gods-eye-view` source code at [`package.json`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/package.json) lines 46-47, Cesium handles scene management, terrain loading, and photorealistic globe visualization. The `vite-plugin-cesium` development dependency (line 56) specifically manages the integration of Cesium's Web Workers and static assets into the Vite build pipeline.

### How does the project calculate real-time satellite positions?

The application uses **satellite.js** to perform SGP4/SDP4 orbital propagation calculations. As defined in [`package.json`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/package.json) line 51, this library processes Two-Line Element (TLE) data sets to compute real-time positions of satellites. The implementation appears in [`src/weatherEffectsMath.js`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/src/weatherEffectsMath.js) alongside altitude corrections from `egm96-universal` to account for Earth's geoid irregularities.

### Which dependencies handle the real-time aircraft and ship tracking data?

**ws** (WebSocket library) enables the real-time data streams for ADS-B and AIS feeds according to [`package.json`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/package.json) line 57. While the transport layer uses `ws`, the coordinate parsing relies on **mgrs** (line 49) for grid reference conversions and **pbf** (line 50) for binary vector tile decoding of geographic features.

### What testing framework does Gods Eye View use for UI validation?

The project employs **Puppeteer** for headless browser automation and screenshot generation, specified in [`package.json`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/package.json) line 53. The test suite defined in `scripts/run-unit-tests.mjs` orchestrates Puppeteer alongside **Sharp** (line 54) for image processing and texture validation, enabling automated visual regression testing of the 3D geospatial interface.