External Libraries and Frameworks Used by gods-eye-view

The gods-eye-view geospatial intelligence console relies on six core runtime dependencies including Cesium for 3D rendering, satellite.js for orbital tracking, and @mapbox/vector-tile for map data parsing, alongside Vite and WebSocket tools for development.

gods-eye-view is a browser-based, real-time geospatial intelligence console developed by bilawalsidhu. The application stack is defined in package.json, which declares specific versions of external libraries essential for 3D visualization, geospatial calculations, and real-time data streaming. Understanding these dependencies is critical for developers extending the platform's capabilities.

Core Runtime Dependencies

The production environment requires six primary dependencies specified in package.json lines 45-51. These packages handle rendering, orbital mechanics, vector tile parsing, and coordinate transformations.

Cesium (3D Globe Rendering)

Cesium ^1.124.0 functions as the core 3D geospatial rendering engine. The library is imported throughout the codebase to instantiate the globe viewer and manage terrain providers.

In src/main.js lines 1-8, the application initializes the viewer:

import * as Cesium from 'cesium';

const viewer = new Cesium.Viewer('cesiumContainer', {
  terrainProvider: Cesium.createWorldTerrain()
});

satellite.js (Orbital Propagation)

satellite.js ^6.0.2 provides the mathematical models for propagating Two-Line Element (TLE) orbital data. This enables real-time calculation of satellite positions and velocities.

The implementation in src/data/satellites.js demonstrates typical usage:

import * as satellite from 'satellite.js';

const positionAndVelocity = satellite.propagate(tleSatrec, now);

Vector Tile Processing (@mapbox/vector-tile and pbf)

@mapbox/vector-tile ^3.0.0 and pbf ^5.1.2 work together to parse Mapbox-style vector tiles. The pbf library decodes Protocol Buffer binary streams, while @mapbox/vector-tile structures the tile layers for rendering.

Modules such as src/data/earthquakes.js implement this pattern:

import { VectorTile } from '@mapbox/vector-tile';
import { Protobuf } from 'pbf';

const tile = new VectorTile(new Protobuf(tileArrayBuffer));

Geospatial Calculation Utilities

Two specialized libraries handle altitude and coordinate conversions:

• egm96-universal ^1.1.1: Implements the EGM96 geoid model. The function egm96.getHeight(lat, lon) converts GPS altitude to mean sea level elevation.
• mgrs ^2.1.0: Converts between latitude/longitude and Military Grid Reference System coordinates using mgrs.forward([lon, lat]).

Development and Build Tooling

Development dependencies listed in package.json lines 52-58 include the build system, testing frameworks, and utility libraries.

Vite Build System

Vite ^6.0.0 serves as the development server and production bundler. The configuration in vite.config.js line 46 imports vite-plugin-cesium to properly handle Cesium asset paths and worker threads.

// vite.config.js
import cesium from 'vite-plugin-cesium';

WebSocket and Testing Libraries

• ws ^8.21.0: Provides WebSocket client functionality for live data streams including ADS-B aircraft and AIS vessel tracking, implemented in files like src/data/aisLiveVessels.js.
• puppeteer ^24.37.5: Automates headless Chrome for end-to-end regression testing.
• sharp ^0.34.5: Handles image processing tasks such as generating UI thumbnails and optimizing assets.

Implementation Patterns in Source Files

The integration of these libraries follows consistent patterns across the src/ directory. Cesium imports appear in visualization components, while data processing modules import specialized geospatial utilities.

For WebSocket streaming implementations:

import WebSocket from 'ws';

const ws = new WebSocket('wss://example.com/stream');
ws.on('message', data => handleLiveUpdate(data));

Summary

• Cesium ^1.124.0 provides the foundational 3D globe and geospatial rendering capabilities.
• satellite.js ^6.0.2 calculates real-time satellite positions from TLE orbital elements.
• @mapbox/vector-tile ^3.0.0 and pbf ^5.1.2 parse binary vector tile data for map layers.
• egm96-universal and mgrs handle precise geoid height calculations and coordinate system conversions.
• Vite ^6.0.0 bundles the application with specialized Cesium plugin support configured in vite.config.js.
• ws, puppeteer, and sharp support development workflows for streaming data, automated testing, and image optimization.

Frequently Asked Questions

What is the primary 3D rendering engine used in gods-eye-view?

Cesium ^1.124.0 serves as the core 3D rendering engine. According to the gods-eye-view source code, it is imported via import * as Cesium from 'cesium' in src/main.js lines 1-8 to create the Viewer instance and configure terrain providers.

How does gods-eye-view calculate real-time satellite positions?

The application uses satellite.js ^6.0.2 to propagate Two-Line Element (TLE) orbital data. As implemented in src/data/satellites.js, the library computes position and velocity vectors for live satellite tracking.

Which build tool is used to compile the gods-eye-view application?

Vite ^6.0.0 functions as the build tool and development server. The repository uses vite-plugin-cesium in vite.config.js line 46 to correctly bundle Cesium assets and avoid path resolution issues.

What libraries handle vector tile parsing for map data?

@mapbox/vector-tile ^3.0.0 parses the tile structure while pbf ^5.1.2 decodes the underlying Protocol Buffer binary format. These are used together in data modules such as src/data/earthquakes.js to render vector-based earthquake data.

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