Private product showcase / Windows candidate · Atlas Mac preview
Yeho
The world's most advanced cross-platform high- and low-level programming language with a custom native UI system.
One native language, UI system, and visual code workspace
Meet your visual workspace
Atlas
Atlas / Visual scripting
Your code, connected.
Work beside your IDE in a native visual workspace written in Yeho with Dolphin and YUI. Atlas reads the real source and turns functions, types, and operations into connected graphs.
- Open several Yeho projects together, follow direct function calls, and enter an operation graph. Pan, zoom, and arrange cards with saved layouts.
- Select a node to highlight its source. Follow VS Code's cursor and unsaved buffers, or keep the visual view pinned while you code elsewhere.
- Edit literals, operators, and named inputs; drag compatible value connections or insert a numeric multiply operation. The compiler checks each change before it reaches the source.
- Visual edits share VS Code's unsaved buffer and Undo history when connected. Without an IDE, Atlas edits the file and retains session Undo and Redo.
- Today: Yeho projects on the Mac developer path. Arbitrary-language repositories, general node creation, and continuous repo-to-function semantic zoom remain in development.
Atlas / Shader editing
Shape the surface. See the result.
Connect colors, waves, and mixes to Dolphin's surface output. The preview compiles the actual Yeho shader function and renders the material from that code.
- Use Dolphin's real Vector3 colors and surface contract, with roughness, metallic, and emission inputs.
- Change a value in Atlas or the IDE and regenerate the material sphere. Compatible color-wire edits update the same source call.
- Preview linear RGB materials with shared Dolphin GGX lighting. Incomplete code retains the last valid image with a visible stale status.
- The current preview uses compiled CPU rendering and fixed studio lighting. GPU shader export, texture and normal sampling, and arbitrary Studio material assignment remain in development.
- Atlas is a Mac developer preview in the Yeho source tree. It is not included in the currently published Windows Starter Pack.
Why this changes the game
Three reasons to care.
See and edit real Yeho code in Atlas while you work beside your IDE.
Connect Dolphin surface nodes and watch compiled shader previews update.
More than 300× faster than Python in a retained 50-million-iteration benchmark.
Proof today
The current machine, without mythology.
The current Windows x64 candidate builds bounded console and YUI apps through Forge and Kyber into native executables. Its provider-neutral graphics contract drives a real OpenGL 3.3 path without leaking backend handles into ordinary Yeho code. Portable compute has a working CPU slice plus a bounded Vulkan 1.2 exact-int32 reference adapter with CPU parity. In the retained counted-loop benchmark, Kyber completed 50 million iterations in a 3.035 ms median versus Python 3.14 at 4,147.313 ms on the same i7-14700K host. That result is workload-specific, not a claim that every Yeho program is universally faster. The candidate also ships project scaffolding, packages, reports, diagnostics, a relocatable SDK and toolchain, custom retained widgets and rendering, and explicit failure when a native construct is not yet supported. Atlas now has a verified Mac developer preview: real Yeho graphs, compatible value rewiring, unsaved VS Code buffer synchronization, Undo, and compiled Dolphin surface previews. Atlas uses the explicit CPU-oracle/AppKit route on Mac; this is not Kyber support for Mac or a new downloadable SDK release.
Software ideas get buried under language boundaries, UI frameworks, native build systems, glue code, and hardware APIs. The team cannot fix the layer that blocks it.
Yeho gives the owned stack one readable source language, one semantic boundary in Forge, one direct native backend in Kyber, and one custom retained interface system in YUI. Atlas adds a native visual view of that same source, with typed connections and two-way IDE editing. When a product exposes a missing primitive, we improve the language upstream.
One language to the graphics card
Build the world once. Yeho speaks to the GPU.
Game and app code names scenes, meshes, materials, lighting, and drawing in Yeho. OpenGL, Vulkan, DirectX, Metal, shader languages, binding slots, and driver handles stay behind a provider boundary. The hardware stays real. The platform plumbing stops taking over the idea.
World logic, YUI, meshes, materials, lighting, particles, and draw intent.
Semantic pipelines, opaque resources, capability checks, readable failures, and explicit lifetime.
The Windows x64 provider already drives real OpenGL 3.3 shaders, indexed GPU meshes, depth, materials, sunlight, hemisphere fill, directional shadows, readback, and bounded resource teardown through a public API with no OpenGL handles in ordinary Yeho code.
The same high-level Yeho graphics source moves across Vulkan, DirectX, Metal, OpenGL ES, Starfish, and future hardware providers. Creators build the game, not a pile of platform ports.
Parallel by intent
Hand Yeho the operation. Let the machine choose the muscle.
You describe the work and its data. Yeho can feed available CPU worker capacity or an admitted GPU without making game, simulation, or AI code own raw threads. One clear operation remains readable whether it runs as a CPU oracle or scales across GPU lanes.
[auto]
compute UpdateParticles(buffer<particle> particles, float deltaTime)
{
int id = compute.index
if id >= particles.count
{
end
}
particles[id].position = particles[id].position
+ particles[id].velocity * deltaTime
}taskOne concurrent CPU unitStart it, wait for it, inspect it, or stop it through one structured handle.
parallelIndependent CPU branches togetherYeho starts and joins the branches while the runtime manages worker threads.
computeOne operation across dataUse the portable compute-safe subset for CPU or GPU execution from the same source.
Choose the best admitted backend. Use [cpu] to pin the reference path or [gpu] to require acceleration.
Available worker capacity, simple local testing, and the reference oracle.
Far more lanes for simulations, graphics math, inference, and future training scale.
Portable explicit GPU compute with validated SPIR-V, submission, synchronization, readback, profiling, and CPU parity.
Use NVIDIA compute and AI acceleration when it is the best available engine, without making CUDA the language or the only correctness path.
Kyber runs the first [auto] CPU compute slice for integer and boolean scalar buffers. A promoted Vulkan 1.2 reference adapter proves explicit GPU resources, submission, synchronization, readback, profiling, and exact-int32 CPU parity through a bounded Yodi-shaped canary.
Keep the equation elegant while Yeho widens backend and data-type coverage from local CPU experiments to portable GPU paths and optional CUDA acceleration on NVIDIA hardware, then eventually large AI training and inference systems. No duplicated CPU logic, vendor shader language, or hand-built thread maze.
The connected stack
Nothing powerful lives alone.
Public Academy
Learn Yeho from the inside.
Every public guide, field lesson, and architecture map for this system is gathered here. No membership is required to study these rooms.
Yeho: native programming, YUI, and visual code
Learn what the Yeho programming language, Kyber compiler, YUI interface system, and Atlas visual editor do, with public examples and a practical first evaluation.
Open in the Academy ↗02 / Code guideFree Yeho apps, games, and templates
Run, read, and remix nine complete examples, including colorful fluids, a veterinary CMS, chess, and a solar navigator.
Open in the Academy ↗03 / System guideYeho from first principle to working system
Trace Yeho source through Forge and Kyber, understand YUI, and see exactly what the current native candidate proves.
Open in the Academy ↗04 / Code guideYeho: variables to a flying AI dot
Start with variables, open a window, paint a galaxy ball, add jumping, and train a small GPU steering model.
Open in the Academy ↗05 / Code guideBuild beautiful interfaces with YUI
Real native examples, commented source, themes, interaction, and screenshots.
Open in the Academy ↗06 / Code guideAtlas: visual code, UI, and shaders
Drag UI elements, inspect connected code, and explore a material using the same Yeho source.
Open in the Academy ↗07 / Code guidePaint with GPU shaders
Complete Yeho image programs and native GPU results.
Open in the Academy ↗08 / Code guideLearn the Yeho libraries
Complete commented programs, expected output, and small experiments for each package.
Open in the Academy ↗09 / Field lessonSource-code licensing for companies and government teams
A practical guide to evaluating Demon Hunter Labs source memberships: commercial and public-sector rights, team seats, release scope, and the evidence to request before adoption.
Open in the Academy ↗10 / Field lessonYeho: One Language From Idea to Machine
Follow Yeho source through Forge and Kyber into a native artifact, then see how YUI keeps interface meaning inside the same owned system.
Open in the Academy ↗11 / Architecture mapYeho interactive architecture
Select stations, trace routes, and see which layer owns each important Yeho decision.
Open in the Academy ↗Open the machinery
Follow the whole system.
See the route first. Then open the architecture or complete manual when you want every chamber, boundary, and proof.
InteractiveSee inside the systemOpen the architecture map ↗A glimpse inside
Six doors into the machine.
One readable systems language
Yeho joins ordinary application code, native systems work, structured tasks, graphics, and accelerator-oriented programs without making C++ part of the normal product route.
Projects stay small and inspectable
A project is source, an optional project.mech manifest, and optional authored .yui documents. Package resolution, lock identity, capabilities, and target selection are exposed rather than hidden.
Your code, connected.
Work beside your IDE in a native visual workspace written in Yeho with Dolphin and YUI. Atlas reads the real source and turns functions, types, and operations into connected graphs.
Shape the surface. See the result.
Connect colors, waves, and mixes to Dolphin's surface output. The preview compiles the actual Yeho shader function and renders the material from that code.
Forge preserves program meaning
Forge is the semantic bridge between typed Yeho programs and execution backends. It owns a portable program model, validation, reports, and optimization boundaries.
Kyber owns the machine boundary
Kyber lowers Forge programs directly to Windows x64 objects, owns ABI and runtime helpers, and packages the final native executable with a bounded assembler and linker.
The door is open