Pack-a-Bunch

Pack a Bunch is a smart Android app for packing tight, awkward or almost any spaces like car boots. Scan your space, add/scan items, and follow a 3D guide showing exactly what fits and where it goes.

Comment

Inspiration

The spark for Pack-a-Bunch came during a postgraduate research trip. While struggling to pack the back of a bakkie (pickup truck) under the blazing sun, my supervisor jokingly remarked, "Why can't we just magically poof it packs itself like Tetris?" Finding a way to make everything fit efficiently was incredibly frustrating, and that exact comment ignited the idea. I wanted to take the spatial puzzle of Tetris and apply it directly to real-world loading, moving, and packing headaches.

What it does

Pack-a-Bunch takes the stressful guesswork out of arranging objects into tight physical zones.

  1. Space Mapping: Scan irregular volumes, such as a car boot with awkward wheel arches or a cupboard with built-in shelving via your device's camera, or manually input physical internal dimensions.
  2. Item Library: Log the items you need to pack by adding names, dimensions, quantities, stacking limits, and allowable rotations.
  3. Deterministic Solver: A custom pure Kotlin heuristic engine calculates a logical layout arrangement. Instead of giving confusing optimization scores, it reports clean, modeled fill volume and states exactly what could not fit and why.
  4. Visual Packing Guide: Walks users through a physical layer-by-layer arrangement via an elegant, native 3D isometric interface, showing you exactly what piece goes where from the bottom up.

How I built it

Pack-a-Bunch is designed with a strict layer separation to maximize speed, portability, and native UI consistency:

  • UI & Frontend: Built natively using Kotlin, Jetpack Compose, and Material 3. Custom motion design tokens and high-fidelity animations were modeled in Figma and rendered smoothly using Lottie.
  • Core Logic Engine: A highly performant, unit-testable Pure Kotlin module completely isolated from Android framework dependencies. Lengths are processed strictly as integer millimeters.
  • Computer Vision Hybrid Stack: A local Python engine running NumPy and OpenCV embedded directly on the mobile device via Chaquopy. It parses ML Kit object bounds and ARCore spatial anchors to map object depth surfaces and identify physical dimensions.
  • Data & Infrastructure: Powered by Supabase Auth and a PostgreSQL cloud backend, alongside local Room database synchronization.
  • Monetization & Frameworks: Integrated via the RevenueCat SDK to handle tiered free/premium boundaries alongside native Google Pay Billing integrations.

Challenges I ran into

The absolute toughest hurdle was overcoming camera-scanning imprecision. Translating raw physical spaces and uneven item depths into clean mathematical bounds proved notoriously difficult. Initial camera-based dimension estimations were inaccurate and fell far short of the pixel-perfect layouts I had structured on my Figma artboards.

To conquer this, I engineered a robust fallback system: the app enforces a persistent manual dimensions input flow that is never hidden from the user, and the architecture catches Python/Chaquopy scanning anomalies gracefully by shifting dynamically to the Kotlin ScanMath.kt local module.

Accomplishments that I'm proud of

  • High-Fidelity UI Motion: Creating highly responsive, well-received interface animations on my very first attempt.
  • Algorithmic Craft: Building an isolated, high-speed spatial heuristic engine that operates independently of the platform UI and behaves identically regardless of user subscription tiers.
  • Asset Modeling: Spending grueling, dedicated hours modeling 3D representations for every conceivable daily object I had th time to model so that the user's packing guide renders realistic, easily recognizable canvas shapes.

What I learned

This project pushed me far past the boundaries of a traditional designer. I learned how to move beyond static layouts into fully responsive animation generation in Figma. On the technical side, I significantly expanded my mobile system knowledge by figuring out how to successfully interface a localized Python data-science pipeline (Chaquopy, OpenCV, NumPy) right inside a native Kotlin Android structure.

What's next for Pack-a-Bunch

  • Global App Market Launch: Successfully publishing the production build directly onto the Google Play Store to help everyday people solve real-life packing struggles.
  • Cross-Platform Portability: Rewriting the frontend architecture into a multiplatform format to deploy a native iOS version.
  • Bypassing Spatial Roadblocks: Replacing the ARCore layer with an independent, universally compatible spatial measuring method that functions fluidly on older, lower-spec mobile devices without hardware barriers.
  • Scaling Infrastructure: Expanding the backend cloud database architecture to handle high-concurrency automated sync states for extensive user asset libraries.
  • Recognizable Space Modeling: Expanding the 3D library to include fully recognizable environment templates and structures, allowing the packing guide to perfectly mirror specific, real-world spaces.
  • Advanced Gap Optimization: Refining the algorithmic solver to support hyper-dense, gap-filling calculations that push space utility to its absolute limit.
  • Interactive Layer Customization: Implementing manual item manipulation directly within the layered 3D view, giving users the perfect hybrid balance of automated packing logic and precise, custom control.

Built With

Share this project:

Updates

Submission history