Aether Canvas

Space is the prompt.
A generative desktop where grouping ordinary files creates the mini-app you need.

OpenAI Build Week 2026  ·  Apps for Your Life  ·  Built with Codex + GPT-5.6

Watch the demo   ·   Devpost   ·   See the product   ·   Run Aether   ·   GPT-5.6   ·   Build story

_{Five source files, four semantic streams, one GPT-generated interactive workspace—captured from the running Electron app.}

Five files in. One living workspace out.

A normal folder sees filenames. Aether sees the trip, project, course, budget, or plan they describe together.

CONCEPTUAL WORKFLOW · CLICK A CHAPTER
_{A hand-drawn explanation of the idea, not a screenshot of the application. Select any panel to inspect the real files, architecture, or product evidence behind it.}

01 · Start with files Open the exact sample files used in the demo.

02 · Understand context Follow the implemented GPT-5.6 data flow.

03 · Become useful See the real workspace and reproducible product loop.

Space is the prompt Place files together to express intent—without inventing folders, tags, or a perfect prompt first.

Files stay alive Edit the original spreadsheet or note. Aether detects the save, re-analyzes the change, and refreshes the workspace.

Answers show their work Ask across the canvas and see animated traces to the dashboard sections and files that support the answer.

The product thesis: personal files should not become useful only after someone manually reorganizes them. Aether compiles the context already present between them.

See Aether in action

01 DROP	02 UNDERSTAND	03 CONNECT	04 COMPILE	05 STAY LIVE
Add PDFs, sheets, documents, notes, or images.	GPT-5.6 extracts dates, costs, places, tasks, and grounded context.	Semantic ribbons reveal why the artifacts belong together.	The cluster becomes an interactive mini-workspace.	External file edits and canvas questions keep it useful.

The 90-second product loop

The repository includes a deterministic five-file Tokyo dataset in agent_assets/sample-files.

1. Create an empty space and drop in flight-ticket.pdf, hotel-booking.docx, budget.xlsx, packing-list.txt, and city-guide.pdf.
2. Watch the file cards, semantic hubs, ribbons, and Tokyo Trip dashboard assemble.
3. Open Journey, Budget, Packing, and Places—the generated card behaves like a mini-app, not a static summary.
4. Change a value in budget.xlsx externally and save it. The source card and dashboard update without re-importing.
5. Press Ctrl/⌘ J and ask “How much can I spend on food each day?”
6. Follow the answer’s animated evidence trail back to the supporting files.

Demo line: “Your files aren’t imported into Aether and forgotten. They stay alive.”

More than a beautiful graph

Adaptive mini-workspaces GPT-5.6 plans the dashboard from the actual cluster. Journey, Budget, Packing, Map, Timeline, Progress, Key Points, Priorities, and other modules appear only when grounded in the files. Travel is the demo—not the architecture.	Interactive outcomes Edit actual expenses, check packing items, inspect timelines, navigate maps, export data, reveal contributing sources, and preserve those changes with the workspace. The output is usable, not merely readable.
Living source files Chokidar watches added files. Stable-write detection, SHA-256 comparison, batching, per-file cooldowns, and request guards prevent partial reads and API storms. Aether reacts only to meaningful changes.	Visual explainable AI Answers render as draggable canvas cards. Their colored traces identify the exact generated modules and source files used; low-confidence answers draw no misleading provenance. Do not just trust the answer—see its path.

Built for more than Tokyo

Put these files together	Aether can compile
Lecture notes + syllabus + assignment + textbook	Topics, schedule, concepts, progress, resources
Requirements + meeting notes + timeline + budget	Overview, milestones, tasks, team, budget
Quotes + receipts + floor plan + inspiration	Contractors, spending, materials, timeline, references
Recipes + pantry list + dietary notes	Ingredients, cooking timeline, shopping list
Lab results + prescriptions + appointment notes	Timeline, medications, appointments, key results

How GPT-5.6 powers Aether

GPT-5.6 is not a chat box beside the product. It is the workspace compiler.

GPT-5.6 decides what each selected file means; which entities and relationships matter; what kind of workspace the cluster represents; which dashboard modules belong in it; how changed source data affects the result; and which evidence supports a canvas answer.

Aether guarantees secure, user-authorized file access; schema validation and bounded inputs; a tested local visual component grammar; interaction, persistence, and animation; provenance ID validation; and predictable sync and rate limits.

The model never sends executable interface code to the renderer. It returns a strict plan built from Aether’s local grammar—routes, rings, progress, maps, timelines, briefs, comparisons, priorities, and other tested primitives. GPT-5.6 chooses the information architecture; Aether owns every rendered pixel and interaction.

Open the complete GPT-5.6 runtime flow

User-approved file
        │
        ▼
Electron main process ── MIME detection + secure local read
        │
        ▼
GPT-5.6 Responses API ── native file/image understanding
        │
        ▼
Structured analysis ──── entities, preview, summary, source intelligence
        │
        ├── relationship discovery ──► semantic hubs and ribbons
        │
        └── dashboard planning ──────► bounded local UI composition

External save ──► stable write ──► SHA-256 diff ──► re-analysis
Canvas question ──► validated context ──► answer + provenance

Files are sent directly through Responses input_file or input_image. Structured schemas drive previews, relationship discovery, generated modules, live refreshes, and grounded Q&A.

The default is gpt-5.6-luna with low reasoning for a responsive drop loop. Settings expose Terra and Sol plus the supported reasoning levels without requiring a rebuild.

Run Aether

Install the Windows release

Download Aether-Canvas-Setup-1.0.0-x64.exe from the GitHub Releases page, run the assisted installer, and configure an OpenAI API key in Settings → Intelligence.

Windows SmartScreen may warn about this unsigned hackathon build. Select More info → Run anyway after confirming the publisher repository and release tag.

Four commands to the canvas

git clone git@github.com:abbasmir12/aether-canvas.git
cd aether-canvas
nvm use
npm install

cp .env.example .env

On Windows PowerShell:

Copy-Item .env.example .env

Add the API configuration:

OPENAI_API_KEY=sk-your-key-here
AI_MODEL=gpt-5.6-luna
AI_REASONING_EFFORT=low

Then launch:

npm run dev

Expected time: under five minutes on a machine with Node 22 and a working native dependency toolchain.

Prerequisites, commands, and platform notes

Prerequisites

• Node.js >=22.12.0 (.nvmrc targets Node 22)
• npm >=10
• An OpenAI API key
• A native build toolchain if npm cannot use prebuilt binaries

If native installation falls back to compilation on Debian/Kali:

sudo apt update
sudo apt install build-essential python3

Command	Purpose
npm run dev	Start Vite and Electron with live rebuilding
npm run lint	Strictly type-check renderer, shared, main, preload, and configuration code
npm run build	Type-check, build, rebuild native modules, and package for the current platform
npm run build:win	Build the assisted 64-bit Windows NSIS installer
npm start	Run the previously built Electron bundle

Development and product testing have been performed on Linux/EC2 and Windows 11. Windows release artifacts are built and smoke-tested on Windows because better-sqlite3 and Sharp include platform-specific native binaries. Electron Builder generates the Windows icon set from the canonical 512×512 build/icon.png source.

The API key can also be entered in Settings → Intelligence. A key saved through the UI is protected with Electron safeStorage; if OS-backed encryption is unavailable, Aether refuses to persist it as plaintext.

Supported file input

Documents	Data	Images
PDF	Excel (.xlsx, .xls)	PNG
Word (.docx)	CSV and TSV	JPEG
PowerPoint (.pptx)	Plain text and Markdown	GIF and WebP

Files are limited to 50 MB for direct analysis. Sharp generates local image thumbnails; GPT-5.6 handles semantic understanding.

How Codex accelerated the build

The first prompt to Codex did more than request code. It established the product thesis, visual north star, technical constraints, hackathon criteria, documentation system, and a rule: every major milestone must separate Codex contributions, human decisions, and verification.

Codex accelerated Electron, Vite, and React Flow scaffolding; secure IPC and native path authorization; GPT-5.6 Responses and structured schemas; dashboard compilation and custom ribbons; atomic workspace persistence and recovery; live sync, batching, and Windows save handling; visual answer nodes and provenance edges; and native smoke captures and regression debugging.

The human directed the “Space is the prompt” product thesis; native GPT file understanding over parser libraries; semantic hubs instead of graph spaghetti; living files instead of static imports; visual provenance instead of ordinary chat citations; the interaction and design quality bar; feature priorities and scope; and acceptance testing on the real Windows workflow.

Codex made the week move faster. Human judgment determined what was worth building and repeatedly changed the implementation when the product did not yet express the idea clearly enough.

The build is inspectable

Build log What Codex contributed, what the human decided, and how each milestone was verified.	Decision record Architecture and product choices, including superseded approaches and why direction changed.	Judging evidence Concrete proof mapped to implementation, design, impact, and quality of the idea.
Architecture Electron trust boundaries, data flow, local persistence, and renderer structure.	Product specification The user problem, core thesis, target audience, features, and hackathon scope.
Build documentary Watch the prompts, milestone recordings, Codex working sessions, Windows testing, debugging, and progress screenshots captured throughout the build. A written index is also available in the repository.

Local-first, with an explicit AI boundary

Aether does not move, rename, or modify source files. Workspace layouts, cached analysis, relationships, dashboard state, pinned folders, and preferences are stored locally as atomic JSON in Electron’s OS-standard application-data directory.

Local-first does not mean offline-only. Files explicitly selected through drop or a native picker are sent to the OpenAI Responses API for analysis. Relationship discovery uses the resulting metadata. Local path access is authorized at the preload/main-process boundary, Node integration is disabled in the renderer, and the OpenAI credential never enters renderer code.

Architecture and repository map

┌──────────────── Electron main process ────────────────┐
│ secure file access · OpenAI client · workspace store │
│ file watcher · settings · dialogs · OS integrations  │
└───────────────────────┬───────────────────────────────┘
                        │ typed, prefixed IPC
┌───────────────────────▼───────────────────────────────┐
│ context-isolated preload bridge                      │
└───────────────────────┬───────────────────────────────┘
                        │ window.aether
┌───────────────────────▼───────────────────────────────┐
│ React renderer                                       │
│ React Flow canvas · local UI grammar · Framer Motion │
│ workspaces · interactive dashboard · visual answers │
└───────────────────────────────────────────────────────┘

src/
├── main/                 Electron lifecycle, IPC, AI, files, persistence
├── renderer/
│   ├── components/       Canvas, cards, ribbons, dashboards, views
│   ├── hooks/            Auto-layout and renderer behavior
│   ├── services/         Renderer-side orchestration
│   ├── stores/           Workspace and UI state
│   ├── types/            Renderer contracts
│   └── utils/            Shared presentation helpers
└── shared/               Cross-process TypeScript contracts

agent_assets/
├── aether_design.png     North-star product mockup
└── sample-files/         Reproducible Tokyo Trip demo data

docs/                     Build history, decisions, architecture, evidence
build-journey/            Recorded prompts, milestones, and build documentary

Technology: Electron, TypeScript, React 19, Vite, React Flow, Tailwind CSS, Framer Motion, OpenAI Responses API, Chokidar, Leaflet, Sharp, and electron-builder.

License

Aether Canvas is open-source software available under the MIT License.

Submission

Track Apps for Your Life

Built with Codex using GPT-5.6

Runtime brain GPT-5.6 Responses API

Repository GitHub

Aether Canvas
_{Space is the prompt.}