Top 20+ Augmented Reality (AR) Projects in 2026

In 2026, AR projects are evolving with the integration of generative AI and advanced spatial mapping. This shift is turning AR devices into proactive assistants that can understand environments and deliver real-time, context-aware experiences.

Key AR projects now focus on AI-powered visual inspection in manufacturing, advanced virtual try-ons in retail, and immersive learning experiences in education. With rapid growth in AR hardware and WebAR adoption, developers are building more scalable and accessible applications across industries.

In this guide, you will explore beginner to advanced AR projects, tools to use, and practical ideas to build real-world augmented reality applications. 

Build skills for immersive tech and AI-driven applications. Explore upGrad’s Artificial Intelligence Courses to learn how to create AR experiences, work with real-world tools, and start building interactive, future-ready applications.

Beginner Friendly AR Projects

These AR Projects introduce you to the core fundamentals of spatial computing, including plane detection, image tracking, and rendering 3D assets. They serve as the perfect transition into the wider world of AR VR projects.

1. AR Virtual Business Card

This project teaches the absolute basics of image tracking. You will build an application where hovering a smartphone camera over a physical business card brings it to life, displaying floating 3D social media icons and a video introduction.

Tools and Technologies Used

• Unity 3D: The core game engine.
• Vuforia Engine: For highly reliable image target tracking.
• C#: For basic interaction logic.

How to Make It

• Upload a high-contrast image of a physical business card to the Vuforia Developer Portal to generate a tracking database.
• Import this database into Unity and attach it to an ImageTarget game object.
• Place 3D models (like a LinkedIn or GitHub logo) and a VideoPlayer component as children of the ImageTarget so they render relative to the card's position.
• Write a simple C# script using Raycast so that when the user taps the floating 3D LinkedIn icon on their screen, it opens the actual URL in their device's mobile browser.

Also Read: Top 40 AI Project Ideas 

2. AR Tape Measure App

This project introduces you to plane detection and spatial mathematics. You will build a utility application that calculates the real-world distance between two points tapped on the screen.

Tools and Technologies Used

• AR Foundation (Unity): For cross-platform ARKit/ARCore deployment.
• AR Plane Manager: To detect horizontal and vertical surfaces.
• Vector3 Mathematics: To calculate distance in 3D space.

How to Make It

• Set up an AR Session in Unity with an ARPlaneManager to visualize the floor or walls using a transparent grid material.
• Implement a touch interface: when the user taps the screen, execute an ARRaycast against the detected planes to place a 3D sphere marker.
• When a second marker is placed, draw a LineRenderer component between the two spheres.
• Use the Vector3.Distance function in C# to calculate the exact distance between the two markers in meters, converting the output to inches/centimeters and displaying it via a floating UI text component.

3. Solar System Explorer

This project focuses on rendering complex 3D environments and handling local rotation. You will build an educational app that anchors a to-scale, rotating 3D model of the solar system in the center of the user's living room.

Tools and Technologies Used

• RealityKit / ARKit (iOS native): For highly optimized Apple device rendering.
• Swift: For application logic.
• Blender: To source and optimize the 3D planetary models.

How to Make It

• Import textured 3D sphere models representing the sun and planets into your Xcode project.
• Use ARKit to detect a horizontal plane (like a coffee table) and establish an AnchorEntity.
• Programmatically structure the planets in a hierarchy around the sun, ensuring they scale appropriately so the entire system fits within the room.
• Apply continuous rotation animations to the planets using RealityKit's animation system, giving each planet a distinct orbital speed based on real physics data.

4. Interactive Face Filter

This project delves into facial mesh tracking and blend shapes. You will build a social-media-style filter that attaches 3D objects (like glasses or a hat) to a user's face and reacts to their facial expressions.

Tools and Technologies Used

• Spark AR Studio (Meta) or Lens Studio (Snapchat): For rapid face-tracking development.
• Face Tracker node: To map the user's facial geometry.
• Patch Editor (Visual Scripting): For interactive logic.

How to Make It

• Open your chosen AR studio and instantiate a Face Tracker object in the scene hierarchy.
• Import a 3D model of a hat and make it a child of the Face Tracker, adjusting its transform so it sits accurately on the top of the head.
• Utilize the Patch Editor to detect specific facial gestures, such as "Mouth Open" or "Eyebrow Raise."
• Connect the "Mouth Open" trigger to a particle emitter, making the app shoot 3D hearts or fire from the user's mouth whenever they smile broadly.

Also Read: 35+ Mini Project Ideas for CSE Students in 2026 

5. Floating AR Notes (Location-Based)

This project blends GPS data with spatial rendering. You will build an app where users can leave floating text notes at specific real-world coordinates, which can be discovered by other users walking by.

Tools and Technologies Used

• ARCore Geospatial API: For ultra-precise global localization.
• Google Maps API: For fetching coordinate data.
• Kotlin (Android native): For application architecture.

How to Make It

• Integrate the ARCore Geospatial API, which uses Google's Street View data to determine the device's exact latitude, longitude, and altitude with centimeter-level precision.
• Build a UI allowing the user to type a short message and hit "Place Note."
• Capture the device's current geospatial pose and spawn a 3D text object anchored to those specific global coordinates.
• Save these coordinates and the text string to a backend database (like Firebase) so that when another user opens the app in the same location, the database fetches the note and renders it in AR.

Also Read: Top 25+ DBMS Project Ideas for Students in 2026 [With Source Code] 

6. Magic Portal to Another World

This project teaches advanced rendering techniques, specifically using stencil buffers to mask objects. You will build an AR door that appears in the user's room; when they walk through the physical space of the door, they are visually transported into a 3D 360-degree environment.

Tools and Technologies Used

• Unity 3D: For the rendering pipeline.
• Custom Stencil Shaders: To mask the "inside" of the portal from the real world.
• 360 HDRI Skyboxes: For the immersive environment.

How to Make It

• Create a 3D doorframe model and place it on a detected AR plane.
• Write a custom stencil shader in Unity. Apply this shader to a quad placed inside the doorframe so that the 3D environment behind the door is only visible when viewed directly through the frame.
• Place a massive 360-degree sphere around the door, mapped with an HDRI image of an alien planet or a forest.
• Use camera collision detection to swap the rendering layers once the user's physical phone passes through the threshold of the doorframe, making the digital world fully visible and masking out the real world.

7. Basic Furniture Previewer

This project introduces the fundamentals of e-commerce spatial computing. You will build a tool that lets users select a piece of furniture from a UI menu and place a true-to-scale 3D model of it on their floor to see if it fits.

Tools and Technologies Used

• WebXR (Model-Viewer): For a frictionless, browser-based experience without app downloads.
• HTML/CSS/JavaScript: For the web interface.
• GLTF/GLB 3D Formats: Optimized models for the web.

How to Make It

• Use Google's <model-viewer> web component, which abstracts away the complex ARKit/ARCore logic into a simple HTML tag.
• Create a gallery of GLB files (e.g., a couch, a chair, a table) and build a JavaScript UI to swap the src attribute of the <model-viewer> tag when a user taps a thumbnail.
• Enable the ar attribute on the tag, which automatically triggers the native Quick Look (iOS) or Scene Viewer (Android) when the user taps the "View in your space" button.
• Ensure the 3D models are exported at a 1:1 real-world scale from Blender so the couch accurately represents its physical dimensions when placed on the user's floor.

Also Read: Top 35 MERN Stack Project Ideas of 2026 [With Source Code] 

Intermediate Level AR Projects

These AR Projects require a deeper understanding of user interface design in 3D space, interacting with external databases, and handling occlusion. These are representative of the standard expected in professional AR VR projects.

1. AR Museum Audio Guide

This project focuses on complex image tracking and multimedia integration. You will build an application for a museum where pointing a phone at a specific painting triggers a 3D animated overlay and synchronized audio narration.

Tools and Technologies Used

• 8th Wall (WebAR): For high-quality image tracking directly in the mobile browser.
• A-Frame: A web framework for building VR/AR experiences.
• Web Audio API: For managing narration playback.

How to Make It

• Set up an 8th Wall project and upload high-resolution images of various paintings to act as image targets.
• Use A-Frame to construct the scene; when the camera recognizes the "Mona Lisa" target, spawn a 3D informational panel that sits cleanly next to the physical painting.
• Programmatically trigger an audio file to play detailing the history of the artwork, ensuring you write logic to pause or stop the audio if the painting leaves the camera's view.
• Add interactive 3D buttons beneath the painting that the user can tap to cycle through different languages or see an x-ray view of the painting's underlying sketches.

Also Read: 40 Best BCA Final Year Project Topics & Mini Project Ideas 

2. Interactive 3D Restaurant Menu

This project bridges commercial APIs with augmented rendering. You will build a tablet application for restaurants where patrons can scan a QR code and view hyper-realistic 3D models of their food before ordering.

Tools and Technologies Used

• Unity & AR Foundation: For a stable tablet experience.
• Photogrammetry software (RealityCapture): To generate realistic 3D food models.
• Firebase Firestore: To fetch live pricing and descriptions.

How to Make It

• Use photogrammetry to take hundreds of photos of real dishes (like a burger or a pasta plate) and process them into highly realistic, textured 3D models.
• Build a polished UI in Unity that fetches the menu item names, prices, and descriptions from a Firebase database in real-time.
• When the user selects a dish, spawn the 3D photogrammetry model on an AR plane directly in front of them on their physical table.
• Add an "Order Now" button in the AR space that pushes a POST request to the restaurant's Point of Sale (POS) system.

3. Interactive Human Anatomy Visualizer

This project deals with complex 3D hierarchies and educational interaction. You will build a medical app that displays a full 3D human body, allowing students to peel back layers of skin, muscle, and bone interactively.

Tools and Technologies Used

• RealityKit / Swift: For high-performance rendering.
• Custom UI Sliders: To control visibility layers.
• Raycasting: For selecting specific organs.

How to Make It

• Source a medically accurate 3D model of the human anatomy, ensuring systems (skeletal, muscular, nervous) are separated into distinct sub-meshes.
• Anchor the model to a tabletop using ARKit.
• Build a 2D UI slider on the screen. Map the slider's value to the material transparency of the different sub-meshes (e.g., sliding left fades out the skin to reveal the muscles, sliding further reveals the skeleton).
• Implement a tap-to-select feature using a Raycast; when a student taps the 3D heart, highlight the mesh with a glowing shader and display a text panel detailing its biological functions.

Also Read: Top 28 Robotics Project Ideas for Students in 2026 

4. Indoor Wayfinding Navigation

This project tackles the difficult challenge of indoor localization where GPS signals fail. You will build an app that draws an AR path (like a glowing line) on the floor of a supermarket to guide users to specific products.

Tools and Technologies Used

• Azure Spatial Anchors: For cross-platform, persistent indoor mapping.
• Unity NavMesh: For calculating the shortest path avoiding physical obstacles.
• C#: For pathfinding logic.

How to Make It

• Physically walk through the target building (like a grocery store) mapping the space and dropping Azure Spatial Anchors at key intersections to build a cloud-based coordinate map.
• Use Unity to bake a NavMesh based on the store's digital floor plan.
• When a user opens the app and selects "Find Milk," the app utilizes their camera to recognize the surrounding physical features and localizes them against the Azure Spatial Anchors map.
• Calculate the shortest path from the user's recognized location to the milk aisle using the NavMesh, and render a glowing, animated 3D line on the floor that the user can physically follow.

5. Multiplayer AR Tic-Tac-Toe

This project introduces networking and shared coordinate spaces, a staple in collaborative AR VR projects. You will build a game where two users on different phones see the exact same 3D game board hovering between them in real-time.

Tools and Technologies Used

• ARCore Cloud Anchors: To sync the spatial map between two distinct devices.
• Photon PUN 2 (or Unity Relay): For real-time multiplayer networking.
• Unity: For game logic.

How to Make It

• Player A opens the app, scans their physical table, and drops a 3D Tic-Tac-Toe board. This generates an ARCore Cloud Anchor, uploading the visual feature map of the table to Google's servers and returning a short ID.
• Player A shares this ID with Player B via the network (using Photon). Player B inputs the ID, scans the same physical table, and ARCore perfectly aligns Player B's digital coordinate system with Player A's.
• Write game logic so that when Player A taps a square to place an 'X', an RPC (Remote Procedure Call) is sent via Photon to update the game state, making the 'X' appear instantly on Player B's screen in the exact same physical space.

Also Read: Top 30 Final Year Project Ideas for CSE Students in 2026 

6. AR Vehicle Maintenance Guide

This project leverages advanced object tracking instead of standard image tracking. You will build a tool that recognizes the physical engine bay of a specific car and overlays 3D arrows pointing to the oil dipstick and coolant reservoir.

Tools and Technologies Used

• Vuforia Object Scanner or ARKit Object Capture: To map 3D physical objects.
• Unity: For UI and 3D arrow rendering.
• Post-Processing Stack: For glowing outlines.

How to Make It

• Use an object scanning app to physically scan the engine bay of a target vehicle, generating a 3D object tracking dataset.
• Import this dataset into Unity. When the user's camera recognizes the distinct 3D shape of the engine block, lock the digital coordinate system to it.
• Spawn brightly colored, floating 3D arrows and text labels specifically anchored to the coordinates of the oil cap and battery terminals.
• Add an interactive checklist UI on the screen; as the user completes steps (e.g., "Check Oil"), the AR arrows sequentially guide them to the next component in the physical engine bay.

7. Virtual Try-On for Jewelry/Glasses

This project requires high-precision face tracking and physically based rendering (PBR) to make digital objects look real. You will build an e-commerce try-on tool for reflective objects like gold necklaces or sunglasses.

Tools and Technologies Used

• DeepAR SDK or MediaPipe: For advanced, lightweight face and neck tracking.
• WebGL/JavaScript: For a browser-based integration.
• PBR Shaders: To calculate realistic lighting and reflections.

How to Make It

• Integrate the DeepAR SDK into a web application to access 68-point facial mesh tracking and head rotation matrices.
• Import highly detailed 3D models of glasses. Apply PBR materials, specifically tweaking the "metalness" and "roughness" maps so the gold frames and glass lenses react to light.
• Attach the 3D glasses strictly to the bridge of the nose coordinate on the face mesh.
• Capture the user's live camera feed and use it as a dynamic environment map (reflection probe) on the 3D lenses, making it look as though the digital glasses are genuinely reflecting the user's real-world room.

Also Read: Best Computer Science Project Ideas (2026) for CSE Students 

Advanced Level AR Projects

These AR Projects represent the absolute bleeding edge of immersive AR VR projects. They require integrating hardware sensors, utilizing artificial intelligence, managing environmental occlusion, and pushing the boundaries of mobile GPU performance.

1. Real-Time Translation AR Glasses Simulator

This project simulates the HUD (Heads Up Display) of future smart glasses. You will build a mobile app that uses Optical Character Recognition (OCR) to read foreign text in the real world and overlay the translated text perfectly on top of the physical sign in AR.

Tools and Technologies Used

• Google ML Kit (Vision API): For on-device, real-time OCR.
• DeepL API or Google Translate API: For high-accuracy translation.
• AR Foundation: To render the text in 3D space.

How to Make It

• Extract every frame from the AR camera feed and pass it to Google ML Kit to detect the bounding boxes of physical text (e.g., a street sign in Japanese).
• Send the extracted Japanese string to the DeepL API to retrieve the English translation.
• In Unity, spawn a 3D TextMeshPro object containing the English text. Calculate the size and rotation of the ML Kit bounding box to scale the 3D text perfectly.
• Apply a shader to the text background that matches the average color of the physical sign, effectively erasing the Japanese text and replacing it seamlessly with the English translation in 3D space.

Also Read: Top Real Time Project Ideas Every Tech Student Should Try 

2. Room-Scale AR Escape Room Game

This project handles complex state machines and environmental occlusion. You will build an immersive game where the user's actual physical room becomes the escape room, forcing them to find digital clues hidden behind physical furniture.

Tools and Technologies Used

• ARKit Scene Geometry (LiDAR): To generate a 3D mesh of the physical room.
• AR Foundation: For logic and rendering.
• NavMesh & AI: For interactive virtual creatures.

How to Make It

• Require the user to use a LiDAR-equipped device (like an iPad Pro). Utilize ARKit to aggressively scan the environment, generating a physical mesh of their walls, floors, and couches.
• Apply a special "Occlusion Material" to this generated mesh. This makes the physical furniture invisible to the camera, but allows it to block the rendering of 3D objects (so a digital monster can actually hide behind a physical sofa).
• Spawn interactive puzzle elements (like a safe or a keypad) anchored to the detected physical walls.
• Implement a state machine that tracks puzzle completion, culminating in a digital hole breaking through the physical floor to reveal the escape path.

3. Precision Surgical Assistance HUD

This project demands absolute millimeter precision and represents enterprise medical AR. You will build a prototype application that overlays CT scan data onto a physical anatomical training dummy to assist surgeons.

Tools and Technologies Used

• Vuforia Advanced Model Targets: For sub-millimeter object tracking.
• DICOM to 3D Conversion tools: To parse medical scan data.
• Unity HDRP: For hyper-realistic volume rendering.

How to Make It

• Convert a patient's raw CT or MRI scan data (DICOM files) into a 3D volumetric model utilizing Python libraries or medical software.
• Use Vuforia's Model Targets to scan the physical surgical dummy. This tracking is vastly more precise than image tracking, utilizing the physical contours of the dummy to lock the coordinate system.
• Overlay the 3D CT scan data perfectly inside the physical dummy.
• Build a UI utilizing hand-tracking (if using a headset like HoloLens) or voice commands, allowing the surgeon to say "Hide Ribcage" to visually isolate the internal organs in AR without touching a screen.

Also Read: Top Hackathon Project Ideas for Fast, Scalable Prototypes 

4. Industrial IoT AR Dashboard

This project merges hardware data streams with spatial interfaces. You will build an application for factory workers where pointing a tablet at a physical machine (like a CNC router) displays floating, real-time data charts regarding its temperature and RPM.

Tools and Technologies Used

• MQTT Protocol: For low-latency, lightweight IoT messaging.
• ARCore Augmented Images: To track the machines via QR codes.
• Unity & Third-party Charting Assets: To draw data visually.

How to Make It

• Attach unique QR codes or distinct image markers to various physical machines on the factory floor.
• Set up an MQTT client in Unity that subscribes to the live telemetry data (temperature, pressure, RPM) being broadcast by the machine's actual hardware sensors.
• When the AR camera detects a machine's specific QR code, instantiate a 3D dashboard anchored above the machine.
• Parse the incoming MQTT JSON payload and dynamically update 3D gauges, progress bars, and warning lights. If the temperature exceeds safe limits, make the AR dashboard pulse red and emit an alarm.

5. Location-Based AR MMO (Pokemon Go Style)

This project requires master-level database architecture and geospatial math. You will build a massive multiplayer platform where digital resources and monsters spawn at exact physical GPS coordinates across a real-world city.

Tools and Technologies Used

• Mapbox Maps SDK for Unity: To render real-world maps in 3D.
• Node.js & MongoDB (Geospatial Indexing): To manage the backend coordinates.
• ARCore: For the encounter phase.

How to Make It

• Integrate the Mapbox SDK to render a stylized 3D map based on the user's real-world GPS location, updating their avatar as they physically walk down the street.
• On the backend, use MongoDB's geospatial queries ($nearSphere) to efficiently calculate if the user is within 50 meters of a spawned digital monster.
• When the user gets close and taps the monster, seamlessly transition from the Mapbox GPS view into an ARCore camera view.
• Anchor the 3D monster to the physical ground using AR plane detection, and implement swipe physics allowing the user to throw digital projectiles at the creature to capture it.

6. Collaborative 3D Modeling Workspace

This project bridges different hardware ecosystems. You will build a shared workspace where User A (on a mobile phone in AR) and User B (in a Meta Quest headset in VR) can manipulate the same 3D architectural model simultaneously.

Tools and Technologies Used

• Unity XR Interaction Toolkit: For cross-platform input handling.
• Normcore or Photon Fusion: For highly synchronized physics and transforms.
• ARKit / Oculus Integration: For platform-specific rendering.

How to Make It

• Build a Unity project with two distinct camera rigs: an AR rig for mobile and a VR rig for the headset.
• Integrate Normcore to handle the multiplayer synchronization. Instantiate a 3D architectural building model in the shared network scene.
• Write cross-platform interaction logic: the VR user can grab and scale the building using their physical hands/controllers, while the AR user can walk around their physical table to view the changes in real-time.
• Broadcast a 3D representation of the VR user's head and hands to the AR user, so the person looking through the phone can literally see where the VR user is pointing in physical space.

7. AI-Powered Generative AR Avatar

This project combines Generative AI with spatial computing. You will build an AR application where a user spawns a 3D historical figure (e.g., Abraham Lincoln) in their room and can have a real-time, spoken conversation with them.

Tools and Technologies Used

• OpenAI GPT-4 API: For the conversational brain.
• ElevenLabs API: For realistic, cloned voice generation.
• Oculus Lipsync or Salsa LipSync: To animate the 3D model's mouth based on audio.

How to Make It

• Anchor a rigged 3D model of the character in the AR environment using standard plane detection.
• Record the user's spoken question via the device microphone, convert it to text using a Speech-to-Text API, and send it to GPT-4 with a strict system prompt instructing it to respond in character.
• Stream the LLM's text response into the ElevenLabs API to generate an authentic-sounding audio file.
• Feed the incoming audio file into a LipSync script attached to the 3D model, which automatically analyzes the audio waveform and drives the blend shapes of the model's mouth, making it look like the avatar is actually speaking the generated words in the user's physical room.

Conclusion

AR projects help you build interactive applications that connect digital content with the real world. Start with simple ideas to learn tracking and 3D interaction, then move to advanced systems with AI and real-time features.

Focus on practical AR projects that improve user experience and solve real problems. This approach helps you build strong skills and create impactful augmented reality applications.

"Want personalized guidance on AI and upskilling opportunities? Connect with upGrad’s experts for a free 1:1 counselling session today!"   

Similar Reads:   Top 25+ SaaS Project Ideas in 2026  40 Must-Try JavaScript Project Ideas for Developers of All Levels  Top 20 Real-Time React Projects and Ideas for Beginners in 2026  GitHub Project on Python: 30 Python Projects You’d Enjoy   15+ Web Development Projects   30 Best Cyber Security Projects Ideas in 2026   35+ Android Projects with Source Code You MUST Try in 2026 (Beginner to Final-Year)   Top 36+ Python Projects for Beginners in 2026  Top 45+ Nodejs Project Ideas for Beginners and Professionals   Top 21+ Next.js Project Ideas in 2026  Top 30 Django Project Ideas for Beginners and Professionals   15 Best Full Stack Coding Project Ideas & Topics For Beginners   Top 20+ Generative AI Project Ideas in 2026