DEV Community: sword luan

GitHub Trending #1 Installed Cleanly, but the Main UI Still Would Not Start

sword luan — Fri, 28 Aug 2026 13:30:21 +0000

Yesterday I tested bilawalsidhu/gods-eye-view, the repository that reached the top of GitHub Trending for the global Today view. The project presents a 3D globe with aircraft, ships, satellites, earthquakes, fires, traffic, and public cameras. The demo is visually convincing. The useful question is whether a new user can install it, verify it, and reach the main experience.

The test was pinned to one commit

I pinned commit b22573a9db28e47c324821ebdd4c67bdb241c0e1 and used Linux, Node.js 24.19.0, and npm 11.9.0. The package requirement accepts Node 24.14.x through 24.x or Node 26.x.

The repository is a real application rather than a static demo. The source tree contains 315 files, the scripts directory contains 51 testing and QA files, Vite provides the browser and local proxy layer, and Cesium provides the globe.

Installation and build

I first ran npm ci --ignore-scripts to inspect the dependency installation boundary. After that completed successfully, I ran the official npm ci. Both runs installed 201 packages successfully.

The root project does not define preinstall, install, or postinstall. Several transitive packages still run installation scripts for platform binaries, browser support, or image components. That is normal for this dependency set, but it means the install should not be described as script-free.

npm audit --omit=dev --json reported zero known production-dependency vulnerabilities. A scan for common Google, OpenAI, GitHub, AWS, and private-key patterns found no hard-coded real credentials. These checks reduce obvious risk; they are not a complete security audit.

The production build exited with code 0. Vite finished in 6.67 seconds and generated about 31 MB across 419 files. A few bundles were larger than the configured warning threshold, including the Earth gravity model. The warnings did not block the build.

The test count needs an honest sentence

The official test command reported 2,587 passing assertions. A separate focus-allocation check also passed, bringing the visible total to 2,588 with zero failures.

The process then stayed alive for more than 90 seconds. I had to interrupt it manually, producing exit code 130. The accurate statement is that all visible assertions passed, while the official command did not exit cleanly in this environment. Those two facts belong together in a report.

The main UI is gated by a billable key

With Google, OpenAI, AISStream, Cesium, TomTom, and FIRMS credentials removed, the HTML shell still returned HTTP 200. Several endpoints returned explicit missing-key responses. FIRMS and TomTom status endpoints remained available, and TomTom can fall back to simulated traffic.

The main application follows a different path. Its initialization checks GOOGLE_MAPS_API_KEY and throws when the key is missing. The core 3D globe therefore cannot start without a Google Maps key. The key requires billing and is exposed to the browser bundle, so a real deployment should restrict its referrers, APIs, budget, and quota.

The repository README makes zero-key operation sound broader than the fixed commit actually allows. Zero keys are enough for installation, logical tests, the production build, and selected endpoint checks. They are not enough to enter the main 3D experience.

Browser QA was blocked by the environment

I also ran the track regression command. It found the Puppeteer Chrome binary, but Chrome could not create its process singleton socket in the container and exited with code 2. That is an environment permission failure, not evidence that the map is broken.

It does mean this run did not verify WebGL rendering, map tiles, drag behavior, target focus, or real-data overlays. Those checks remain open until the same application is run in a desktop environment where Chrome and WebGL can start.

Verdict

God’s Eye View is installable and buildable. Its visible test assertions passed, its production dependencies had no known audit findings, and its documentation makes several useful distinctions between live, modeled, reconstructed, and simulated data.

The core user experience still has a hard first-run condition. Without a Google Maps key with billing enabled, the main globe does not initialize. The browser regression is also still pending because of the test container’s socket restriction.

The complete Chinese experiment record, evidence, and author-claim invitation are collected at Jian AI Lab. The source repository is bilawalsidhu/gods-eye-view.

This is a stage-blocked result, not a failure to collect evidence. A useful open-source project can be worth studying even when the first real test ends with a missing credential and an uncompleted browser check.

I Built GitHub Trending #1. The Code Passed, but the Main UI Still Would Not Start

sword luan — Fri, 28 Aug 2026 00:32:00 +0000

God’s Eye View was the top project on GitHub Trending when we selected it for Jian AI Lab’s daily experiment.

The pitch is immediately compelling. It brings aircraft, vessels, satellites, earthquakes, wildfire data, traffic, CCTV sources, and other feeds into one 3D globe. The repository also makes a serious effort to label data as live, modeled, reconstructed, or simulated.

We tested commit b22573a9db28e47c324821ebdd4c67bdb241c0e1 on Linux with Node.js 24.19.0 and npm 11.9.0.

Installation and security checks

We first ran npm ci --ignore-scripts, reviewed the install-script sources, and then ran the normal npm ci. Both installations succeeded with 201 packages.

The root project has no preinstall, install, or postinstall hook. Transitive install scripts come from esbuild, fsevents, Puppeteer, and sharp.

npm audit --omit=dev reported no known vulnerabilities in production dependencies. A common secret-pattern scan did not find hard-coded live credentials. This is a limited check, not a full source audit.

The project talks to many external services, including Google Maps, OpenAI, OpenSky, AISStream, NASA FIRMS, TomTom, CelesTrak, OSM, Open-Meteo, GDELT, and Radio Browser. It is local-first, but it is not offline.

Server-side keys such as OpenAI and AISStream are read by the local Vite proxy. Google Maps and Cesium tokens are intentionally delivered to the browser. Users must restrict referrers and APIs and set provider budgets and quotas.

2,588 visible assertions passed

The main test suite reported 2,587 passing assertions and zero failures. A separate focus-allocation check added one more passing assertion.

The visible total was 2,588 passes and zero failures.

The process did not exit after the summary. We waited more than 90 seconds and interrupted it manually. The final exit code was 130.

The precise result is that all visible assertions passed, while the official test command did not complete with a clean exit in this environment. This may indicate an open handle, connection, or child process that remains alive after the tests finish.

The production build succeeded

npm run build completed with exit code 0 in 6.67 seconds.

The dist directory contained 419 files and was about 31 MB. Vite reported browser externalization warnings for two Node modules and warned about several bundles larger than 1.5 MB. The warnings did not block the build, but initial-load performance deserves a separate measurement.

The core 3D interface requires a Google Maps key

We cleared the Google, OpenAI, AIS, Cesium, TomTom, and FIRMS environment variables before starting the local server.

The HTML shell returned HTTP 200. Missing-key API routes behaved clearly. OpenAI, Google Places, and AISStream returned explicit 503 responses. FIRMS and TomTom status routes remained available, and traffic can fall back to a simulation without a TomTom key.

The main UI is different. src/main.js checks GOOGLE_MAPS_API_KEY during initialization and throws when it is absent. The interactive globe never becomes available.

The key must have the required Google Maps service enabled and billing turned on. Because it is visible in the browser, it also needs strict referrer and API restrictions plus a budget and quota policy.

Without that key, a user can install the repository, run logic tests, build the production bundle, and inspect several status endpoints. They cannot enter the core photorealistic 3D experience.

Browser and WebGL QA remain incomplete

The repository includes a test:track regression command. After starting the server, the script found Puppeteer’s downloaded Chrome. Chrome then crashed because the current container could not create its process-singleton socket.

The command exited with code 2. This is an execution-environment restriction, not an application assertion failure. It also means we did not verify WebGL, real map tiles, dragging, target focus, or live data accuracy.

Completing that stage requires a desktop environment that can run Chrome and WebGL, plus a billing-enabled Google Maps key with strict restrictions.

Verdict

God’s Eye View has a substantial engineering foundation. Installation and production build succeeded, and 2,588 visible assertions passed with zero failures. The repository is unusually explicit about live, modeled, reconstructed, and simulated data.

The first-run experience still has a significant barrier. A user must configure a billable browser-visible Google Maps key before the core interface appears. A functional OSM first-run mode would let people explore the basic globe and data layers before deciding whether they need photorealistic 3D tiles.

Our status for this experiment is a staged result blocked by external conditions. The code-level evidence is complete. End-to-end visual and live-data validation is not.

Sources

I Put GitHub Trending #1 Through a Real Architecture-Test Workflow

sword luan — Thu, 27 Aug 2026 19:54:08 +0000

GitHub Trending is useful for discovery. It tells you where attention is moving today. It does not tell you whether a project installs cleanly, survives a real task, diagnoses its own failures, or produces an artifact another person can inspect.

That distinction matters because many open-source recommendations stop at the same point. Someone finds a fast-growing repository, repeats the README, runs the official demo, and calls the project “tested.” A demo proves that the happy path exists. It does not prove that the tool can handle your system.

So I took Archify, which ranked first on GitHub Trending's global Today list that day, and put it through the full workflow at Jian AI Lab.

The task was not invented for the test. Archify had to map the real architecture of Jian AI Lab, pass its own validation gates, and deliver an interactive result that a reader could open without an online diagramming service.

The final result passed 9 of 9 showcase checks with zero errors and zero warnings. It took four validation rounds to get there.

What Archify actually does

Archify is a Node.js rendering and validation system designed for coding agents including Codex CLI, Claude Code, Cursor, and OpenCode. An agent produces a typed JSON intermediate representation. Archify then compiles that structured source into deterministic HTML and SVG.

It supports five diagram families.

Architecture diagrams
Workflow diagrams
Sequence diagrams
Data-flow diagrams
Lifecycle diagrams

The output can be a self-contained HTML file with light and dark themes, search, node focus, route tracing, guided views, and export controls. The repository is published under the MIT license.

The important part is the delivery gate. Archify does not treat “an HTML file was generated” as success. Its validators inspect schema, layout, routes, labels, projected text size, and other measurable conditions. A failing candidate returns structured diagnostics instead of silently replacing the last valid artifact.

That was the part I wanted to test.

The real task

Jian AI Lab is a Chinese platform built around a simple workflow. We discover open-source projects, verify their claims, test one project against a real problem, preserve failures and fixes, and turn the result into reusable public material.

The website includes a project library, a live activity arena, personal experiment fields, a harvest area for completed artifacts, member profiles, authentication, community APIs, a database, and media storage.

For this experiment, the architecture model contained 12 components and 11 relationships. The diagram had to communicate the main path through the product without turning into a wall of boxes and crossing lines.

The expected deliverables were also explicit.

A typed architecture JSON file
A machine-readable validation receipt
A self-contained interactive HTML diagram
A repeatable record of every failed and successful run
A public experiment report linked to the final artifact

Environment and first checks

The experiment ran with Node.js v24.19.0.

I began with Archify's environment diagnostic.

node bin/archify.mjs doctor

All 16 checks passed. The official demo also generated successfully.

Those results established that the tool and runtime were available. They did not count as completion because neither command tested the Jian AI Lab architecture.

The real work started when the actual components and relationships were written into the architecture model and validated with the showcase quality profile.

Validation round one — only 5 of 9 checks passed

The first real candidate looked plausible at a glance. The validator rejected it.

Only five of the nine showcase checks passed. Four concrete problems remained.

A route crossed through a node.
One route segment was only 7 pixels long.
A label overlapped another visual element.
Another label had no safe clearance from its route.

This was the most useful moment in the experiment. A conventional image generator could have delivered that diagram because it looked approximately correct. Archify identified the exact local failures and refused to release it as a showcase artifact.

The distinction is practical. If a diagram is used in a product page, architecture review, onboarding document, or technical presentation, a crossing line can imply the wrong dependency. A label placed against the wrong route can change the reader's interpretation. Visual defects can become factual defects.

Rounds two and three — local repairs, not a full rewrite

The next two rounds focused on the diagnosed subjects. I adjusted route geometry, endpoint direction, and label clearance while preserving the rest of the model.

That matters because uncontrolled regeneration is a poor repair strategy. If an agent rebuilds the entire diagram after every warning, unrelated nodes move, valid relationships change, and reviewers lose the ability to compare versions.

Archify's diagnostics made narrower correction possible. Each run reduced the remaining failures without discarding the valid structure.

After the routing and label problems were repaired, one issue remained. The projected minimum font size measured 5.8125 pixels. The showcase threshold was 6 pixels.

The difference was less than two-tenths of a pixel, but the candidate still failed. The validator did not round the result up or quietly treat it as acceptable.

Round four — 9 of 9

The final repair widened the canvas to 1380 pixels. That gave the labels enough projected space without shrinking the content below the readability threshold.

The fourth validation completed with the result we needed.

9 of 9 checks passed
0 errors
0 warnings

The final self-contained HTML file was 713,036 bytes. The JSON source and validation receipt were preserved beside it.

The diagram can be opened locally or from the experiment page. It supports node search, focus, route inspection, view changes, and both light and dark presentation themes.

You can open the interactive Jian AI Lab architecture diagram here.

One check was skipped, and it stayed skipped

Archify also provides an automated visual-check path that requires Chrome or Chromium. That browser was not available in the test environment, so the automatic visual check did not run.

I recorded it as skipped.

I did not convert “could not run” into “passed.” A separate manual browser review checked the light theme, dark theme, labels, controls, and basic interaction. The manual review passed, but it remained separate from the unavailable automated check.

This sounds like a minor reporting choice. It is one of the easiest places for an AI-assisted experiment to become dishonest. If skipped, inferred, and manually inspected results are all displayed with the same green check mark, the report stops being evidence.

The tool test also tested our own website

Running Archify through a real experiment exposed six weaknesses in the Jian AI Lab workflow.

Project states were too vague. A saved project could look similar to a verified or tested project.
Completed artifact files did not have a strong, permanent entry from the experiment record.
Command evidence and validation results were stored too loosely.
The harvest area did not summarize the experiment records automatically enough.
The long-form article could drift away from the evidence collected during the test.
The video package could become detached from the same experiment and repeat unverified claims.

We repaired the workflow so that a project now moves through explicit states.

Discovered → Verified → Tested → Produced

The artifact, report, commands, failures, screenshots, and publication package remain connected to the same experiment. A failed attempt stays in the timeline instead of disappearing after the successful run.

This is why the Archify test became more than a software review. The project revealed defects in the system used to review it.

What I learned from Archify

Archify's main value is not that it can draw a diagram quickly. Many tools can generate a polished diagram from a prompt.

Its stronger idea is validation before delivery.

The typed JSON source makes the diagram reproducible. Deterministic checks make failures measurable. Local diagnostics allow focused repairs. Atomic delivery prevents a broken candidate from replacing the last valid result. The final HTML keeps the artifact portable.

There are still limits.

The agent must model the real system accurately. Validation cannot prove facts that were never supplied.
Automated layout checks do not replace human judgment about emphasis and clarity.
The visual-check feature needs Chrome or Chromium.
Archify is not a WYSIWYG editor or a hosted sharing platform.

For architecture reviews, technical documentation, product explanations, and agent-generated system maps, those limits are reasonable. The project is especially useful when “looks good” is not an acceptable definition of done.

Reproducible outcome

The public experiment includes the failed rounds, repair history, final result, and links back to the original repository.

GitHub Trending helped us find the project. The experiment determined what it could actually do.