AI GamingGPT & Claude

Triomelette Profiler AI

## Target Users Profiler AI is designed for video game developers, game development studios, and QA teams using Unity who need to identify and resolve performance issues during gameplay. Our primary users are developers who experience FPS drops, frame-time spikes, excessive memory allocations, or other performance bottlenecks but need to spend significant time investigating Unity Profiler data to understand their causes. The platform is particularly useful for small and medium-sized game development teams that want to simplify performance analysis without requiring every team member to have advanced profiling expertise. ## The Problem We Solve Identifying performance bottlenecks in games can be a time-consuming and technically demanding process. Developers often need to manually inspect profiler data, identify expensive functions, investigate source code, and determine which optimizations will have the greatest impact. When multiple testers encounter performance issues on different machines, comparing their findings can become even more challenging. Traditional profiling tools provide valuable technical data, but interpreting that data and turning it into actionable solutions still requires considerable developer effort. Profiler AI bridges this gap by automatically collecting Unity performance data, consolidating reports from testers, and using AI to explain potential causes and recommend optimizations through a centralized dashboard. Instead of manually searching through extensive profiling data, developers can quickly identify the most problematic functions, understand why they might be affecting performance, and prioritize the issues that need attention. Our goal is to help game development teams spend less time investigating performance problems and more time building smoother, better-performing games.

Open the demo GitHub

Preliminary score

46.0/ 100Earlyaverage of 2 judges

Value for the user17.5 / 25
A specific problem and a clear outcome from solving it.
Prototype and use of AI10.0 / 30
A working core scenario, and what AI actually contributes to the result.
Quality testing5.5 / 20
Tests, examples of failures, and comparison with the current approach.
Feasibility7.0 / 15
Data requirements, running costs and a clear next step.
Originality6.0 / 10
A meaningful difference from common solutions.

What the judges wrote

GPT-6 AstraPreliminary50/100
Strengths
Your focus on Unity developers and QA teams addresses a concrete problem: translating frame-time spikes into actionable debugging work. Your reported real-game test covers the Unity-to-backend-to-dashboard pipeline, while aggregating reports from multiple testers provides a useful team workflow. Your explicit treatment of AI explanations as hypotheses requiring verification is technically sound.
To improve
Your validation section lists AI integration as future work, so demonstrate one captured spike producing an actual Gemini diagnosis, a suggested fix, and measured results after applying it. Add repeatable bottleneck tests, document missed or misleading diagnoses, and compare investigation time against manual Unity profiling. Specify profiler and source-code data requirements, estimate inference and storage costs, and replace the template README with reproducible setup instructions.
Claude Opus 5.5Preliminary42/100
Strengths
Your problem framing is concrete and credible: Unity developers who struggle to turn raw Profiler data into fixes, backed by your own 113.7 ms recorded frame against a 33.3 ms budget. You report an end-to-end data path from a real Unity game, through your exporter script and Spring Boot backend, to the dashboard, which is the hard plumbing part of this idea. Combining slow-frame data from multiple testers on different hardware into one ranked hotspot view is a useful step beyond a single-machine profiler. You are also candid that AI suggestions are hypotheses that must be verified by re-running the game.
To improve
By your own testing write-up, the Gemini analysis step is still a next step, so AI does not yet contribute to the demonstrated result. Show at least one real slow frame going into Gemini and the explanation and fix it returns, and check whether that fix actually lowered frame time. Your repository README is still the default Vite template, and the dashboard screenshot (an RTX 4080, a PS5 dev kit and a Steam Deck) looks like mock data; document the real setup and label which data is live. Add testing cases where the AI's diagnosis was wrong, compare your diagnosis time with manual Profiler inspection, and estimate Gemini cost per report.

The team

Rafiq SafarovLead
developer
Yadulla Mirzayev
developer
Irada Amirli
developer

Disclosure

Required by the rules. Judges verify it against the repository.

Models: Gemini
Data: Public, gameplay runtime.
Components: React, Java/Spring, Unity, Postgresql, Google Cloud Platform
Built during the event: Confirmed

Quality testing

# Product Testing and Validation We tested Profiler AI using a real Unity game to validate the core functionality of our solution in a practical environment. We integrated our custom monitoring script into the Unity project, launched the game, and played it while the script was running. During gameplay, the script collected performance data from Unity's Profiler and generated reports containing information about the game's performance. These reports were transmitted to our backend, where the incoming data was processed and made available to the dashboard. We then verified that the dashboard could successfully fetch and display the reports received from the running game. This confirmed that the core data pipeline—from Unity's profiling environment to our backend and finally to the dashboard—was functioning as intended during our test. This test was an important milestone for the project because it demonstrated that Profiler AI could work with a real game rather than relying solely on simulated data or predefined examples. We successfully validated the integration between the Unity monitoring script, the backend data pipeline, and the dashboard's reporting interface. With this foundation in place, our next steps are to further validate performance issue detection, improve the analysis of collected profiler data, integrate AI-generated explanations and optimization recommendations, and measure performance improvements before and after applying fixes.

Worth 20 of the 100 points.

Running it

Profiler AI is an AI-powered Unity game performance monitoring and analysis platform. It helps game developers identify performance issues that occur during gameplay, understand their potential causes, and discover how to fix them through a centralized dashboard. 1. Install a Custom Unity Script The developer imports a dedicated Profiler AI script into their Unity project. Once configured and running in the Unity Editor, this script automatically collects performance data while the developer or tester plays the game. The script monitors Unity Profiler data to detect performance issues such as sudden frame-time spikes, FPS drops, expensive functions, and excessive memory allocations. The developer does not need to manually collect and upload reports every time a performance issue occurs. Data collection happens automatically while the monitoring script is active and the required Unity profiling features are enabled. 2. Send Performance Data Through the MCP Integration When the script detects a performance problem, it packages the relevant profiler measurements into a structured data report and sends them to our backend. The backend acts as the connection between Unity, the AI analysis system, and our dashboard. The MCP server can expose this collected information through tools, allowing compatible AI clients to retrieve and investigate performance data when needed. One technical distinction is important: the Unity script would normally send data to our backend through an HTTP or WebSocket connection. MCP provides a separate interface for AI tools to access that data; it is not itself the automatic transport mechanism from Unity. 3. Analyze the Problem With AI The backend processes the incoming reports, identifies the most expensive functions, and combines relevant measurements from different testers. The AI then analyzes the performance evidence and, when the corresponding source code is available, investigates potential causes. It generates an actionable report containing: - Problem identification: Which function or script is associated with the slowdown. - Performance evidence: Frame time, execution time, memory allocations, and affected testers. - Potential root cause: The code patterns that may be contributing to the issue. - Suggested solution: Specific code optimizations the developer can investigate. - Priority and estimated impact: Which issues deserve attention first and what improvements might be possible. AI-generated explanations are hypotheses until the developer verifies them. Actual performance improvements must be confirmed by testing the game again. 4. View Everything on the Dashboard All collected performance data and AI-generated reports appear on our centralized dashboard, where developers can monitor their games in real time. The dashboard allows developers to: - Monitor connected testers and incoming performance data. - View frame-time graphs and identify moments when the game slows down. - Explore the most expensive functions in a ranked hotspot table. - Open detailed reports with measurements, function call hierarchies, and relevant source code. - Read AI-generated explanations and recommended optimizations. - Compare performance before and after applying a fix. This gives the development team a shared place to investigate performance problems rather than relying on each tester to manually analyze their own Unity Profiler. 5. Verify the Fix After reviewing the AI report, the developer modifies the relevant code and runs the game again. Profiler AI collects the new performance measurements and displays the results alongside the original data. The developer can then determine whether the optimization reduced frame time, improved FPS, or lowered memory allocations. The goal is to create a continuous workflow: detect a performance issue, collect evidence, analyze its likely cause, apply a fix, and measure the result.

Project ownership

The team keeps the rights to this project. Judges were given access for verification only.