BioPath Optimizer - Nature-inspired logistics for carbon-neutral deliveries.
BioPath Optimizer: A C++ GUI showing Ant Colony Optimization. It features delivery network maps, fuel cost convergence graphs,param sliders.
ACO parameters: 10 cities, 27 ants, 100 gens, α=1.4, β=2.3
Optimized delivery route connecting 8 cities using ant colony algorithm.
Fuel cost drops from 1090 to 1049 over 85 generations of learning.
Best fuel cost 1049.6 km, 10.9% better than greedy route.
How α, β, and evaporation mimic real ant behavior to reduce CO₂.

Inspiration

We wanted to tackle a problem that is both computationally hard and environmentally urgent. Logistics routing is one of the oldest NP-hard problems in computer science, yet real-world delivery systems still default to naive greedy approaches wasting fuel at a planetary scale.

The inspiration came from biomimicry: the idea that evolution has already solved many of our optimization problems. Ant colonies, with no awareness of the global map, find near-optimal paths purely through local pheromone signaling and emergent collective intelligence. That is a profound algorithmic insight, and it translates directly into a practical engineering solution.

Algo Fest's emphasis on algorithmic excellence alongside real-world impact made this the perfect venue to show that strong computational thinking and environmental responsibility are not in conflict, they can be the same thing.

What it does

Bio Path Optimizer takes a set of delivery locations and finds a near-optimal visiting order-minimizing total route distance (fuel cost) using Ant Colony Optimization.

Users interact with a real-time browser demo: configure the number of cities, ant population, generations, pheromone weight (α), heuristic weight (β), and evaporation rate (ρ), then run the simulation. The interface visualizes the optimized delivery network on a canvas map and plots colony convergence over generations via Chart.js, making the learning process transparent and inspectable.

Under the hood, the same algorithm runs as a compiled C++17 binary, producing benchmark JSON output that validates the web results against independently generated test networks.

How we built it

We built Bio Path in two parallel layers: C++ engine (Areeba): The core ACO algorithm is implemented in C++17 with zero external dependencies. This handles the transition probability calculation $$ P(i→j) = [τ(i,j)^α × η(i,j)^β] / Σ_k [...]$$ the pheromone evaporation-and-reinforcement update cycle, roulette-wheel selection, and benchmark output. Compiling with -O2 optimization, the engine runs full 150-generation simulations in milliseconds.

Web demo (Hifza): The interactive frontend is a standalone index.html-no framework, no build step, no install. HTML5 Canvas renders the delivery network graph; Chart.js renders the live convergence curve. JavaScript re-implements the ACO logic client-side so the simulation runs entirely in the browser, matching the C++ results.

We validated both implementations against identical random seed networks to confirm consistency between the C++ benchmark output and the browser simulation.

Challenges we ran into

The hardest challenge was parameter sensitivity. ACO has three interdependent knobs — α, β, and ρ — and the wrong combination causes the colony to either stagnate (too low evaporation, too high α) or forget good paths too quickly (too high ρ). Finding the default values that consistently outperform greedy routing across different network sizes required systematic empirical testing, not just theory.

A second challenge was making the algorithm's behavior legible to users who haven't studied ACO. The convergence chart was key - watching the colony's best cost curve flatten as it approaches the optimum gives an intuitive sense of the algorithm learning, without requiring any mathematical background.

Accomplishments that we're proud of

We are most proud of the benchmark numbers holding up. A 25% improvement over greedy routing on a 10-city network is not a toy result it is consistent with published ACO literature. Getting that from a clean, zero-dependency C++17 implementation written during a hackathon, and then independently replicating the result in a browser simulation, validated that our algorithmic understanding was sound rather than incidentally correct.

We are also proud of making a graduate-level optimization algorithm accessible to a general audience through the interactive demo-anyone can adjust parameters and immediately see the effect on colony convergence.

What we learned

We deepened our understanding of the exploration-exploitation tradeoff that sits at the heart of most metaheuristic algorithms-how the same tension that makes reinforcement learning hard also governs whether an ant colony finds the global optimum or gets trapped in a local one.

We also learned that the gap between a working prototype and a comprehensible demo is just as important as the algorithm itself. Clear visualization of what the algorithm is doing at each step is what turns a technical solution into a convincing argument.

What's next for Bio Path Optimizer

Scale to real logistics data-integrating live OpenStreetMap coordinates so the optimizer runs against actual city networks rather than randomly generated ones.

Multi-constraint routing-extending the ACO model to handle time windows, vehicle capacity, and multi-depot scenarios, which are the real-world constraints that make logistics routing so difficult.

Carbon tracking dashboard-translating route improvements directly into estimated CO₂ savings in real time, so logistics operators can see the environmental impact of each optimization run.

Slide Deck: https://1drv.ms/p/c/78b7df03f3303eec/IQBALSEG-t-aS45kTyNOUdV_AW_l6A4glUmzJr4N4TvLQsA?e=1mvVVz