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

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, 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 orchestrates the bootstrapping process. It initializes the Cesium environment, configures the Google Photorealistic 3D Tileset, and instantiates the core controllers:

// 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 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 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:

// 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, 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:

// 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 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 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.
• Modular architecture in src/data/*.js isolates data feeds (flights, ships, earthquakes) into independent DataSource layers.
• src/mapStackController.js manages base-map switching and dispatches gev:map-stack-changed events to synchronize layers.
• Voice control via 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 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. 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.

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