30 AI Project Ideas for Class 10

Artificial Intelligence (AI) is no longer only for college students or big companies.

Even Class 10 students can build simple, useful AI projects that teach fundamental concepts such as data collection, pattern recognition, model training, and evaluation.

This article lists 30 AI project ideas for Class 10 explained in clear, student-friendly language.

Each idea includes the objective, tools you can use, a simple step-by-step plan, expected outcome, and one or two “extension” ideas if you want to make the project more advanced.

These projects are chosen to be practical, low-cost, and doable with basic programming knowledge (Python is recommended) or block-based tools like Scratch plus cloud tools or easy online AI platforms.

If you are new to AI, start with the simpler projects (marked “Easy”) and move to intermediate projects when you feel ready. Use this article as a guide to pick a project for school fairs, class assignments, or personal learning. Let’s get started!

Must Read: 29+ Social Media Project Ideas for Students 2026-27

How to pick an AI project for Class 10

Interest: Choose a topic you care about — games, health, school, or environment.
Time: Pick simple projects if you have a week; choose intermediate projects if you have more time.
Tools & Hardware: Most projects use a computer and internet. For some projects you may need a smartphone or webcam.
Data: Many projects require small datasets. You can create your own or use publicly available small datasets.
Safety & Privacy: Don’t collect personal data without consent. Use sample or synthetic data where possible.

1. Face Mask Detector (Easy)

Objective: Detect if a person is wearing a mask using a webcam image.
Tools: Python, OpenCV, pre-trained MobileNet or simple CNN, Google Colab (optional).
Steps:

Collect a small dataset of masked and unmasked faces (or use public datasets).
Preprocess images (resize, normalize).
Use transfer learning with a pre-trained model (MobileNet) and train the final layers.
Test using webcam image and show “Mask” / “No Mask”.
Expected outcome: A program that reads webcam input and displays mask detection result.
Extensions: Add detection for correct mask-wearing (covering nose) or count how many people wear masks in a frame.

2. Spam Message Classifier (Easy)

Objective: Classify SMS or short messages as spam or not spam.
Tools: Python, scikit-learn, pandas, NLTK (for text cleaning).
Steps:

Use an existing SMS spam dataset (many small datasets are publicly available).
Clean text (lowercase, remove punctuation).
Convert text to numeric features using TF-IDF or CountVectorizer.
Train a simple classifier (Naive Bayes or Logistic Regression).
Test with sample messages.
Expected outcome: A console or web app that labels messages as “Spam” or “Not Spam”.
Extensions: Build a small email-like interface and show accuracy metrics.

3. Handwritten Digit Recognizer (Easy)

Objective: Recognize digits 0–9 from images (MNIST-style).
Tools: Python, TensorFlow/Keras or scikit-learn, Google Colab.
Steps:

Use MNIST dataset (preloaded in many libraries).
Build a simple neural network (Fully Connected or small CNN).
Train and evaluate accuracy.
Create a drawing widget where students draw digits and the model predicts.
Expected outcome: A small app that recognizes drawn digits with good accuracy.
Extensions: Add recognition for letters (A–Z) or support multi-digit input.

4. Fruit/Vegetable Classifier (Easy — Camera Based)

Objective: Identify common fruits and vegetables in images.
Tools: Python, TensorFlow/Keras, OpenCV, or Teachable Machine.
Steps:

Collect images of 4–6 types of fruits/vegetables (apple, banana, tomato, potato, etc.).
Train a simple CNN or use Teachable Machine for quick model building.
Deploy to a webcam app to show predictions.
Expected outcome: A demo where the webcam recognizes a fruit placed in view.
Extensions: Add a price estimator or nutritional facts display.

5. Simple Chatbot for School Queries (Easy)

Objective: Build a rule-based or simple ML chatbot to answer common school questions.
Tools: Python, NLTK, or Dialogflow (free tier) for an easier setup.
Steps:

List common questions (class timings, holidays, fees).
Create responses manually or use retrieval-based ML with small dataset.
Build a chat interface (web page or console).
Expected outcome: A chatbot that responds to student queries about school.
Extensions: Add small talk capability or connect to a school calendar.

6. Emotion Detection from Text (Intermediate)

Objective: Detect emotions (happy, sad, angry, neutral) from short sentences.
Tools: Python, scikit-learn or simple neural network, publicly available emotion datasets.
Steps:

Gather small labelled sentences for emotions.
Clean and vectorize text (TF-IDF or word embeddings).
Train a classifier (SVM or small neural network).
Test on new sentences.
Expected outcome: A web or console tool labeling input text with an emotion.
Extensions: Combine with voice input or visualization of emotional trends.

7. Music Genre Classifier (Intermediate)

Objective: Classify short music clips into genres (classical, pop, rock).
Tools: Python, librosa (audio features), scikit-learn or Keras.
Steps:

Use a small dataset of short audio clips for 3–4 genres.
Extract features (MFCCs, chroma).
Train a simple classifier.
Build a UI to upload a clip and show genre prediction.
Expected outcome: A working classifier for short audio samples.
Extensions: Add song recommendation based on predicted genre.

8. Hand Gesture Control for Slides (Intermediate)

Objective: Use hand gestures to control slide navigation (next/previous).
Tools: Python, OpenCV, MediaPipe (hand detection), keyboard simulation library.
Steps:

Use MediaPipe to detect hand landmarks.
Detect a few gestures (open palm for next, fist for previous).
Map gestures to keyboard events (arrow keys).
Test with a slideshow application.
Expected outcome: Hands-free control of slides during a presentation.
Extensions: Add gesture to start/stop video, or annotate slides.

9. Weather Chat Assistant (Easy)

Objective: A simple assistant that returns weather information for a city using APIs.
Tools: Python, requests, OpenWeatherMap API (free tier), simple front end.
Steps:

Register for free API key.
Build a small chatbot UI that asks for city name.
Fetch weather data from API and parse results.
Display current temperature and weather description.
Expected outcome: A chat-like app that gives weather updates.
Extensions: Add forecasts and advice (carry umbrella etc.).

10. Plant Disease Identifier (Intermediate)

Objective: Identify common leaf diseases in plants using leaf images.
Tools: Python, TensorFlow/Keras, dataset of diseased and healthy leaves.
Steps:

Collect images (healthy vs diseased) for 2–3 plants.
Preprocess images and augment data.
Train a CNN or use transfer learning.
Create a simple app to upload leaf images and show diagnosis.
Expected outcome: A helpful tool for small gardeners that flags disease.
Extensions: Suggest remedies or link to treatment steps.

11. AI-based To-Do Prioritizer (Easy)

Objective: Rank tasks by priority based on short descriptions.
Tools: Python, rule-based heuristics or simple ML classifier.
Steps:

Define rules (deadline words, urgent, important).
Optionally collect small dataset of tasks labeled high/low priority.
Implement model to suggest priority and order tasks.
Build a simple UI to enter tasks.
Expected outcome: A to-do app that sorts tasks and flags urgent ones.
Extensions: Add reminders or calendar integration.

12. Fake News Detector (Intermediate)

Objective: Classify short news headlines as likely real or fake.
Tools: Python, scikit-learn, small labelled dataset for headlines.
Steps:

Gather headlines labeled real/fake (small datasets exist).
Clean text and vectorize.
Train a classifier (Logistic Regression or Naive Bayes).
Build UI to test headlines.
Expected outcome: A tool that warns if a headline looks suspicious.
Extensions: Explain which words led to the prediction (simple explainability).

13. Optical Character Recognition (OCR) for Notes (Intermediate)

Objective: Convert photographed handwritten notes to typed text.
Tools: Python, Tesseract OCR, OpenCV for preprocessing.
Steps:

Capture clear images of typed or neat handwritten notes.
Preprocess (grayscale, threshold) to improve OCR accuracy.
Apply Tesseract and output text.
Provide a simple editor to correct errors.
Expected outcome: Digitized notes ready to copy-paste.
Extensions: Add language detection or export to PDF.

14. Traffic Sign Recognition (Intermediate)

Objective: Recognize common traffic signs from images.
Tools: Python, Keras or scikit-learn, small traffic sign dataset (or create your own).
Steps:

Collect images of several sign classes (stop, speed limit, pedestrian).
Train a small CNN model.
Use webcam or test images to predict sign type.
Expected outcome: Model that identifies signs with reasonable accuracy.
Extensions: Build an educational game that quizzes students on sign meanings.

15. Movie Recommendation System (Intermediate)

Objective: Recommend movies based on user ratings or a small preference input.
Tools: Python, pandas, simple collaborative filtering or content-based filtering.
Steps:

Use a small movie dataset with genres and ratings.
Implement content-based recommender using genre similarity or simple user-item matrix.
Take user input and display recommended movies.
Expected outcome: A basic recommender to help choose movies.
Extensions: Allow users to rate movies and improve suggestions.

16. Digitized Library Search (Easy)

Objective: Build a searchable system for a small collection of book summaries using NLP search.
Tools: Python, simple text embeddings (Sentence Transformers if available), or TF-IDF.
Steps:

Create a dataset of your school library books with short summaries.
Vectorize summaries and implement cosine similarity search.
Build a search UI where a query returns best matching books.
Expected outcome: Students can find books by entering topic or keywords.
Extensions: Add borrowing status and recommendation based on reading history.

17. Voice Assistant for Simple Tasks (Intermediate)

Objective: Voice-based assistant that opens websites, tells time, or plays a song.
Tools: Python, speech_recognition library, pyttsx3 for text-to-speech, webbrowser module.
Steps:

Use speech_recognition to capture voice.
Process commands with simple if-else or NLP.
Use pyttsx3 to reply and perform tasks (open YouTube, search Wikipedia).
Expected outcome: A basic voice assistant that responds to a few commands.
Extensions: Integrate weather, reminders, or a school calendar.

18. Number Plate Reader (Advanced-Intermediate)

Objective: Read vehicle number plates from images.
Tools: Python, OpenCV, EasyOCR or Tesseract OCR.
Steps:

Detect the plate region using contour detection.
Preprocess and feed into OCR.
Parse characters and format the number.
Expected outcome: Extracted plate text from photo or video frame.
Extensions: Add logging of plates and timestamps for practice projects (avoid privacy misuse).

19. Signature Verification (Advanced-Intermediate)

Objective: Verify whether a signature is genuine using image comparison.
Tools: Python, OpenCV, feature extraction or simple Siamese network for images.
Steps:

Collect sample genuine and forged signatures (small dataset).
Extract features (keypoints or embeddings).
Compare similarity and set a threshold for acceptance.
Expected outcome: A prototype that flags potential forgeries.
Extensions: Make it robust against rotation/scale; use it for school certificate verification practice.

20. Disease Prediction from Symptoms (Easy, Rule-Based)

Objective: Suggest possible diseases from a set of entered symptoms (educational only).
Tools: Python, list of common symptom-disease mappings, simple logic rules.
Steps:

Create a small database mapping symptom sets to likely conditions.
Build an input form where users choose symptoms.
Return a short list of possible conditions and advice to consult a doctor.
Expected outcome: Educational tool that suggests likely conditions and warnings.
Extensions: Replace rules with a trained classifier using small dataset (requires caution).

21. Road Crack Detection (Intermediate)

Objective: Detect cracks in road images to help maintenance prioritization.
Tools: Python, OpenCV, simple CNN or image segmentation model.
Steps:

Collect images of roads with and without cracks.
Train a classifier or segmentation model to highlight cracks.
Visualize output overlay on images.
Expected outcome: A program that marks crack areas for inspection.
Extensions: Estimate crack area and generate a simple report.

22. Language Translator (Beginner-Intermediate)

Objective: Translate short sentences from one language to another using APIs.
Tools: Python, Google Translate API (or free alternatives), simple UI.
Steps:

Use API to translate input text from language A to B.
Create UI for input and output.
Optionally add speech-to-text for voice input.
Expected outcome: Basic translator useful for schoolwork or travel.
Extensions: Add multiple language support and offline translation for common phrases.

23. Visual Math Solver (Intermediate)

Objective: Recognize hand-written math problems and solve them (simple arithmetic).
Tools: Python, OpenCV, OCR, simple math parser.
Steps:

Capture handwritten arithmetic expressions.
Use OCR or digit/character recognition for numbers and operators.
Parse the expression and compute result.
Expected outcome: App that takes a picture of a handwritten sum and returns the answer.
Extensions: Support multi-line equations or algebraic simplifications.

24. Dataset Visualizer & Explorer (Easy)

Objective: Build a small app that visualizes datasets (bar, pie, line) and shows simple stats.
Tools: Python, pandas, matplotlib (or JavaScript visualization).
Steps:

Load a small CSV (school marks, local weather data).
Compute statistics (mean, median).
Plot charts that students can interact with.
Expected outcome: An educational tool to learn data exploration and interpretation.
Extensions: Add filters and trend detection with a simple linear regression.

25. Book Summary Generator (Intermediate)

Objective: Create short, automated summaries of book chapters using simple NLP.
Tools: Python, NLTK or simple extractive summarization methods.
Steps:

Input chapter or article text.
Split into sentences, score sentences by importance (TF-IDF), select top sentences.
Output 3–6 sentence summary.
Expected outcome: Short summaries to help revision or revision notes.
Extensions: Add keyword extraction and highlight important sentences.

26. Handwritten Name Plate Recognition (Easy)

Objective: Read a handwritten name and convert to typed text.
Tools: Python, Tesseract OCR, image preprocessing.
Steps:

Collect neat handwritten name images.
Preprocess (crop, binarize) for OCR.
Use Tesseract to read text and allow corrections.
Expected outcome: A useful tool for digitizing sign-in sheets or attendance.
Extensions: Add database of names for auto-filling and matching.

27. Real-time Object Counter (Intermediate)

Objective: Count objects like pens or bottles on a desk using webcam.
Tools: Python, OpenCV, simple object detection (background subtraction or MobileNet-SSD).
Steps:

Capture frame, detect objects using contour detection or a lightweight detector.
Count detected items and show the count overlay.
Expected outcome: Real-time count display for simple objects.
Extensions: Differentiate by object type and track count changes over time.

28. Handwritten Equation-to-LaTeX Converter (Advanced)

Objective: Convert a photographed handwritten math equation into LaTeX.
Tools: Python, OCR for math (e.g., MathPix API if available) or train a small model for limited symbols.
Steps:

Capture equation image and preprocess.
Use a math OCR tool or pattern matching to identify symbols.
Convert output into LaTeX and display.
Expected outcome: Typed LaTeX code for neat rendering in documents.
Extensions: Support multi-line equations or integrals.

29. Personalized Study Planner Using Simple ML (Intermediate)

Objective: Create a study planner that suggests study times and subjects based on past performance.
Tools: Python, pandas, simple rules or basic regression, UI (spreadsheet or webpage).
Steps:

Collect sample data: study hours vs marks for a few subjects.
Analyze patterns and suggest more study time for weak subjects.
Output a weekly plan with recommended hours.
Expected outcome: A personalized weekly study plan that adapts to weak areas.
Extensions: Add reminders and track progress over weeks.

30. Simple Image Caption Generator (Advanced-Intermediate)

Objective: Generate short captions for images using pre-trained image-to-text models or simple templates.
Tools: Pretrained models (if available), Python, Keras, or rule-based captions using object detection.
Steps:

Detect main objects in image (person, cat, tree) using object detection.
Use a template-based caption like “A [object] near [background]”.
For advanced route, use pre-trained image-captioning models (may require internet/cloud resources).
Expected outcome: A program that generates short descriptive captions for images.
Extensions: Train a small image-captioning model or add multiple language captions.

Tips for Building Your AI Project (for Class 10 students)

Start Small: Don’t try to build a complete product in one go. Make a simple prototype first.
Use Existing Tools: Tools like Google Colab, Teachable Machine, and pre-trained models reduce setup time.
Document Steps: Keep notes of data sources, code, results, and problems you solved — useful for reports and presentations.
Test Often: Small tests help you find bugs early.
Explain Results Clearly: For school projects, focus on explaining how it works, what data you used, and what the results mean.
Be Ethical: Never collect private data without permission. Don’t use sensitive personal information.
Use Version Control: If possible, keep your code in cloud storage or simple version control (like GitHub) so you can show progress.

Resources & Tools Suggested for Beginners

Programming Language: Python (easy, widely used in AI).
Online Notebooks: Google Colab or Jupyter Notebook.
Libraries: OpenCV (images/video), TensorFlow/Keras or PyTorch (models), scikit-learn (classical ML), pandas (data handling), NLTK/Spacy (text).
No-code tools: Teachable Machine (Google) for image/audio models, Dialogflow for chatbots.
APIs: OpenWeatherMap (weather), Google Translate (translation), MathPix (math OCR, may be paid).
Datasets: Use small public datasets from Kaggle, UCI, or create your own small dataset.

Must Read: 25 Decision Making Project Ideas For Student 2026-27

How to Present Your AI Project (for Class 10 science fair)

Title & Objective: Clear and concise — e.g., “Mask Detector for Safety”.
Problem Statement: Why it matters; who it helps.
Method: Simple explanation of steps and tools used — no need to go very technical.
Demonstration: Live demo or recorded video showing the model working.
Results: Show accuracy, success examples, and failure cases. Be honest about limitations.
Conclusion & Future Work: What you learned and how to improve it.

Conclusion

These 30 AI project ideas for Class 10 are designed to be achievable, educational, and interesting. They teach key AI concepts like data preparation, model training, evaluation, and deployment — all at a level suitable for Class 10 students.

Start with easier projects to build confidence (for example, digit recognition, simple chatbots, or image classifiers) and move on to intermediate projects once you understand the basics.

Remember: the main goal is learning — it’s fine if your model isn’t perfect. Document what you tried, show examples where it works, explain where it fails, and propose improvements.

With curiosity and steady practice, you’ll be able to build projects that are useful and impressive for science fairs or school assignments.

Good luck — pick an idea from these ai project ideas for class 10, and start building today!

30 AI Project Ideas for Class 10 – Student-Friendly Projects with Steps, Tools & Tips

How to pick an AI project for Class 10