# Project export: Wayve

This document was generated by HackStack to give an AI agent context about a hackathon project. Sections are labeled with their provenance; content marked as truncated was cut to keep this document small.

## Project metadata

- Hackathon: UC Berkeley AI Hackathon 2026
- Tagline: Wayve is an AI-powered parking platform that predicts parking availability, reduces unnecessary driving and carbon emissions, helping people reach destinations faster, cheaper, and more sustainably.
- Devpost: https://devpost.com/software/wayve-afvdl2
- GitHub: https://github.com/FoamyPancake125/wayve
- Video: https://www.youtube.com/embed/uYhZAUxPhZ4?enablejsapi=1&hl=en_US&rel=0&start=&version=3&wmode=transparent
- Team: 1 GitHub contributor(s) — Xiangting Ren (1 commits)

## Devpost submission (written by the team)

### Inspiration

Parking is something millions of people experience every day, yet it remains one of the most frustrating parts of transportation. Students arrive late to class, commuters miss appointments, and drivers spend valuable time searching for available spaces. At universities such as UC Berkeley, thousands of students, faculty, staff, and visitors travel to campus every day, and finding parking can often take longer than the drive itself. Beyond the inconvenience, these extra minutes contribute to traffic congestion, fuel consumption, and unnecessary carbon emissions. The inspiration for Wayve came from a simple question: navigation applications can tell us how to reach a destination, but why can they not tell us where we can actually park when we arrive? We wanted to build a system that addresses the final part of the journey and helps people make smarter transportation decisions before they even reach their destination.

### What it does

Wayve is an AI-powered parking platform that predicts parking availability before a user arrives. Rather than displaying every parking option equally, the system analyzes arrival time, historical demand, nearby events, parking costs, walking distance, accessibility needs, and community reports to recommend the most practical options for each individual user. The platform also recognizes that transportation affects much more than parking. Access to internships, volunteer opportunities, campus events, and community activities often depends on whether people can realistically reach those destinations. Wayve therefore connects transportation decisions with access to opportunity. The community reporting system also allows users to report full garages, construction, or temporary closures, helping improve future recommendations and train the AI.

### How we built it

Wayve was developed as a web application using React, TypeScript, and modern frontend development tools. The prototype was designed to demonstrate how multiple transportation data sources can work together to estimate parking availability. The prediction system is based on factors such as historical parking demand, arrival times, nearby events, user preferences, and community reports. We designed the system around a gradient boosting model because it performs well on structured transportation data and can improve as more information becomes available. The prediction process can be represented as: $$Availability = f(time,\ location,\ events,\ demand,\ reports)$$ The goal of the AI system is not simply to display parking locations but to provide personalized recommendations that adapt to changing conditions.

### Challenges we ran into

One of the biggest challenges was the lack of universally available parking data. Many parking facilities do not provide real-time occupancy information, and installing sensors at scale can be expensive. Because of this, we had to design a system that could still make useful predictions using historical demand patterns, schedules, and community feedback. Another challenge was balancing technical feasibility with realistic impact. Parking is often viewed as a small inconvenience, but we discovered that it affects accessibility, transportation equity, congestion, and environmental sustainability. Building a solution that addressed these larger issues while remaining practical required careful consideration of both the technology and the people using it.

### Accomplishments we're proud of

One accomplishment we are particularly proud of is turning an everyday frustration into a problem with meaningful social and environmental impact. Rather than building another navigation application, we created a platform that connects parking, accessibility, sustainability, and access to opportunity within a single experience. We are also proud of developing a complete prototype that demonstrates the full user journey. Users can search for parking, receive personalized recommendations, report real-time conditions, discover opportunities, and track the environmental impact of their transportation decisions. The project goes beyond simply locating parking spaces and instead focuses on helping people reach important destinations more efficiently. Another accomplishment was designing a system that can still provide useful recommendations even when real-time parking data is unavailable. By combining historical demand patterns, user preferences, event schedules, and community reports, Wayve demonstrates how AI can help solve transportation challenges without requiring expensive infrastructure. Most importantly, we are proud that Wayve addresses a real problem experienced by students, commuters, faculty, and visitors every day. The project demonstrates how artificial intelligence can be used responsibly to improve accessibility, reduce unnecessary driving, and make transportation decisions more equitable and sustainable.

### What we learned

Through building Wayve, we learned that transportation problems are rarely isolated. Parking affects how people access opportunities, how cities manage congestion, and how individuals experience their daily routines. We also learned the importance of designing around incomplete data and creating systems that improve over time through feedback. Most importantly, we learned that solving problems requires more than technical knowledge alone. It requires understanding users, identifying meaningful challenges, and designing solutions that create measurable impact.

### What's next

Our next goal is to test Wayve within a real university environment and gather user feedback to improve prediction accuracy. Future development could include additional data partnerships, additional parking integrations, mobile applications, and pilot programs with universities and cities. Success for Wayve would mean reducing parking search times, decreasing unnecessary driving, and helping people reach important destinations more efficiently. While Wayve began as a solution to parking frustration, its larger mission is to improve accessibility, reduce emissions, and make transportation decisions smarter for everyone. Find the way. Solve the day. All with Wayve.

## README (from the GitHub repository)

Wayve

Find the way. Solve the day. All with Wayve.

Wayve is an AI-powered parking and mobility platform that helps users find parking faster, reduce unnecessary driving, and make smarter transportation decisions before they arrive. Built for the UC Berkeley AI Hackathon 2026, the project combines parking prediction, accessibility, community reporting, and sustainability into a single platform.

The inspiration for Wayve came from a simple problem that millions of people experience every day. Drivers often spend several minutes searching for parking, creating traffic congestion, wasting fuel, and increasing carbon emissions. Existing navigation applications tell users how to reach their destination, but they rarely answer the question: Where can I actually park when I arrive? Wayve was created to solve this final step of the journey.

Wayve analyzes factors such as arrival time, historical demand patterns, nearby events, accessibility needs, walking distance, and user preferences to recommend practical parking options. The platform also includes community reporting features that allow users to share information about full garages, construction, or temporary closures, helping improve future recommendations.

The application was built using React and TypeScript with Vite as the development framework and Tailwind CSS for the user interface. The prediction framework is designed around structured machine learning approaches that estimate parking availability using transportation data and user feedback.

One of the biggest challenges during development was designing a system that could still provide useful recommendations when real-time parking information is unavailable. Rather than relying entirely on parking sensors, Wayve combines historical patterns, schedules, and community input to improve predictions.

UC Berkeley serves as a demonstration environment to showcase how Wayve can help students, faculty, staff, commuters, and visitors make smarter transportation decisions. While the current prototype focuses on university environments, the system could eventually expand to cities, hospitals, business districts, and event venues.

Wayve demonstrates how artificial intelligence can improve transportation accessibility, reduce unnecessary driving, and help people reach important destinations more efficiently.

Built for the UC Berkeley AI Hackathon 2026.


## Detected evidence (automated analysis)

Indexed codebase: 20 recognized source files, 149 KB.
- CSS (language) — detected in the code
- HTML (language) — detected in the code
- JavaScript (language) — detected in the code
- React (technology) — detected in the code
- Tailwind CSS (technology) — detected in the code
- TypeScript (language) — detected in the code

## Codebase structure (from repository index)

### Files (26 of 26)

```
.gitignore
.vite/deps/_metadata.json
.vite/deps/package.json
index.html
package.json
postcss.config.js
README.md
src/App.tsx
src/components/Sidebar.tsx
src/components/TopBar.tsx
src/index.css
src/layouts/AppLayout.tsx
src/layouts/AuthLayout.tsx
src/main.tsx
src/pages/Community.tsx
src/pages/Dashboard.tsx
src/pages/FindParking.tsx
src/pages/ForgotPassword.tsx
src/pages/Login.tsx
src/pages/Opportunities.tsx
src/pages/Register.tsx
src/pages/ResetPassword.tsx
tailwind.config.js
tsconfig.json
tsconfig.node.json
vite.config.ts
```

### Dependencies

- package.json: @types/react@^18.2.66, @types/react-dom@^18.2.22, @typescript-eslint/eslint-plugin@^7.2.0, @typescript-eslint/parser@^7.2.0, @vitejs/plugin-react@^4.2.1, autoprefixer@^10.4.19, eslint@^8.57.0, eslint-plugin-react-hooks@^4.6.0, eslint-plugin-react-refresh@^0.4.6, lucide-react@^0.363.0, postcss@^8.4.38, react@^18.2.0, react-dom@^18.2.0, react-router-dom@^6.22.3, recharts@^2.12.2, tailwindcss@^3.4.1, typescript@^5.2.2, vite@^5.2.0

### Recent commits (newest first)

- Initialize README with project overview and details
- Fixed login page styling
- Added accessibility filters
- Updated parking filters and UI
- Initial Wayve app

## Key source files (fetched from GitHub, selected and truncated for size)

### package.json

```
{
  "name": "wayve-vite",
  "private": true,
  "version": "0.0.0",
  "type": "module",
  "scripts": {
    "dev": "vite",
    "build": "tsc && vite build",
    "lint": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0",
    "preview": "vite preview"
  },
  "dependencies": {
    "react": "^18.2.0",
    "react-dom": "^18.2.0",
    "react-router-dom": "^6.22.3",
    "recharts": "^2.12.2",
    "lucide-react": "^0.363.0"
  },
  "devDependencies": {
    "@types/react": "^18.2.66",
    "@types/react-dom": "^18.2.22",
    "@typescript-eslint/eslint-plugin": "^7.2.0",
    "@typescript-eslint/parser": "^7.2.0",
    "@vitejs/plugin-react": "^4.2.1",
    "autoprefixer": "^10.4.19",
    "eslint": "^8.57.0",
    "eslint-plugin-react-hooks": "^4.6.0",
    "eslint-plugin-react-refresh": "^0.4.6",
    "postcss": "^8.4.38",
    "tailwindcss": "^3.4.1",
    "typescript": "^5.2.2",
    "vite": "^5.2.0"
  }
}

```

### .vite/deps/package.json

```
{
  "type": "module"
}

```

### src/main.tsx

```typescript
import React from 'react'
import ReactDOM from 'react-dom/client'
import App from './App.tsx'
import './index.css'

ReactDOM.createRoot(document.getElementById('root')!).render(
  <React.StrictMode>
    <App />
  </React.StrictMode>,
)

```

### src/App.tsx

```typescript
import { BrowserRouter, Routes, Route, Navigate } from 'react-router-dom'
import AppLayout from './layouts/AppLayout'
import FindParking from './pages/FindParking'
import Opportunities from './pages/Opportunities'
import Community from './pages/Community'
import Dashboard from './pages/Dashboard'

export default function App() {
  return (
    <BrowserRouter>
      <Routes>
        <Route element={<AppLayout />}>
          <Route path="/" element={<FindParking />} />
          <Route path="/opportunities" element={<Opportunities />} />
          <Route path="/community" element={<Community />} />
          <Route path="/dashboard" element={<Dashboard />} />
        </Route>
        <Route path="*" element={<Navigate to="/" replace />} />
      </Routes>
    </BrowserRouter>
  )
}

```

### postcss.config.js

```javascript
export default {
  plugins: {
    tailwindcss: {},
    autoprefixer: {},
  },
}

```

### vite.config.ts

```typescript
import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'

export default defineConfig({
  plugins: [react()],
})

```

### index.html

```html
<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Wayve — Smart Parking & Transportation</title>
  </head>
  <body>
    <div id="root"></div>
    <script type="module" src="/src/main.tsx"></script>
  </body>
</html>

```

### tailwind.config.js

```javascript
/** @type {import('tailwindcss').Config} */
export default {
  content: ['./index.html', './src/**/*.{js,ts,jsx,tsx}'],
  theme: {
    extend: {
      fontFamily: {
        sans: ['Inter', 'ui-sans-serif', 'system-ui', 'sans-serif'],
        display: ['DM Sans', 'ui-sans-serif', 'system-ui', 'sans-serif'],
      },
      colors: {
        background: 'hsl(var(--background))',
        foreground: 'hsl(var(--foreground))',
        card: {
          DEFAULT: 'hsl(var(--card))',
          foreground: 'hsl(var(--card-foreground))',
        },
        primary: {
          DEFAULT: 'hsl(var(--primary))',
          foreground: 'hsl(var(--primary-foreground))',
        },
        secondary: {
          DEFAULT: 'hsl(var(--secondary))',
          foreground: 'hsl(var(--secondary-foreground))',
        },
        muted: {
          DEFAULT: 'hsl(var(--muted))',
          foreground: 'hsl(var(--muted-foreground))',
        },
        accent: {
          DEFAULT: 'hsl(var(--accent))',
          foreground: 'hsl(var(--accent-foreground))',
        },
        destructive: {
          DEFAULT: 'hsl(var(--destructive))',
          foreground: 'hsl(var(--destructive-foreground))',
        },
        border: 'hsl(var(--border))',
        input: 'hsl(var(--input))',
        ring: 'hsl(var(--ring))',
      },
      borderRadius: {
        lg: 'var(--radius)',
        md: 'calc(var(--radius) - 2px)',
        sm: 'calc(var(--radius) - 4px)',
      },
    },
  },
  plugins: [],
}

```

### src/index.css

```css
@import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&family=DM+Sans:wght@400;500;600;700&display=swap');

@tailwind base;
@tailwind components;
@tailwind utilities;

@layer base {
  :root {
    --background: 220 25% 97%;
    --foreground: 222 47% 11%;
    --card: 0 0% 100%;
    --card-foreground: 222 47% 11%;
    --popover: 0 0% 100%;
    --popover-foreground: 222 47% 11%;
    --primary: 230 65% 30%;
    --primary-foreground: 0 0% 100%;
    --secondary: 220 16% 94%;
    --secondary-foreground: 222 47% 11%;
    --muted: 220 16% 94%;
    --muted-foreground: 220 9% 48%;
    --accent: 38 92% 50%;
    --accent-foreground: 222 47% 11%;
    --destructive: 0 72% 51%;
    --destructive-foreground: 0 0% 100%;
    --border: 220 14% 89%;
    --input: 220 14% 89%;
    --ring: 230 65% 30%;
    --radius: 0.75rem;
  }

  * {
    border-color: hsl(var(--border));
  }

  body {
    background-color: hsl(var(--background));
    color: hsl(var(--foreground));
    font-family: 'Inter', ui-sans-serif, system-ui, sans-serif;
    -webkit-font-smoothing: antialiased;
    -moz-osx-font-smoothing: grayscale;
    line-height: 1.6;
  }

  .font-display {
    font-family: 'DM Sans', ui-sans-serif, system-ui, sans-serif;
  }

  /* Smooth scrolling */
  html {
    scroll-behavior: smooth;
  }

  /* Better focus outlines */
  :focus-visible {
    outline: 2px solid hsl(var(--ring));
    outline-offset: 2px;
    border-radius: 6px;
  }
}

@layer utilities {
  .bg-background { background-color: hsl(var(--background)); }
  .bg-card { background-color: hsl(var(--card)); }
  .bg-primary { background-color: hsl(var(--primary)); }
  .bg-secondary { background-color: hsl(var(--secondary)); }
  .bg-muted { background-color: hsl(var(--muted)); }
  .bg-accent { background-color: hsl(var(--accent)); }
  .text-foreground { color: hsl(var(--foreground)); }
  .text-card-foreground { color: hsl(var(--card-foreground)); }
  .text-primary { color: hsl(var(--primary)); }
  .text-primary-foreground { color: hsl(var(--primary-foreground)); }
  .text-muted-foreground { color: hsl(var(--muted-foreground)); }
  .text-accent-foreground { color: hsl(var(--accent-foreground)); }
  .border-border { border-color: hsl(var(--border)); }
  .ring-ring { --tw-ring-color: hsl(var(--ring)); }
  .bg-card\/80 { background-color: hsl(var(--card) / 0.8); }

  /* Hide scrollbar but keep functionality */
  .no-scrollbar::-webkit-scrollbar { display: none; }
  .no-scrollbar { -ms-overflow-style: none; scrollbar-width: none; }

  /* Card hover shadow depth */
  .card-hover {
    transition: box-shadow 0.2s ease, border-color 0.2s ease, transform 0.15s ease;
  }
  .card-hover:hover {
    box-shadow: 0 8px 24px rgba(0, 0, 0, 0.08);
  }
}

```

### src/layouts/AuthLayout.tsx

```typescript
import { Outlet } from 'react-router-dom'

export default function AuthLayout() {
  return (
    <div className="min-h-screen bg-gradient-to-br from-slate-900 via-blue-950 to-slate-900 flex items-center justify-center p-4">
      <div className="w-full max-w-md">
        <div className="text-center mb-8">
          <div className="inline-flex items-center gap-2 mb-2">
            <div className="w-9 h-9 rounded-xl bg-blue-500 flex items-center justify-center">
              <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="white" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round">
                <path d="M12 2L2 7l10 5 10-5-10-5z"/>
                <path d="M2 17l10 5 10-5"/>
                <path d="M2 12l10 5 10-5"/>
              </svg>
            </div>
            <span className="text-2xl font-bold text-white">Wayve</span>
          </div>
          <p className="text-slate-400 text-sm">Smart Parking &amp; Transportation Intelligence</p>
        </div>
        <div className="bg-white rounded-2xl shadow-2xl p-8">
          <Outlet />
        </div>
      </div>
    </div>
  )
}

```

[11 more indexed source files omitted to keep this export small. The full file list is in the Codebase structure section above.]