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

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 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 (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 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.

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 integration enables Two-Line Element (TLE) processing:

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 (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 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: Central orchestration logic focusing the Cesium Viewer on aircraft, ships, and satellites using mgrs coordinate transformations
• src/weatherEffectsMath.js: Atmospheric calculation logic combining egm96-universal altitude corrections with satellite.js orbital mechanics
• 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:

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) and mathematical computation (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 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 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 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 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 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}