Back to browse
GitHub Repository

Central hub of the GSL Engine: Extreme-scale, deterministic VRP optimization (CVRP, VRPTW, MDVRP, MDVRPTW) executed entirely on mobile architecture.

0 stars

I built a deterministic 10k-node VRP solver on a $100 phone

by CTSuwan·Apr 25, 2026·2 points·0 comments

AI Analysis

●●●BangerWizardryDark HorseBold Bet

Runs 10k-node VRP solves in seconds on a $100 Android phone, beating legacy systems.

Strengths
  • Solves 10,000-node MDVRP instances in 8.9 seconds on mobile hardware.
  • Real-world benchmark shows 31.4% cost reduction vs existing legacy system.
  • Built entirely without CS degree using standard Python on Android.
Weaknesses
  • Lacks academic peer review despite bold performance claims on NP-hard problems.
  • Python on mobile struggles with integration compared to standard C++ solvers.
Target Audience

Logistics companies, operations researchers

Similar To

Google OR-Tools · VROOM · OptaPlanner

Post Description

A few years ago, I was a delivery driver in Bangkok. I saw firsthand how inefficient algorithms stressed out drivers. At that time, I didn't even know what "NP-hard" meant—I just knew the system could be better. So, I started building.

The Journey of an Outsider: I have no CS background. I hold a vocational diploma in Goldsmithing from 20 years ago. Before this, I was unemployed and had no PC. My only tool was a $100 Android smartphone (3,000 THB).

I spent 16 hours a day architecting the logic via Pydroid 3. Because I didn't know standard optimization libraries existed, I designed my own deterministic logic architecture from the ground up. I just thought that was how software was built.

The Technical Skepticism: When I shared my work locally, the skepticism was purely technical. People couldn't believe a standard Snapdragon environment could solve 10,000-node VRP instances without runtime explosions, doubting mobile hardware could handle an NP-hard problem of this scale.

The Result: By relying purely on deterministic, axiomatic logic rather than standard metaheuristics, the engine (GSL Solver) now handles up to 10,000 nodes with stable execution across standard benchmarks (CVRP, VRPTW, MDVRP).

I’ve kept the benchmark outputs transparent for inspection: https://github.com/CT1-deMo-goG/CT1-deMo-goG

You can run the live deterministic engine here: https://gsl-solver.com

P.S. Even the front-end website was built entirely on that same smartphone using Acode. I'd love to hear your thoughts on the architectural approach of building solvers entirely from scratch without standard libraries.

Similar Projects