Carys Richards

Nimbus

A live weather app built with React 19, featuring real-time forecasts, geolocation, dynamic theming, and a five-context state architecture.

Nimbus is a client-side React application that pulls live weather data from the OpenWeatherMap API — current conditions, a 5-day forecast, and hourly breakdowns. This is where I explored React's ecosystem: Context API for global state, custom hooks for browser APIs, and Emotion CSS-in-JS for component-scoped styling.

The app does more than display data — it processes it. Raw Unix timestamps get converted to local timezones, forecast entries get grouped and aggregated into daily highs/lows, and dominant weather conditions are calculated by frequency across each day's entries. There's also a dual-axis theme system (dark/light × warm/cool) and a saved locations feature, all persisted to localStorage.

Key Acheivements:

• Five-context state architecture: Isolated global state across Theme, Location, Weather, Unit, and LocalStorage contexts — each with a single concern, composed cleanly in App.jsx.
• Live API integration: Three distinct OpenWeatherMap endpoints with HTTP status handling, environment variable security, and user-facing error messages for every failure state.

Geolocation pipeline: Implemented one-click device positioning via navigator.geolocation, piped into a reverse geocoding call to resolve coordinates to a city name.

Data processing: Built forecast aggregation from scratch — timezone-safe grouping, daily high/low extraction, dominant condition frequency counts, and precipitation averages.

Dynamic theming system: Four theme combinations (dark/light × warm/cool) driven by programmatic CSS variable swaps and persisted across sessions via localStorage.

Live autocomplete search: Keystroke-driven geocoding with click-outside dismissal and unique key construction for duplicate city names.

That Cat Game

A joyful, 2D adventure platformer built in Unreal Engine 5.6. I designed, developed, and programmed the entire game from scratch.

That Cat Game was my first Unreal Engine project; I went from zero experience in the engine to shipping a playable Early Access game. It taught me how to manage a full project pipeline: art, programming, level design, UI, packaging, and release.

Key Acheivements:

• Gameplay programming: Built full 2D platforming mechanics, including movement, jumping, collision, and dynamic/static interactable elements.
• Debugging & optimization: Refined gameplay systems to achieve smooth, polished, and responsive controls.
• Player accessibility: Implemented three difficulty modes with full keyboard & controller support.
• Progressive systems: Gradually introduced new mechanics to support player learning.
• Content scalability: Implemented optional challenges and reward systems to encourage replay and extend gameplay value.
• Iterative development: Conducted external playtesting and adapted gameplay systems based on player feedback.
• Level design strategy: Designed levels with a focus on timing, flow, and skill progression.
• Art integration: Created and integrated all player and creature sprites.

Thoughtbox

A whimsical, full-stack note-taking and idea management app built with Node.js, Express, MongoDB, and EJS.

Thoughtbox is an server-rendered web app focused on building scalable, customizable note systems. Unlike my game projects, Thoughtbox focuses heavily on backend architecture, authentication, and scalable data modeling.

Designed for people who don't think in straight lines; Thoughtbox is space where users can build a collection of "Boxes", each containing modular "Thoughts"" with different content types — text, images, lists, and tags — which can be edited, organized, and removed dynamically.

Key Acheivements

• Full CRUD implementation: Designed and implemented RESTful routes and controller logic for boxes and nested notes.
• Authentication & session management: Integrated Passport.js with secure session handling and protected routes.
• Data modeling with MongoDB & Mongoose: Structured relational schemas to support scalable, nested content systems.
• Server-side rendering: Built dynamic views using EJS partials and conditional rendering.
• UI iteration & usability refinement: Adjusted layout behavior, scroll handling, and dynamic rendering to improve clarity and responsiveness.

KittyPop!

The cheerful, cat-collecting arcade challenge created with HTML, CSS and JavaScript.

KittyPop! was a chance to pull together what I've been learning in my Software Development Bootcamp, event-driven gameplay, and scalable architecture, and turn it into something fun, silly, and joyful.

KittyPop! was built using:

• ES6 Modules to organize logic across multiple scripts.
• Intervals and Timers that power a lightweight game loop.
• Dynamic DOM manipulation to add, animate, and remove cats, snakes, and rewards.
• Moblie-first responsive design including media queries and flexbox layouts.
• State management for pausing, resuming, level selection, and game over.
• Utility helpers for rarity rolls, bonuses, and randomness.
• Custom triggers for SFX and music tied to game events.