Shipyard Solver Lab

Reproducible optimization workbench for packing shipyard blocks.

Comment

Inspiration

Optimization challenges are not won by a beautiful UI alone. They are won by a fast, honest loop: load the instance, generate a valid solution, score it, inspect what failed, improve the algorithm, and document the method.

Shipyard Solver Lab is my preparation workbench for Optimization Grand Challenge 2026. The official problem is about packing and scheduling shipyard blocks under constraints. Before the official data is released, I built the repeatable solver pipeline I will need once the real competition begins.

What it does

The current version runs on a toy local instance and demonstrates the full loop:

  • load shipyard yards and blocks
  • build a baseline placement solution
  • run beam search candidates
  • validate boundaries and overlaps
  • score coverage, utilization, lateness, and unplaced blocks
  • generate solution JSON
  • generate a technical report draft
  • run a 1,051-candidate benchmark archive
  • keep the best sample solution
  • show the score improvement over the baseline
  • visualize the solution in a browser dashboard

The benchmark validates 1,051 candidates on the current toy instance. The best beam-search run scores 1297.33, compared with the baseline score of 1274.36, a +22.97 point improvement.

I also added an official-schema readiness step after checking optichallenge.com. The script downloads the public OGC baseline package, reads the official example file example_B2_b10.json, projects its polygon/layer block geometry into this lab's rectangle model, and runs the beam solver. On that projection, the beam run scores 1204.76 versus a baseline projection score of 1195.74, a +9.02 point delta.

That projection is not official scoring. It is a smoke test proving that the workbench can ingest the official-style example and produce an internal validated search run while keeping the public claim boundary honest.

The latest build also runs an exact official-checker smoke test. It creates a conservative official operations-format solution and verifies it with the public OGC feasibility checker. The smoke solution passes feasible=true at stage 5. Its objective is intentionally poor because only one block is present at a time; the purpose is to prove format integration before replacing the placeholder with an optimized official-format algorithm.

The newest build adds that first optimized official-format candidate. The file official_submission/myalgorithm.py wraps the public greedy baseline with a bay-assignment portfolio search, checks each candidate with the official feasibility checker, and keeps the best feasible result. On the public example_B2_b10 instance, it improves the official checker objective from 1055.73 to 1022.70, a 33.03 point improvement over the public greedy reference. Because this public example has only 10 blocks and 2 bays, the smoke test enumerates all 1,024 bay assignments and verifies that the candidate matches the static assignment lower bound. This is not leaderboard evidence; it is a checker-validated improvement on the public example.

I also added an official-platform candidate package builder. It creates outputs/official_submission_candidate.zip with myalgorithm.py at the archive root, plus a manifest with hashes. The package is not submitted yet; it is a readiness artifact for when the official platform opens.

How I built it

The solver is written in Python. It includes a baseline, multi-start constructive search, and a beam search that keeps multiple partial layouts at each block step. Candidate placements use contact points, rotation, yard reassignment, boundary checks, overlap validation, and compactness-aware ranking.

The browser dashboard reads generated JSON artifacts and visualizes the best solution. It also displays the run boundary, benchmark count, baseline improvement, best solver name, and placement table.

Challenges

The hardest design choice was not to pretend this is already an official contest result. The official OGC 2026 problem files are not included in this repository yet. This public build proves the reproducible loop on toy data so the loader and scorer can be adapted quickly when the official platform opens.

Accomplishments

  • Built a complete solver, validator, scorer, benchmark archive, dashboard, and report generator.
  • Added beam search with contact-point placements and compactness-aware ranking.
  • Validated 1,051 candidates on the sample instance.
  • Improved the sample score by +22.97 over baseline.
  • Added official OGC baseline-example ingestion via example_B2_b10.json.
  • Produced a +9.02 projection delta on the official example projection, without claiming official scoring.
  • Added exact official-checker smoke proof: feasible=true, stage 5.
  • Added official-format portfolio candidate: feasible=true, objective 1022.70 vs greedy 1055.73 on public example_B2_b10.
  • Verified the candidate matches the static assignment lower bound after enumerating all 1,024 bay assignments on the public example.
  • Built a candidate official submission zip with myalgorithm.py at the archive root.
  • Published a live dashboard, source repo, screenshot, and submission package.
  • Kept the claim boundary explicit.

Public links

What's next

  • Generalize the candidate official algorithm against official training instances.
  • Add relocate, swap, rotate, and yard reassignment local-search moves on top of checker-feasible official solutions.
  • Add time-window and resource constraints once official rules are known.
  • Archive best official runs by seed and score.
  • Generate the final technical report from official benchmark evidence only.

Built With

  • algorithm-engineering
  • beam-search
  • benchmark
  • github
  • optimization
  • playwright
  • python
  • shipyard
  • shipyard-logistics
Share this project:

Updates