# What Is the God's Eye View Project? A Browser-Based OSINT Simulator

> Explore the Gods Eye View project, a browser-based OSINT simulator that visualizes live data like flight telemetry, satellite orbits, and earthquakes on a 3D globe.

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

---

**God's Eye View is an open-source, browser-based "spy-satellite" simulator that aggregates live public data streams—flight telemetry, maritime AIS, satellite orbits, and earthquakes—into a photorealistic 3D globe using CesiumJS and Google Photorealistic 3D Tiles.**

The God's Eye View project transforms disparate open-source intelligence (OSINT) signals into a cohesive, interactive visualization platform. Built as a fully client-side application with no backend infrastructure, it enables users to explore real-time global data feeds directly in their browser while keeping API keys local and secure.

## Core Architecture and Design Philosophy

The project functions as a **single-page web application** where the `Cesium.Viewer` serves as the central rendering context. According to the source code in [`src/main.js`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/src/main.js), the initialization sequence injects the Google Maps API key, instantiates the photorealistic 3D tileset, and wires up supplementary systems such as the `StyleManager` and `MapStackController`.

The architecture emphasizes **modular data layers**. Each live feed—whether flight tracking from the OpenSky Network, maritime AIS data, or USGS earthquake reports—resides in its own encapsulated module under `src/data/`. These layers register themselves with the main viewer and handle independent polling cycles, allowing the application to ingest multiple concurrent public APIs without tight coupling.

### Bootstrapping the Viewer

The entry point in [`src/main.js`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/src/main.js) orchestrates the bootstrapping process. It initializes the Cesium environment, configures the **Google Photorealistic 3D Tileset**, and instantiates the core controllers:

```javascript
// src/main.js
import * as Cesium from 'cesium';
import { StyleManager } from './ui.js';
import { MapStackController } from './mapStackController.js';

async function init() {
  const googleApiKey = import.meta.env.GOOGLE_MAPS_API_KEY;
  Cesium.GoogleMaps.defaultApiKey = googleApiKey;
  
  const viewer = new Cesium.Viewer('cesiumContainer', { /* minimal UI */ });
  const tileset = await Cesium.createGooglePhotorealistic3DTileset();
  viewer.scene.primitives.add(tileset);

  const mapStack = new MapStackController(viewer, { googleTileset: tileset });
  await mapStack.setStack('photoreal', { silent: true });
  
  new StyleManager(viewer, { mapStackController: mapStack });
}
init();

```

This sequence establishes the rendering foundation before any live data layers activate.

### Map Stack Controller

The [`src/mapStackController.js`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/src/mapStackController.js) module abstracts map source switching between Google Photorealistic tiles and alternatives like OSM or Bing. It emits a custom `gev:map-stack-changed` event to synchronize all active layers when the base map changes, ensuring that flight tracks, ship positions, and other overlays remain properly georeferenced regardless of the underlying imagery.

## Live Data Layer Implementation

Each OSINT feed implements a consistent interface extending Cesium's `DataSource`. The project's modular design allows layers to fetch public API data, transform coordinates into Cesium entities, and manage their own update intervals.

### Flight Tracking with OpenSky Network

The aviation layer in [`src/data/flights.js`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/src/data/flights.js) demonstrates the standard pattern for ingesting live telemetry. It polls the OpenSky Network API for ADS-B data and instantiates entities that users can click to inspect aircraft telemetry:

```javascript
// src/data/flights.js
import { DataSource } from 'cesium';

export default class FlightsLayer {
  constructor(viewer) {
    this.viewer = viewer;
    this.source = new DataSource();
    viewer.dataSources.add(this.source);
  }
  
  async startPolling() {
    const data = await fetch('https://opensky-network.org/api/states');
    const positions = await data.json();
    // Create Cesium entities from live positions
  }
}

```

### Additional Public Data Streams

Beyond aviation, the project ingests multiple live feeds:
- **Maritime AIS** via AISStream for ship positioning and navigation status
- **Seismic activity** from USGS earthquake feeds with magnitude filtering
- **Traffic congestion** data via TomTom APIs visualized on road networks
- **Public camera feeds** (CCTV) projected as video textures into the 3D scene
- **Satellite orbits** for space situational awareness and tracking

Each module follows the same encapsulation pattern, registering with the main viewer through `viewer.dataSources.add()` and responding to the `gev:map-stack-changed` event to maintain synchronization.

## Voice-Controlled AI Integration

The God's Eye View project integrates an optional **voice interface** that connects to OpenAI's API for natural language interaction. Located in [`src/voice/gevRealtime.js`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/src/voice/gevRealtime.js), this system captures speech through the browser's Web Speech API, sends transcripts to OpenAI for intent parsing, and executes commands such as camera movements or data queries.

Users can ask contextual questions like "How many flights are over Texas?" or issue navigation commands such as "Take me to LAX." The implementation requires a user-provided OpenAI API key and routes responses through the `executeGevCommand` function:

```javascript
// src/voice/gevRealtime.js
async function initGevVoiceCommands() {
  const micBtn = document.getElementById('gev-mic');
  micBtn.addEventListener('click', async () => {
    const transcript = await startSpeechRecognition();
    const response = await fetch('/api/openai', {
      method: 'POST',
      body: JSON.stringify({ prompt: transcript })
    });
    const { command } = await response.json();
    executeGevCommand(command);
  });
}

```

## Performance Optimization and User Experience

To maintain responsiveness while tracking hundreds of simultaneous moving entities, [`src/renderGovernor.js`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/src/renderGovernor.js) caps the Cesium render loop at **60 frames per second**. This prevents unnecessary GPU and CPU consumption on high-refresh-rate displays, ensuring the application remains usable on consumer hardware.

The project also includes [`src/firstRunExperience.js`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/src/firstRunExperience.js) to guide new users through the interface, explaining how to switch between the global overview mode and **"cockpit view"**—a perspective that rides inside tracked flights with sensor-style overlays (NVG, FLIR, CRT) for immersive reconnaissance simulation.

## Summary

- **God's Eye View** is a browser-based OSINT simulator aggregating public data into an interactive 3D globe without requiring classified credentials.
- The **CesiumJS** engine renders **Google Photorealistic 3D Tiles** as the base map, initialized in [`src/main.js`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/src/main.js).
- **Modular architecture** in `src/data/*.js` isolates data feeds (flights, ships, earthquakes) into independent `DataSource` layers.
- **[`src/mapStackController.js`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/src/mapStackController.js)** manages base-map switching and dispatches `gev:map-stack-changed` events to synchronize layers.
- **Voice control** via [`src/voice/gevRealtime.js`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/src/voice/gevRealtime.js) enables OpenAI-powered natural language queries and camera control.
- All processing occurs client-side, with API keys remaining local to the browser and no backend exposure of secrets.

## Frequently Asked Questions

### What data sources does the God's Eye View project use?

The project consumes entirely public-domain APIs including the OpenSky Network for aircraft ADS-B telemetry, AISStream for maritime tracking, USGS for seismic data, and TomTom for traffic congestion. All feeds are unclassified and accessible without special credentials, though some data providers require free API registration.

### Is the God's Eye View project completely client-side?

Yes. The application runs entirely in the browser without a backend server that could expose secrets. Users provide their own API keys (Google Maps, OpenAI, etc.) which remain local to their browser session, and all data fetching occurs directly from the client to public API endpoints.

### How does the voice assistant work in the God's Eye View project?

The voice interface in [`src/voice/gevRealtime.js`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/src/voice/gevRealtime.js) uses the browser's native Web Speech API to capture audio, then sends transcripts to OpenAI's API for processing. The system parses natural language commands to control the camera, filter data layers, or answer quantitative questions about visible entities, though it requires a valid OpenAI API key to function.

### Can I extend the project with custom data layers?

Absolutely. The modular architecture allows developers to create new classes following the pattern established in [`src/data/flights.js`](https://github.com/bilawalsidhu/gods-eye-view/blob/main/src/data/flights.js). By extending Cesium's `DataSource` and implementing a `startPolling` method, custom layers can fetch any public API and render entities into the same 3D scene, automatically integrating with the `MapStackController` event system.