OnlineAIIDE Documentation
Welcome to the official developer guide for OnlineAIIDE, the browser-based cloud integrated development environment engineered for modern software engineers. OnlineAIIDE unites a high-performance Monaco code editor, terminal emulation, native Git version control, multi-language compilation, interactive DAP debugging, an extensible multi-framework test runner, multi-provider AI pair programming, and a visual drag-and-drop web application builder.
OnlineAIIDE is not limited to a single language or compiler. It supports diverse full-stack development workflows across Java (JDK 8–21+), Spring Boot, Python (3.8–3.14+), Node.js & JavaScript, TypeScript, React, Angular, Go (Golang), and DevOps infrastructure. Whether evaluating in instant zero-setup Guest mode or building production microservices, this guide provides complete, verified instructions.
Getting Started with OnlineAIIDE #
Getting started requires no client-side toolchains, Docker daemons, or compiler installations. OnlineAIIDE runs directly within any modern web browser that supports HTML5 standards and WebAssembly.
First Session Step-by-Step Walkthrough
- Open the IDE: Navigate to the OnlineAIIDE Workspace.
- Select an Access Mode: Work immediately in instant Guest mode for fast evaluation, or sign in to persist custom settings, keymaps, and higher resource quotas.
- Open or Create a Project: Use File > Open Folder to mount a local directory via the File System Access API, or use File > New > Show Gallery to generate a scaffolded Spring Boot, React, or WebApp template.
- Explore the Interface: The workspace layout comprises:
- Activity Bar & Sidebar: File Explorer, Project Explorer, Package Explorer, Search, Source Control, and Extensions.
- Editor Surface: Tabbed Monaco editor with split-pane capability and breadcrumb navigation.
- Bottom Panel: Integrated PTY Terminal, Output log streams, Problems diagnostics, and Test Explorer.
- AI Panel: Conversational coding assistant, code generator, and autonomous task executor.
Account Creation and Authentication #
OnlineAIIDE provides flexible, secure authentication architectures supporting both quick guest sessions and authenticated team accounts:
Instant evaluation without registration. Access includes a starter quota for builds, executions, debugging sessions, and AI queries.
Register with an email address and verified One-Time Password (OTP) for durable preference storage, project bookmarks, and elevated plan quotas.
One-click OAuth authentication with Google, Microsoft, and Apple identity providers.
Saved preferences synchronize your active theme (Dark, Light, High Contrast), font size, editor indentation, locale, and configured AI models across sessions.
To protect user privacy and account security, account workflow screens (such as sign-in and registration forms)
are excluded from search engine indexing via explicit noindex directives while remaining accessible
to users and crawlers alike.
Creating and Managing Projects #
The workspace accommodates both simple script directories and complex enterprise multi-module architectures:
Multi-View Explorer Hierarchy
- File Explorer: Direct filesystem representation showing physical files, assets, and directory structures.
- Project Explorer: Project-centric view filtering compilation noise, categorizing source folders (
src/main/java,src/test/java), and exposing project lifecycle actions. - Package Explorer: Java-aware package hierarchy grouping classes by namespace, libraries, and external JAR dependencies.
Project Scaffolding via Show Gallery
Use File > New > Show Gallery to open the integrated project generator. Starter templates include Java Spring Boot REST applications, modern React frontends, and vanilla web applications with pre-configured build descriptors and testing scaffolding.
Editing Code Using Monaco Editor #
OnlineAIIDE embeds the industry-standard Monaco Editor engine, delivering the responsiveness and muscle of desktop editing inside the web browser:
- Keyboard Shortcuts: Full fidelity with standard VS Code keybindings for code navigation, multi-cursor editing, command palette (
Ctrl/Cmd + Shift + P), and quick file open (Ctrl/Cmd + P). - Multi-Tab & Split Views: Split the editor horizontally or vertically to inspect source code and unit tests simultaneously.
- Find and Replace: Workspace-wide and document-level search supporting regular expressions, whole-word matching, and case sensitivity.
- Minimap and Breadcrumbs: Dynamic structural overview for rapid scanning of large files.
- Syntax Highlighting: Accurate tokenization and colorization across dozens of languages.
Language Intelligence and Code Navigation #
OnlineAIIDE features deep, offline-first semantic language intelligence powered by pre-compiled API catalogs and Language Server Protocol (LSP) integrations:
- Version-Aware Catalogs: Intelligent completion dynamically adapts whether you are targeting Java 8, Java 17, or Java 21, ensuring deprecated methods or unsupported APIs are never falsely recommended.
- Code Navigation: Right-click or press
F12to trigger Go to Definition, Go to Implementation, or Find References. - Organize Imports: Automatically clean and sort unused package imports with IntelliJ-style accuracy.
- Diagnostics & Problems Panel: Live compiler diagnostics, lint warnings, and syntax errors are aggregated in the Problems tab with one-click editor navigation.
AI-Assisted Code Assistance & Autonomous Agents #
The integrated AI Assistant Panel (AIPanel) acts as your autonomous pair programmer, capable of executing complex software engineering tasks directly in your workspace:
Generate classes, REST controllers, SQL schemas, and helper functions tailored to your existing project context.
Produce comprehensive unit and integration tests with high assertion coverage for newly written or legacy methods.
Highlight stack traces or compiler error messages in the editor and request instant root-cause analysis and remediation code.
The AI agent analyzes build logs, identifies missing imports or syntax mismatches, proposes precise diffs, and verifies build repair.
Supported AI Providers & Model Configuration #
OnlineAIIDE supports a multi-provider AI architecture, allowing developers to switch between local, privacy-first inference and powerful cloud frontier models from Settings > AI Preferences:
| AI Provider | Supported Models | Ideal Use Case | Hosting Model |
|---|---|---|---|
| Ollama | DeepSeek Coder, Llama 3, CodeLlama, Qwen 2.5 Coder | Private offline inference, zero API cost, local host | Local / Self-hosted |
| OpenAI | GPT-4o, GPT-4 Turbo, GPT-3.5 Turbo | Complex reasoning, architecture planning, code refactoring | Cloud API |
| Anthropic | Claude 3.5 Sonnet, Claude 3 Opus, Claude 3 Haiku | Advanced coding loops, precise syntax, long-context analysis | Cloud API |
| Google Gemini | Gemini 1.5 Pro, Gemini 1.5 Flash | Multimodal analysis, massive token context, code explanation | Cloud API |
Build, Run, Debug, and Test Workflows #
OnlineAIIDE delivers a unified development lifecycle without requiring external terminal windows:
Execution and Build Bridge
Execute programs via the Run menu or project context actions. The runtime bridge automatically detects build files:
- Maven: Executes
./mvnw compile,./mvnw package, or./mvnw spring-boot:run. - Gradle: Executes
./gradlew buildor./gradlew run. - Python: Executes
python main.pywithin isolated virtual environments. - Node / Web: Runs package scripts (
npm run build,pnpm dev,npm test). - Go: Executes
go buildandgo run ..
Interactive Debug Adapter Protocol (DAP) Debugging
Set breakpoints directly in the editor gutter. Launch debug sessions with full support for stepping (Step In, Step Over, Step Out), stack frame inspection, and variable watches. Variable evaluation accurately inspects complex objects, loops, and conditional scopes in runtime processes.
Unified Multi-Language Test Explorer
The bottom Tests panel provides a framework-independent test runner and explorer supporting JUnit 4, JUnit 5, TestNG, pytest, unittest, Jest, and Vitest. Discover tests across your workspace, execute individual test classes or suites, and click failing test cases to jump directly to the assertion line in the code editor.
Git and Version Control Integration #
Manage source code changes effortlessly via the built-in Source Control view:
Review modified, untracked, and deleted files with visual diff indicators in the editor gutter.
Stage individual hunks or entire files, write descriptive commit messages, and create atomic Git commits.
Create, switch, rename, and merge branches with full status bar visibility of current checkout state.
Perform Fetch, Pull, Push, and Sync operations with GitHub, GitLab, and custom Git remotes.
Visual Web Application Development #
The Visual Web App Builder enables developers and designers to build responsive frontend interfaces visually with complete bidirectional source synchronization:
How to Use the Visual Builder Step by Step
- Open Page Designer: In any supported WebApp or React project, select a component or page file (e.g.
App.tsxorindex.html) and click the Open Visual Designer icon. - Component Palette: Browse standard UI components (Buttons, Inputs, Cards, Modals, Forms, Navigation bars, and Responsive Grids). Drag and drop components directly onto the visual canvas.
- Properties & Styling Inspector: Select any canvas element to adjust typography, colors, padding, borders, flexbox/grid layout alignments, and event handlers in real time.
- Live Interactive Preview: Test interactions, responsive breakpoint toggles (Mobile 375px, Tablet 768px, Desktop 1200px), and state bindings directly in the canvas.
- Two-Way Code Sync: Changes in the visual builder immediately update the underlying HTML/TSX code, and manual edits in the Monaco editor reflect back onto the canvas without data loss.
Explore detailed visual building tutorials in our dedicated Visual Web App Builder Guide.
Java, Spring Boot & Maven Development #
OnlineAIIDE offers first-class enterprise Java development supporting JDK 8, 11, 17, and 21+:
1. Creating & Opening Java Projects
Open an existing Maven (pom.xml) or Gradle (build.gradle) project via File > Open Folder,
or generate a new Spring Boot service using File > New > Show Gallery > Spring Boot Starter.
2. Building & Compiling
The runtime execution bridge automatically resolves project-local wrappers:
# Compiling Java Maven project
./mvnw clean compile
# Packaging executable Spring Boot JAR
./mvnw package -DskipTests
3. Running & Debugging Applications
Click Run > Run Application to boot your Spring Boot microservice. OnlineAIIDE automatically allocates port 8080
with live web preview streaming. Set breakpoints in any .java file and select Run > Start Debugging to inspect
variables, loops, and call stacks.
4. Testing with JUnit
Execute individual test classes or your full test suite directly from the Tests panel. Assertions report failure stack traces with direct links back to the source line.
5. Troubleshooting Common Java Issues
- JDK Compliance Mismatch: If code using virtual threads fails to compile, open Project Properties and verify the compiler level is set to Java 21.
- Port In Use: If port 8080 is locked by a previous process, use the terminal to terminate lingering instances or click Stop Process in the Run panel.
Read our comprehensive Online Java IDE Guide and Spring Boot IDE Guide.
Python Application Development #
Develop Python scripts, data science modules, and web APIs with Python 3.8 to 3.14+:
1. Environment Isolation & Dependencies
OnlineAIIDE automatically provisions virtual environments (.venv). Install dependencies using standard package managers:
# Installing packages via pip, poetry, or uv
pip install fastapi uvicorn pydantic pytest requests
# Generating requirements.txt
pip freeze > requirements.txt
2. Writing & Running FastAPI Microservices
from fastapi import FastAPI
app = FastAPI(title="OnlineAIIDE Python Service")
@app.get("/api/health")
def health_check():
return {"status": "ok", "runtime": "Python 3.12"}
Launch via Run > Run Without Debugging. Uvicorn boots on an allocated port with automatic browser preview and interactive OpenAPI docs.
3. Running Automated Tests with Pytest
The Tests panel automatically discovers test_*.py files. Click Run All Tests to execute tests in parallel
with detailed failure diagnostic reporting.
Learn more in our dedicated Online Python IDE Guide.
JavaScript & Node.js Development #
Build high-performance backend microservices and full-stack applications with Node.js 20 LTS:
1. Project Setup & Package Management
Work seamlessly with npm, pnpm, and yarn. The integrated terminal handles package installations instantly:
# Initializing a Node.js project
npm init -y
pnpm add express dotenv cors
2. Creating Backend APIs
import express from 'express';
const app = express();
app.use(express.json());
app.get('/api/users', (req, res) => {
res.json({ users: [{ id: 1, name: 'Alex' }, { id: 2, name: 'Jordan' }] });
});
app.listen(3000, () => console.log('Server running on port 3000'));
3. Debugging Node.js Processes
Use the built-in Node debugger to attach to running scripts with breakpoint support, call stack stepping, and live console object inspection.
See our detailed Online Node.js IDE Guide and Online JavaScript IDE Guide.
React & Angular Frontend Development #
Design, code, and preview modern client-side applications with instant live reload:
1. React & Vite Workflows
- Instant HMR: Vite development server provides sub-second Fast Refresh across JSX/TSX components.
- Component Preview: Side-by-side live browser preview automatically reflects changes upon saving.
- State Debugging: Inspect React component props and hooks with integrated console filtering.
2. Angular CLI Projects
- Standalone Components: Full TypeScript IntelliSense for Angular 17+ standalone components, directives, and signals.
- Template Validation: Monaco editor highlights HTML template binding mismatches and type errors in real time.
- Build Workflows: Run
ng buildandng testthrough the execution bridge.
Learn more in our dedicated Online React IDE Guide and Online Angular IDE Guide.
Go (Golang) Application Development #
Develop high-concurrency microservices and systems software with Go 1.22+:
1. Module Initialization & Build Lifecycle
# Initializing a Go module
go mod init myapp
# Compiling binary
go build -o bin/myapp .
# Running tests with coverage
go test -v ./...
2. Go Code Example
package main
import (
"fmt"
"net/http"
)
func helloHandler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello from OnlineAIIDE Go Runtime!")
}
func main() {
http.HandleFunc("/", helloHandler)
http.ListenAndServe(":8080", nil)
}
Explore full Go tooling capabilities in our Online Go IDE Guide.
Extensions and Configuration #
Customize your developer workspace to fit your workflow:
- Extensions Marketplace: Discover and enable curated extensions, themes, and language packs from the Extensions sidebar.
- Custom Keymaps: Configure custom keyboard shortcuts for frequently used IDE actions.
- Workspace Preferences: Tailor editor tab sizing, word wrapping, minimap display, and auto-save intervals.
Workspace and Runtime Management #
Manage environment dependencies and target runtimes with ease:
Choose between Java 8, 11, 17, and 21+ for project-specific compilation and execution environments.
Inspect project build paths, compiler compliance levels, resource directories, and deployment targets.
Subprocesses execute in secure, isolated containers with bounded resource limits and automatic cleanup.
Plans, Billing, and Quotas #
OnlineAIIDE offers transparent tiering tailored to individual learners, professional developers, and enterprise teams:
Guest Plan
- 20 program executions
- 20 debugging sessions
- 20 project builds
- 10 MB project size
- 10 AI assistance queries
Free Plan
- 100 program executions
- 50 debugging sessions
- 50 project builds
- 20 MB project size
- 30 AI assistance queries
Pro
- Unlimited program executions
- Unlimited debugging sessions
- Unlimited project builds
- 100 MB project size
- 150 AI assistance queries
- Priority support
Pro+
- Unlimited program executions
- Unlimited debugging sessions
- Unlimited project builds
- 500 MB project size
- 300 AI assistance queries
- 24/7 dedicated support
Plan pricing is updated automatically based on current deployment configurations.
Troubleshooting Common Problems #
Ensure your API key is correctly entered in Settings. If using local Ollama, verify that Ollama is running and accessible. On HTTPS hosts, AI requests route securely through the gateway proxy.
Check current resource counters under Preferences > Subscriptions. Guest sessions can register for elevated free monthly limits or upgrade to Pro for unlimited executions.
If you encounter compiler errors relating to newer syntax (e.g. records or virtual threads), open Project Properties and select the matching Java version.
Verify that your personal access token (PAT) or SSH key has read/write permissions for the target repository.
If a service cannot start because a local port is bound, stop existing running processes from the Run menu or open the integrated terminal to run lsof -i :port.
Submit diagnostic logs and reproducible bug reports directly via the built-in issue submission interface at Report an Issue.
Frequently Asked Questions #
Is OnlineAIIDE only for Java or Java compilers?
No. OnlineAIIDE is a multi-language cloud development platform. In addition to enterprise Java and Spring Boot, it delivers full support for Python, JavaScript, Node.js, TypeScript, React, Angular, Go, and drag-and-drop visual web app building.
Do I need to install local compilers on my computer?
No. All runtimes (JDK 17/21, Python 3, Node 20, Go 1.22) and build systems (Maven, Gradle, pip, pnpm) run inside secure cloud container sandboxes with interactive terminal and debugging access directly in your browser.
Which browsers are officially supported?
OnlineAIIDE is optimized for Google Chrome, Mozilla Firefox, Apple Safari, Microsoft Edge, and Chromium-based browsers on desktop and laptop operating systems (macOS, Windows, Linux).
Can I run local Ollama AI models with OnlineAIIDE?
Yes. You can connect your own locally running Ollama instance (e.g., DeepSeek Coder, Llama 3) via the AI Preferences dialog, allowing completely offline or zero-cost AI code generation.
How is my code kept private and secure?
Your source code remains your property. Workspace persistence uses isolated per-user storage, and AI interactions are only dispatched to the model provider you explicitly select in your preferences.
Can I push my projects to GitHub or export them?
Yes. OnlineAIIDE uses standard directory structures and native Git version control. You can commit and push to any remote GitHub or GitLab repository, or export your workspace as a zip archive at any time.
Release Notes and Relevant Feature Guides #
OnlineAIIDE is updated regularly with new language providers, debugging tools, and performance enhancements.
To inspect detailed changelogs, new features, and bug fixes across all versions, explore our OnlineAIIDE Release Notes.
Specialized Development Environment Guides
Learn how to configure, run, build, and test applications in your preferred stack using our dedicated environment guides:
Complete multi-language browser IDE overview with Monaco editor, terminal emulation, Git, and debugging.
JDK 8-21+ development with Maven and Gradle build lifecycle, JUnit testing, and Spring Boot support.
Python 3.8-3.14+ script and package development with virtual environments, pytest, and pip workflows.
Node.js backend and full-stack development with npm/pnpm package management and debugging.
Modern ES2024+ client and server-side JavaScript development with real-time linting and browser preview.
Golang application development with go modules, formatting, package testing, and fast compilation.
Microservices with Spring Initializr starters, REST controllers, Maven builds, and configuration tooling.
React and JSX/TSX development with Vite fast refresh, component previews, and state debugging.
Enterprise Angular CLI workflows, TypeScript typechecking, templates, and component design.
Full-stack web applications with HTML5, CSS3, modern JS, instant live reload, and responsive testing.
Low-code drag-and-drop component palette, visual layout designer, and bidirectional source sync.
Multi-provider AI pair programming with OpenAI, Anthropic, Gemini, DeepSeek, and local Ollama models.
Zero-setup cloud workspaces with Docker container runtimes, PTY terminal, and browser accessibility.