ParkAlong

One map for Melbourne parking availability, time limits, prices, providers, and directions.

ParkAlong is a native, map-first iPhone app that brings fragmented parking information into one consistent view. Search a destination in central Melbourne, choose how long you intend to stay, and compare nearby on-street zones and off-street facilities without jumping between council pages, payment apps, and provider websites.

The normal app flow uses live City of Melbourne sensor data and Apple MapKit. It has no account system, backend, payments, reservations, ads, or runtime AI.

Parking information is often split across several places:

• council sensor maps show whether bays may be occupied;
• street signs explain how long a driver can stay;
• payment providers handle sessions and current rates;
• commercial operators list separate off-street facilities;
• navigation happens in another app.

ParkAlong normalizes those pieces into a single ParkingOption model and a single result sheet. The four primary answers are always the same: availability, location, time limit, and price/provider. Arrival prediction is intentionally secondary.

• Live on-street availability from City of Melbourne parking-bay sensors.
• Green, amber, and red count pins: 3+ spaces, 1–2 spaces, or no currently vacant spaces.
• Destination search powered by MKLocalSearch.
• Stay-length filtering for 15 minutes, 1 hour, 2 hours, and 3 hours or longer.
• Current time-limit resolution using Melbourne-local day and time.
• Paid/free labelling where the active parking code makes it clear.
• Provider links when a trustworthy reusable price is not available.
• Nearby off-street facilities from MapKit, normalized alongside on-street zones.
• Availability-first Best bet ranking.
• Individual vacant-bay markers fetched only after selecting a zone.
• Apple Maps driving handoff—ParkAlong does not recreate turn-by-turn navigation.
• Two-minute refresh, foreground refresh, manual refresh, and checked-at timestamps.
• Bundled 2019 historical patterns as a clearly labelled fallback when live sensors cannot be trusted.
• Deterministic test fixtures that never leak into a normal launch.
• Light mode, dark mode, Dynamic Type, VoiceOver labels, and reduced-motion support.

The duration control is a real result filter, not a display preference.

Changing duration clears the previous markers immediately and fetches a fresh, matching result set. If no nearby on-street zone fits, ParkAlong says so and keeps useful off-street options visible rather than presenting a network error.

flowchart LR
    Destination["Destination + stay length"] --> Repository["ParkingRepository"]
    Sensors["City live sensors"] --> Repository
    Signs["Current zone restrictions"] --> Repository
    History["Bundled 2019 patterns"] --> Repository
    MapKit["Apple MapKit facilities"] --> Normalizer["ParkingOption normalizer"]
    Repository --> Engines["Availability, restriction, prediction and ranking engines"]
    Engines --> Normalizer
    Normalizer --> Map["Availability-first map"]
    Map --> Sheet["Unified result sheet"]
    Sheet --> Maps["Apple Maps handoff"]

Sensor rows are accepted only when they have a recognized occupancy state, usable zone/location data, and a status timestamp within the previous 24 hours. Ambiguous or stale rows are excluded. Under-counting is preferred to advertising a questionable vacancy.

Results are ranked deterministically with availability dominating distance:

• 70% predicted available-space count;
• 20% walking distance;
• 10% freshness and confidence.

The map renders the top 24 ranked on-street options to remain responsive while zooming and panning.

ParkAlong shows Free when the current restriction code establishes it. For metered parking and commercial facilities, the app shows a current provider/payment link when it cannot verify a reusable exact tariff. It never invents a price.

The project keeps networking, domain rules, prediction, ranking, and UI orchestration separate:

• macOS with Xcode 16 or newer
• iOS 17+ simulator or device
• XcodeGen
• Python 3 for data generators and their tests

No paid Apple Developer account is required for simulator use.

git clone https://github.com/OpenRenderKit/ParkAlong.git
cd ParkAlong
brew install xcodegen
xcodegen generate
open ParkingAvailability.xcodeproj

Or build entirely from the terminal:

xcodebuild build \
  -project ParkingAvailability.xcodeproj \
  -scheme ParkingAvailability \
  -destination 'platform=iOS Simulator,name=iPhone 17 Pro,OS=latest' \
  CODE_SIGNING_ALLOWED=NO

Set a simulator location in central Melbourne:

xcrun simctl location booted set -37.8136,144.9631

Location permission is optional. If permission is denied, ParkAlong stays centred on Melbourne CBD and destination search remains fully usable.

Run the deterministic app test suite:

xcodebuild test \
  -project ParkingAvailability.xcodeproj \
  -scheme ParkingAvailability \
  -destination 'platform=iOS Simulator,name=iPhone 17 Pro,OS=latest' \
  CODE_SIGNING_ALLOWED=NO

Run generator tests:

python3 -m unittest discover -s Scripts/tests -v

Run the separate real-network smoke check:

python3 Scripts/smoke_live_api.py

UI tests use -ui-testing with deterministic -fixture-live, -fixture-loading, or -fixture-error launch arguments. -location-denied covers the CBD fallback and -intercept-navigation verifies navigation without leaving the test app. Normal launches never select fixtures.

Refresh current zone metadata and sign restrictions:

python3 Scripts/generate_metadata.py

The historical generator streams the 2019 archive directly from its ZIP and does not load 42.7 million rows into memory:

mkdir -p Scripts/data
curl -fL \
  'https://opendatasoft-s3.s3.amazonaws.com/downloads/archive/7pgd-bdf2.zip' \
  -o Scripts/data/2019-parking-events.zip

python3 Scripts/generate_prediction.py \
  Scripts/data/2019-parking-events.zip \
  ParkingAvailability/Resources/Generated/historical_availability.json \
  --metadata ParkingAvailability/Resources/Generated/zone_metadata.json

The raw archive is ignored by Git. Only the compact generated artifact is committed.

Parking data is provided by the City of Melbourne and licensed under Creative Commons Attribution 4.0:

• On-street parking bay sensors
• Sign plates located in each parking zone
• Parking zones linked to street segments
• 2019 parking events archive

Off-street place discovery and destination search use Apple MapKit. Provider availability, opening hours, and prices remain controlled by each provider.

• No account or advertising identifier.
• No first-party analytics or tracking.
• No backend operated by ParkAlong.
• Location is used on-device to centre searches and is not stored by the app.
• Network requests are limited to normal City of Melbourne data and Apple MapKit/Maps requests.

• Availability changes quickly and is not a reservation.
• Sensors can be unreliable on public holidays, around construction, or when a bay is temporarily unavailable.
• Exact on-street and facility prices are not consistently exposed through reusable public interfaces.
• Off-street facility results can provide provider links while current capacity remains unknown.
• Historical fallback data describes 2019 patterns and is always labelled as typical, not live.

Contributions are welcome. Start with CONTRIBUTING.md, use an issue for user-visible changes, and keep networking/domain behavior covered by deterministic tests. Please read the Code of Conduct and report sensitive problems according to SECURITY.md.

ParkAlong source code is available under the MIT License. Bundled and remotely fetched City of Melbourne datasets retain their original CC BY 4.0 terms and attribution requirements.