Inspiration
We believe a smartphone should be more than a device for consuming technology — it should also be a device for creating it.
Students and developers often have access to a phone but not always to a powerful laptop or desktop. Existing mobile coding apps are useful for writing small programs, but they often lack the complete workflow of a modern IDE: project management, multi-file editing, code execution, debugging, visualization, and intelligent assistance.
That inspired us to build HyperIDE AI, a mobile-first development environment that combines a powerful code editor with Google Gemini to make coding, debugging, and learning possible from anywhere.
Our vision was simple:
Turn an Android phone into a portable AI-powered development workspace.
What it does
HyperIDE AI brings the essential features of a modern IDE into a single Android application.
Users can:
- Create and manage multi-file projects
- Browse files and folders
- Write code using a syntax-highlighted editor
- Run programs directly from the phone
- Provide interactive standard input
- View compiler and runtime output
- Track execution history
- Search and replace code
- Generate code flowcharts
- Use programming templates and practice programs
- Preview HTML/CSS projects
- Get AI-powered coding assistance using Gemini
The Gemini-powered assistant can help users understand code, generate suggestions, analyze errors, and propose fixes based on compiler output and the current source code.
HyperIDE AI also uses multiple execution providers, including Judge0, Piston, Docker, and WebSocket-based providers, allowing the execution system to use fallback providers when required.
The result is a complete workflow:
Write → Run → Detect errors → Ask AI → Fix → Run again → Learn
How we built it
HyperIDE AI was built as a native Android application using Kotlin and Jetpack Compose.
We designed the application with a modular architecture so that the editor, project management, AI assistant, execution engine, database, and UI can evolve independently.
For local persistence, we use Room Database to manage projects, files, execution information, and other application data.
The code execution system was designed around an abstraction layer that allows HyperIDE AI to communicate with different execution providers. This makes it possible to support multiple programming environments without tightly coupling the application to a single backend.
For AI capabilities, we integrated Google Gemini directly into the development workflow. Instead of treating AI as a separate chatbot, HyperIDE AI provides contextual assistance based on the user's code, programming language, and compiler errors.
The UI was built with Jetpack Compose to create a responsive developer experience optimized for mobile screens.
Challenges we ran into
One of our biggest challenges was running code from a mobile application.
Different programming languages require different compilers and runtime environments, and providing all of them directly on an Android device is difficult. We solved this by creating a flexible execution architecture that can communicate with multiple execution providers.
Another challenge was handling interactive programs. Programs that require user input cannot simply be executed and forgotten. We had to design a workflow for detecting input requirements and allowing users to provide stdin during execution.
Integrating Gemini effectively was another challenge. We wanted the AI to provide useful programming assistance rather than generic responses. This required passing relevant context such as source code, programming language, and compiler errors into the AI workflow.
We also faced the challenge of designing a feature-rich IDE for a small mobile screen. We had to carefully organize tools, panels, editors, project navigation, and AI features without making the interface overwhelming.
Accomplishments that we're proud of
We are proud that HyperIDE AI evolved from the idea of a simple mobile code editor into a much more complete development environment.
Some of our biggest accomplishments are:
- Building a native Android IDE using Kotlin and Jetpack Compose
- Integrating Gemini directly into the coding workflow
- Supporting multi-file project development
- Creating a multi-provider code execution architecture
- Supporting interactive program input
- Adding AI-assisted error analysis and fixing
- Building code flowchart visualization
- Adding programming practice and starter templates
- Creating an HTML/CSS preview workflow
- Implementing persistent local project management
Most importantly, we built the project around a real problem: making development more accessible when a computer isn't available.
What we learned
Building HyperIDE AI taught us that creating a mobile IDE is much more complex than creating a text editor.
We learned about Android application architecture, Jetpack Compose, local persistence with Room, remote code execution, compiler/runtime error handling, WebSocket communication, API integration, and designing complex developer tools for mobile interfaces.
We also learned how to integrate generative AI into an existing workflow.
Gemini becomes much more useful when it receives the right context. Instead of simply asking an AI to "write code," HyperIDE AI can provide the current code and compiler feedback so that the AI can help the developer understand and solve the actual problem.
This changed our perspective on AI: the most useful AI tools are often the ones embedded directly into the workflow where the problem occurs.
What's next for HyperIDE AI
HyperIDE AI is designed to grow beyond a mobile code editor.
Our next goals include:
- Expanding programming-language support
- Improving AI-powered debugging
- Adding smarter code completion
- Improving offline development capabilities
- Adding stronger cloud synchronization
- Supporting collaborative coding
- Improving project management
- Adding AI-powered code explanations and learning paths
- Introducing more advanced code visualization
- Building a stronger plugin/extension architecture
Our long-term vision is to make HyperIDE AI a complete AI-native development environment for mobile devices.
We want students to be able to learn programming, developers to prototype ideas, and creators to build real software — even when they only have a smartphone.
HyperIDE AI is built around one idea:
Your development environment should be wherever you are.
Log in or sign up for Devpost to join the conversation.