A retro-themed, manually animated iOS app inspired by Street Fighter II, designed as a scrollable character catalog featuring detailed bios, stats, and special moves. Each fighter is brought to life using 750+ individually cropped and resized animation frames, edited by hand and animated using a custom timer-based system in SwiftUI — no sprite sheets or third-party libraries required. The project highlights deep control over frame-by-frame animation, manual asset processing, and precise timing loops — all done within SwiftUI’s modern UI architecture.
- SwiftUI: A fully native iOS interface using Apple's modern declarative UI framework.
- Timer-Based Image Animation: Custom animation system using Timer.publish and Image arrays to replicate motion frame-by-frame.
- Pixlr: Every character’s animation frame was manually processed (cropped/resized) using this online photo editor.
- Custom Animation Logic: Loops through static image arrays to recreate fighter animations with frame-accurate timing.
- Local Asset Management: Assets are organized, named, and rendered manually — no use of SpriteKit or animation libraries.
- Presents a scrollable list of iconic Street Fighter II characters.
- Each character includes:
- Name, bio, origin, fighting style
- Special move list and signature fighting traits
- Frame-by-frame animation of the idle stance or signature motion
- All animations are performed using Timer-driven cycling through static frames.
- Entirely offline — all images and data are locally stored.
- Manual Craftsmanship: Every frame was hand-edited and processed to preserve the 16-bit pixel art style.
- Pure SwiftUI Animation: No SpriteKit, Lottie, or UIKit — just native SwiftUI views and logic.
- Retro UI Design: Fonts, colors, and layout choices mimic the arcade cabinet experience.
- Precision Animation Control: Fine-tuned frame timing for authentic retro feel.
- Organized Asset Management: Structured image arrays and logic that can scale to support other games or characters.
Only Self, Source code can be provided upon request of recruiter or manager
Fetch.com take home project -- A recipes app that fetches food items from the server. The food items are displayed in a grid that can be sorted and searched. Clicking a food item reveals details such as recipes, image, videos, country of origin and an added wiki description. Links opens to webpages and video player.
- Modern Swift Concurrency: used asyn/await to fetch JSON data from server. Async Image to fetch and display Images of food items.
- NSCache: Caching Images fetched from server after initial request.
- UIViewRepresentable: Needed to use UIViewRepresentable to work with Webkit and embed Youtube Videos in the app.
- WebView: Used to Display sources of resipes.
- UnitTest: Created Unit test for All Non-View files, Models, NSCaching, Mocking API Fetches, Mocking URL Session for 100% Code Coverage for all non view files.
- How to run the project:
- Three Buttons on the app fetches from the three endpoints provided in the instructions (Complete, Malformed & Empty).
- All three responses have been handled with a default value or actions to provide a video or source.
- Select one of the buttons and the app will fetch and display all recipes, an empty endpoint will show an alert.
- After the Initial fetch, the recipes will be cached to minimize network calls.
- The items are in a grid and can be sorted by name, country of origin & favourites.
- Items can also be searched for by name or country of origin
- Click the items to go into it's details. There will be a brief summary from wikipedia, a large image, an option to add to favourites, a source webview link and a link to an embeded youtube player.
- Dependencies: There are NO dependencies.
- Extra Added Features:
- Added Alerts to handle using empty endpoints and trying to sort or search an empty recipes.
- Added function to automatically search for recipes in google if the source-variable is missing by using the name of the item. (malformed endpoint items: 2,3,21,27,29)
- Added function to automatically search for videos in youtube if the videoURL-variable is missing by using the name of the item. (malformed endpoint items: 10,35,40,57)
- Added Sorting be name,country of origin, or favourites.
- Added Search by name or country of origin.
- Added Favourites Option.
- Added Embeded Youtube Video View & Source Webview
- Added Refreshable method by pulling scrollview down or tool bar "Show all"
- Added Wikipedia summary for the food items.
Only Self, Source code can be provided upon request of recruiter or manager
An interactive weather and map exploration app built with SwiftUI and MapKit, allowing users to view real-time weather based on any city they enter. It integrates live data from the OpenWeather API, and dynamically displays an interactive map with search functionality, zoom controls, and multiple view modes. The app also features point-of-interest search (hotels, restaurants, etc.) with detailed location info including address and contact data. This project showcases a blend of custom UI, API-driven data, and map-based interactivity — combining practical utility with a smooth user experience.
- SwiftUI: Clean and reactive interface for modern iOS UI.
- OpenWeather API: Retrieves live temperature, humidity, wind, and condition data by city name.
- MapKit + SwiftUI Integration: Displays city location with satellite, hybrid, and standard map modes.
- Custom UI Components: Styled weather displays, toggles for map view modes, and result cards.
- Geocoding & Reverse Geocoding: Converts city names into coordinates and vice versa.
- Asynchronous Networking: Uses async/await and URLSession for clean API integration.
- Searchable Map Points: Supports finding hotels, restaurants, and other landmarks with detail popups.
- Users can search any city by name to:
- View current weather details (condition, temperature, wind, humidity)
- See the location on an interactive map Supports:
- Zoomable map with pinch gestures
- Toggle between map types: standard, satellite, hybrid
- Local POI search (e.g., "restaurant") with marker pins and info cards
- Updates UI dynamically using SwiftUI’s state system
- Real-World API Integration: Weather data fetched via OpenWeather and parsed live.
- Map-Based Interaction: Combines location-based UI with POI search to enrich user experience.
- Modern iOS Design: Built from the ground up with SwiftUI and Apple’s best practices.
- Asynchronous Networking: Uses Swift Concurrency for clean, maintainable data flows.
- Location Intelligence: Combines geocoding, POI lookup, and map overlays.
Only Self, Source code can be provided upon request of recruiter or manager
A fully code-driven, recise mechanical simulation of the Rolex Daytona Caliber 4130 chronograph, engineered entirely in SwiftUI, with working chronograph that starts, stops and snaps back from timer to watch. — with no image assets, no Core Animation, and no external libraries. Every visible element — from the dial markings and hand shadows to the tick marks and sub-dial numerals — is drawn programmatically using geometric and trigonometric calculations. The chronograph system operates from a *SINGLE-Timer, advancing the second hand through 480 discrete micro-steps per minute to authentically replicate the high-beat motion (28,800 vibrations per hour) of the real 4130 movement. The chronograph system isn’t static — it fully functions like the real watch, seamlessly entering and exiting chronograph mode and snapping all hands back to zero when reset, just like a genuine mechanical movement. The result is a pixel-perfect, mechanically faithful chronograph that achieves centisecond-level accuracy in its timer logic, hand synchronization, and tick cadence. This project demonstrates SwiftUI rendering, math-driven motion control, timer coordination, and code-based visual design, photorealistic mechanical simulation can be achieved purely in SwiftUI.
- SwiftUI: Declarative rendering of all UI components, including the chronograph dial, subdials, and hands.
- Timer-Based Rotation System: Simulates mechanical hand movement using Timer.publish with exact tick intervals.
- Programmatic Drawing: Every tick mark, number, and dial layout was drawn with SwiftUI shapes and geometry — no assets or sprites.
- Math-Driven UI: Circular layout calculations using degrees, trigonometry, and polar coordinate conversions.
- Synchronized Motion: All watch hands run in perfect sync, using a single timing source for realism and performance.
- High-Fidelity Simulation: Models a real chronograph’s behavior, including pause, reset, and lap interactions (if implemented).
### What It Does: - Accurately simulates: Main chronograph second hand ticking at 480 BPM (beats per minute) Subdials for elapsed minutes/hours (if included) - Smooth and continuous rotation using step-based updates - Tick marks and dial indicators precisely positioned via trigonometric formulas - Entire interface runs without image files or third-party libraries - Layout adapts across screen sizes while maintaining mechanical accuracy
- Mathematical Rendering: All visual elements placed using geometry and trigonometry with high angular precision.
- Mechanical Fidelity: Mimics the real-world Rolex Daytona movement's tick rate and hand behavior.
- Code-Only UI: Every pixel and curve rendered natively with SwiftUI views — zero visual assets used.
- Timer Synchronization: Centralized timing logic drives all hands consistently and efficiently.
- UI Engineering: Combines timing, geometry, and real-world mechanical reference into a working Swift-based chronograph simulator.
Only Self, Source code can be provided upon request of recruiter or manager
A smart weather-based outfit recommendation app that helps users decide what to wear based on live weather data. Powered by AI, the app personalizes outfit suggestions using the user's gender, age range, and the current weather at their location.
It combines real-time weather forecasts, natural language outfit suggestions, and curated fashion images — all running securely on Google Cloud with Firebase Authentication.
- SwiftUI & Async/Await: Modern, responsive iOS UI built using SwiftUI and Swift Concurrency.
- OpenWeather API: Retrieves the latest weather for your current location.
- OpenAI (ChatGPT API): AI-generated outfit suggestions tailored to weather, gender, and age.
- Pexels API: Visual display of AI-recommended outfits using royalty-free fashion images.
- Firebase Authentication: Secure, scalable sign-in system for users.
- Firebase Secret Manager: Keeps API keys secure and away from client-side code.
- Google Cloud Run: Backend endpoints deployed on a serverless Google Cloud instance, handling all external API calls.
- Firebase Hosting + Logging: Backend analytics and logs monitored via Firebase Console and Cloud Logs.
- Auto-detects your location and current weather.
- Lets you input age range and select gender or use gender-neutral mode.
- Generates natural-sounding clothing suggestions using AI.
- Shows matching outfit photos from Pexels.
- Allows user authentication (sign in/sign up).
- Everything runs through a secure backend on Google Cloud.
- User-first design: Built for clarity and fast decisions — see your weather and your outfit instantly.
- AI + Weather + Visuals: Seamlessly combines data, intelligence, and design to solve a real-life daily problem.
- Security: API keys are stored in Firebase Secret Manager and never exposed in the app.
- Scalable Cloud Architecture: All data fetching is offloaded to Google Cloud Run, improving speed and security.
- Video and screenshots available in the
/mediafolder showing:- Real-time requests logged in Google Cloud Console.
- API traffic routed through Cloud Run.
- Firebase Authentication in action.
- Secure access to API keys using Secret Manager.
- Click to Expand -
- SwiftUI: Declarative UI for responsive, modern iOS interfaces.
- Core Data: Native Apple framework for local storage and data persistence.
- Gestures: Swipe-to-complete, swipe-to-delete, and tap interactions for task control.
- Smooth Scroll Views: Optimized list navigation and animations for long task lists.
- Custom Animations: Transitions and effects to enhance interactivity and UX.
Allows users to:
- Add new tasks instantly via an input field
- Swipe to mark tasks as completed
- Swipe to delete tasks from the list
- Smooth animated transitions between task states All data is stored on-device using Core Data, supporting:
- Offline usage
- Persistent task history
- Fast app performance without cloud sync
- Data Persistence: All tasks are saved locally and survive app restarts using Core Data.
- User-Centric Design: Clean layout, large tap targets, and accessible UX.
- Gesture-Driven UI: Designed for fast input and control using common swipe interactions.
- Thematic Styling: Visually bold and consistent design aesthetic inspired by “boss-mode” productivity.
- SwiftUI Mastery: Takes full advantage of state-driven views, binding, and animation.
Only Self, Source code can be provided upon request of recruiter or manager
- SwiftUI: Lightweight, modern interface for a seamless reading experience.
- NewsAPI.org: Fetches the latest 100 topic-specific news articles via RESTful API.
- Async Networking: Swift Concurrency (async/await) for efficient data fetching.
- WebView Integration: Opens full articles in an in-app browser using SafariViewController.
- List & Navigation Views: Tap-to-expand interface from summary to full article with dynamic view transitions.
- Automatically fetches top 100 articles on a chosen topic.
Displays:
- Headline
- Publication date
- A rticle summary or excerpt Tapping an article:
- Opens a detailed view with extended text
- Includes a button to open the full article in a WebView Supports light/dark mode and responsive layout scaling
- Clean UI & UX: Prioritizes readability, simplicity, and minimal distraction.
- Live News Integration: Demonstrates ability to work with real-world APIs and live content.
- Efficient Data Handling: Uses async/await for responsive and modern networking.
- Smooth Navigation: Tap-to-detail transitions built entirely in SwiftUI.
- Web Integration: Embeds full article access without leaving the app.
Only Self, Source code can be provided upon request of recruiter or manager