Developing Apps with Developer Studio

guideXOS Server v0.2.1 release status

Developer Studio ships with guideXOS Server v0.2.1 and can be launched normally from the Start Menu. The released system includes its Start Menu entry and icon, and the IDE launches through the actual guideXOS Server OS/bare-metal path.

In v0.2.0, Developer Studio existed but its release integration was incomplete: the package was not properly exposed and launchable on the released OS path. v0.2.1 fixes that integration and discoverability issue without changing the fact that Developer Studio itself is an earlier, bounded IDE.

This page describes the capabilities available today and separates them from the hosted development services and future work that remain beyond this focused patch release.

What Developer Studio is

guideXOS Developer Studio is the native IDE and development environment being built for guideXOS Server. It is an early, bounded Native ELF application rather than a full Visual Studio or Clangd replacement. Its language assistance is deliberately lexical or lightweight, with clear limits instead of pretending to provide complete C++ semantic analysis.

Workspace and editor

Workspaces and validated projects
Source editor with multiple document tabs
C/C++ lexical syntax highlighting
Find/Replace and project-scoped Find in Files
Document Outline and project symbol navigation

Bounded code intelligence

Go To Definition and declaration/definition navigation
Find All References and Rename
Code completion and Signature Help
Quick Type Info and lightweight type intelligence
Header/Source switching

Build, run, and debug

Build output and Problems diagnostics
Run Project with temporary development deployment
Source breakpoints, stepping, and source mapping
Call Stack, Locals, Arguments, and Watches
Conditional breakpoints

Starting Developer Studio

On the released guideXOS Server v0.2.1 desktop, open Start Menu / All Programs and choose guideXOS Developer Studio. Its Start Menu entry and icon are part of the released system, so no manual package injection or special launch path is needed just to open the IDE. The package identity is com.guidexos.developerstudio, and its released package shape is a Native ELF AMD64 application.

To work from source, contributors can use the Server Build and Testing workflow to create a development image, then verify that its ESP contains Apps/DeveloperStudio/app.json and Apps/DeveloperStudio/bin/amd64/developerstudio.elf before booting it. That source-build check is for contributor validation; it is not a prerequisite for launching Developer Studio from the public v0.2.1 ISO.

Launching the IDE and using its complete project workflow are separate capabilities. Developer Studio's current Build, Run, and Debug services are hosted-development features and may still require the paired external development environment and toolchain; see Application Model for the wider runtime split.

Create your first application

Choose File → New Project or press Ctrl+N. The current supported template is Native GUI Application. Developer Studio asks for four values:

Field	What to enter
Display Name	The human-readable application name shown by the generated project and window.
Parent location	An absolute hosted path where the new project folder will be created.
Folder name (optional)	The destination folder name. If left blank, Developer Studio derives a lowercase, hyphenated name from the display name.
Application ID	A stable reverse-domain-style identity such as `com.example.hello`.

Application IDs are lowercase, contain at least two non-empty dot-separated segments, and use letters, digits, and hyphens after each segment's initial lowercase letter. Do not use repeated dots or a trailing hyphen. User projects cannot claim the reserved com.guidexos namespace, including its descendants. Use Tab or Enter to advance through the fields; Enter on Application ID creates the project and Escape cancels without filesystem changes.

The generated project

<ProjectRoot>/
    guidexos.project
    CMakeLists.txt
    build.ps1
    README.md
    app/
        app.json
    src/
        main.cpp
        freestanding_memory.cpp

The generated project is a version 1 project with a fixed target profile and a deterministic native build recipe. The important files are:

File	Purpose
`guidexos.project`	Project metadata: target, output name, application identity, source root, entry point, ABI, and related fields.
`app/app.json`	The App Model manifest for the generated Native ELF application.
`src/main.cpp`	The main application source. The generated entry point is `extern "C" gx_result GX_CALL gx_main(gx_app_context* ctx)`.
`src/freestanding_memory.cpp`	Freestanding memory primitives required by the Native ELF link.
`build.ps1`	The deterministic native build recipe used by Developer Studio's Build Project command.
`CMakeLists.txt` and `README.md`	An optional external build description and the generated project notes.

The generated starter is intentionally small. It creates a window, draws the generated welcome text, handles close/Escape, and exports gx_main. Use the generated source and the current SDK headers as the API authority rather than copying an invented application API from a guide.

Edit the app

Open src/main.cpp from the Explorer. The editor supports caret movement, bounded selection, insertion, Enter, Backspace, Delete, arrows, Home, End, mouse placement, vertical scrolling, tabs, dirty tracking, and Save/Save All. It highlights C/C++ lexically and provides bounded navigation and search tools. A typed . or completed -> can open the same completion popup as Ctrl+Space; this is direct, bounded type-aware assistance, not full IntelliSense.

Command	Shortcut
Save	`Ctrl+S`
Save All	`Ctrl+Shift+S`
Find in Files	`Ctrl+Shift+F`
Project symbol navigation	`Ctrl+T`
Go To Definition	`F12`
Find All References	`Shift+F12`
Rename	`F2`
Code completion	`Ctrl+Space`
Signature Help	`Ctrl+Shift+Space`
Quick Type Info	`Ctrl+Alt+T`
Switch Header / Source	`Alt+O`
Toggle source breakpoint	`F9`
Build Project	`Ctrl+Shift+B`
Run Project	`F5`

Some editor conveniences are intentionally not implemented in the current release candidate: clipboard support, redo, folding, regex search, and Replace in Files are not part of this guide.

Build the application

Choose Build → Build Project or press Ctrl+Shift+B. If project files are dirty, Developer Studio saves them or asks you to choose Save All or Cancel before the build starts. The fixed workflow uses the generated build.ps1 recipe and produces:

build/bin/amd64/<outputName>.elf

The current validation expects a static ELF64, little-endian, AMD64 ET_EXEC image with a gx_main entry point. Build output shows the captured build process and summary information. Problems contains recognized compiler/linker diagnostics that you can select to navigate back to source. A failed build is not allowed to leave an older artifact looking like the result of the current build.

Build Project is a hosted-development service. It uses the paired Server SDK headers and LLVM clang++/ld.lld toolchain; the generated CMake file remains an optional external build description.

Run the application

Choose Run Project or press F5. Developer Studio always rebuilds the active project first, then validates the resulting project metadata, manifest, artifact path, hash, ELF shape, ABI, and gx_main entry point.

The active project is saved or passes the dirty-file Save All / Cancel gate.
The project is rebuilt and the output artifact is validated.
The hosted Server temporarily registers the result with the App Model.
The application is launched through the normal hosted Native ELF path.
When the run/session ends, the temporary registration and owned resources are cleaned up.

This development deployment is temporary. It is not the same as permanently installing an application, and its App Model record is not written into installed package storage or Start Menu state.

Debugging

Use Debug → Start Debugging or Ctrl+F5 for the hosted debugger. Set a source breakpoint with F9. In a stopped session, the current controls are:

Debugger action	Shortcut / surface
Continue	`F5`
Step Into	`F11`
Step Over	`F10`
Step Out	`Shift+F11`
Source breakpoints	`F9`
Inspection	Source mapping, Call Stack, Locals, Arguments, and Watches
Filtered stops	Conditional breakpoints using the bounded Watch grammar

The debugger is intentionally bounded. There is no pause-anywhere support, general C++ expression evaluator, memory/register editing, attach or remote debugging, or guarantee of optimized-code parity. Locals, Arguments, and Watches are read-only views of the current stopped frame and supported debug information.

Hosted versus bare-metal development

The current documented project target is:

guidexos.amd64.hosted.native

Build Project and the temporary Run Project/Debug session are hosted-development services. The complete create/build/run/debug workflow currently requires the hosted Windows environment, the paired Server checkout, the hosted Server SDK, and the configured LLVM toolchain. The v0.2.1 release integration makes the IDE launchable on the released OS/bare-metal path; it does not make the native application build and toolchain workflow self-contained there.

Available today in v0.2.1: the released Developer Studio application, its normal Start Menu launch, and the editor, code-navigation, diagnostics, build, run, and bounded debugger capabilities described above. Development/hosted infrastructure still supplies the current project toolchain services. Building applications entirely inside Developer Studio, together with broader native bare-metal project execution and packaging, remains future work.

A five-minute tutorial

Launch Developer Studio from Start Menu / All Programs on the released guideXOS Server v0.2.1 desktop.
Choose File → New Project or press Ctrl+N.
Select Native GUI Application.
Enter a display name and an application ID such as com.example.hello.
Choose the parent location and optionally set a folder name, then create the project.
Open and edit src/main.cpp.
Press Ctrl+Shift+B to build.
Resolve any diagnostics shown under Problems.
Press F5 to rebuild, validate, and run the temporary development deployment.
Set an F9 breakpoint and use the debugger's Continue and stepping controls.