Aether Lens

Inspiration

What it does

How we built it

Challenges we ran into

Accomplishments that we're proud of

What we learned

What's next for Aether Lens

Inspiration

Local AI is often private only at the final network boundary. The application still depends on a browser shell, language runtime, model server, native libraries, package managers, and background services. That is difficult to deploy on offline, controlled, or resource-conscious computers.

ANCL began from the same frustration in industrial-control work: small tools should not require a supply chain. Aether Lens asks how far that principle can go when applied to a complete local-AI product.

What it does

Aether Lens is a portable native Windows desktop for local and explicitly selected cloud AI. Its default backend is Aether Engine, a GGUF inference runtime written entirely in ANCL and bundled beside the application.

Lens provides streaming conversation, local model management, native image understanding, saved chats, bounded local knowledge retrieval, editable document canvases, safe HTML/SVG previews, a local calculator/converter, a permissioned Web Reader, isolated embedded Google search, blind two-model Arena comparisons, and an inspectable Privacy Proof.

The user can copy one folder to a Windows computer and run it. No Python environment, Node installation, Electron shell, Ollama service, C runtime, or machine-learning framework is required. Models are deliberately separate and downloaded only after explicit approval with SHA-256 verification.

How it was built

Lens and Engine are written in ANCL, a self-hosted native language whose compiler emits x86-64 Windows executables directly. Lens uses native Win32 controls, graphics, networking, storage, cryptography, process management, and COM/WebView2 integration. Aether Engine implements GGUF parsing, tokenizers, sampling, CPU inference, runtime-loaded Vulkan acceleration, model serving, OpenAI-compatible routes, and a native vision pipeline.

Using GPT-5.6 in Codex, I developed a major submission-period Lens slice in one sustained July 16 task: Document Canvas; Markdown, HTML, SVG, and CSV modes; safe-preview hardening; calculator/converter; bounded Web Reader; embedded Google results; and a pure-ANCL WebView2 runtime locator replacing a proposed loader DLL.

Codex helped translate product decisions into scoped implementations, compile and test each slice, diagnose live failures from screenshots, add regression gates, and package the verified result. It also helped audit and reproduce the judging build, produce the narrated demo, prepare the private repository, and guide the submission setup. The primary task is supplied through the required /feedback Session ID.

During the submission period the Engine also gained OpenAI-compatible routes, an 8,192-token prompt window, streaming telemetry, tool calling, additional model-family support, shared model discovery, and native Gemma-3n vision. The repository clearly distinguishes this work from the pre-existing baseline.

Challenges

• Keeping the application portable without turning privacy into an unverifiable claim.
• Implementing model inference and Vulkan acceleration without conventional ML libraries.
• Designing explicit network and storage boundaries that remain understandable in the UI.
• Embedding modern web results without bundling a browser or accepting a loader DLL dependency.
• Making tiny local models useful while being honest about their quality relative to frontier models.
• Testing a young compiler and language through real product requirements rather than isolated examples.

Accomplishments

• A working native Lens plus Engine package of approximately 7.9 MB before model weights.
• Aether Engine generated the submission demo response locally at 45 tokens per second on the test machine's integrated GPU.
• Lens locates and hosts the installed WebView2 runtime through pure ANCL code with no bundled loader DLL.
• The Engine exposes Ollama-style and OpenAI-compatible HTTP routes.
• Privacy Proof reports the active endpoint, executable hash, selected model/context, and every portable storage location.
• The project is not a mock-up: judges receive the runnable package, complete relevant source, compiler, tests, and dated evidence.

What I learned

The biggest lesson was that dependency-free software is less about binary size than ownership of boundaries. Every removed dependency creates implementation work, but it also makes behavior, storage, network access, and failure modes easier to inspect.

Codex was most valuable as a persistent engineering collaborator rather than a one-shot code generator. The productive loop was: make a product decision, implement one narrow slice, compile it, test the policy or parser independently, inspect the real UI, report what felt wrong, and iterate.

What's next

• Independent security and correctness review.
• Better accessibility, DPI coverage, diagnostics export, and code signing.
• Broader model architecture and quantization support.
• Faster vision prefill and additional image formats in the native Engine path.
• Linux Lens once the native UI direction is settled.
• Continued ANCL compiler, standard-library, and ecosystem hardening.

Built With

• ancl
• codex
• local