What Keel Engine can do today.

keel new creates an app, 2D game, 3D game or website from a template. keel build, run, test and doctor cover the rest of the loop.

keel shot renders scenes without a window at the sizes, scales, themes and locales you list, writes PNGs and a JSON report, and fails on a panic, a blank frame or an error log.

keel inspect runs a single asset, component, scene or animation in isolation and prints what it found as JSON.

A simulated clock advances one fixed step per frame, so the same build and flags give the same pixels. Snapshot helpers turn a run into a test.

Record input and replay it, so a playtest can be repeated exactly.

keel run --target android builds, installs and launches on a device or emulator, and can save a screenshot.

keel pack builds for the web, desktop and mobile.

Commands accept --json and use clear exit codes, so scripts and agents can act on the result.

Linux, Windows and macOS, drawn with the GPU or with a software renderer on machines without one.

WebAssembly with WebGPU, falling back to WebGL2 and then a 2D canvas. Websites render as real HTML instead.

Generates the Gradle project and builds APK and AAB packages.

Generates the Xcode project around your app. Device builds and store signing are manual.

The same components can render as a text interface in a terminal.

Metal and roughness materials with image-based lighting from environment maps.

Clustered lighting for many lights, HDR, and cascaded directional shadows with soft edges.

Ambient occlusion, temporal and fast anti-aliasing, bloom, auto exposure, filmic tone mapping and colour grading.

Characters with skeletons are skinned on the GPU.

Add your own render passes and shaders to the frame.

A CPU renderer draws UI and 2D on machines without a GPU.

Batched sprites, tile layers and 2D lights.

Paths, strokes, dashes and gradients, with SVG import.

Seeded natural-media brushes such as watercolour, hatching and pigment mixing, on the CPU or the GPU.

Rigid bodies, joints and collisions through Rapier.

Basic Spine skeletons load. Full Spine import and constraints are missing.

Scenes, meshes, materials, skins, morph targets, animations, cameras and lights, including compressed meshes and textures.

PNG, JPEG and KTX2, with Basis Universal transcoding to whatever the device supports.

Reference-counted handles, background loading, dependency tracking and asset hot reload.

Clips, crossfades, blend trees, state machines and layers.

Two-bone, FABRIK and CCD chains, full-body IK, foot placement on uneven ground, and root motion.

Clips compress within an error bound you set and decode without allocation.

Spring bones for hair, cloth and accessories.

Scenes and prefabs are plain data files.

Pose search works. There is no authoring pipeline yet.

3D and 2D bodies, joints, ray and shape casts, and mesh and heightfield colliders.

Move a character through the world with collisions resolved for you.

Particle-based fluids on the CPU or the GPU.

Material point simulation for elastic, snow, sand, goo and liquid materials, on the CPU or the GPU.

Objects break along precomputed fracture patterns when hit hard enough.

Bodies float on a water plane or heightfield with drag.

Rope and cloth can hang from rigid bodies and pull on them.

Cloth runs on the CPU. There is no GPU solver yet.

A raycast vehicle exists but is not yet part of the main physics interface.

A*, jump point search, any-angle paths, replanning when the map changes, hierarchical search and flow fields.

Bake navmeshes from any level geometry, including tiled meshes and moving obstacles, and query shortest paths.

Local avoidance for many agents in 2D and 3D, plus steering behaviours.

Collision-free paths for many agents at once on grids and graphs.

Fast shortest-path queries on large graphs using contraction hierarchies.

Wave function collapse, terrain erosion, dungeons, caves and L-systems.

Triangulation, Voronoi diagrams, polygon booleans and offsets, convex hulls, marching cubes and curve smoothing.

Entities, components, relations and resources, stepped in fixed phases: input, simulation, late update, render.

Behaviour trees, utility AI, state machines, goal and task planners, and perception.

Emitters, trails, beams and screen shake.

Voxel volumes with chunk streaming, level-of-detail meshing and ray casts.

Tweens, easing, springs, timers and scheduled ticks.

A seeded random generator, coherent noise compatible with FastNoiseLite, and blue-noise sampling.

GPU kernels exist, but particles simulate on the CPU by default.

Buses, sends, EQ, filters, compression, delay, reverb, convolution, sidechain ducking and mixer snapshots.

Distance attenuation, cones, doppler, occlusion and binaural 3D sound for headphones.

Long tracks stream from disk with high-quality resampling.

Procedural sound effects, granular synthesis, and time-stretch and pitch-shift.

WAV is always on. Ogg Vorbis and Opus are available but off by default.

Actions, contexts, dead zones, taps and holds.

Pointer events and gesture recognition.

Virtual sticks and touch buttons.

Vibration effects on supported devices.

Supported through the platform. Live polling on desktop needs an optional feature.

Components, signals and derived values, with conditional and list rendering.

Flexible row and column layout that adapts to the screen.

Design tokens, and a full colour palette generated from one seed colour.

OpenType shaping, right-to-left and mixed-direction text, CJK line breaking, and sharp glyphs at any size.

Render Markdown with tables, task lists and code highlighting.

Input methods work on desktop. On mobile they depend on the platform integration.

Screen readers work on desktop. Mobile screen readers depend on the platform integration.

Each route becomes a real HTML page with its own title and metadata, readable by search engines and usable without JavaScript.

Routes, layouts and data loaders, with loading and error states.

Pages can stream in as they render and become interactive where they need to.

Interactive parts change only the elements that changed.

keel dev serves the site and reloads the page on every change.

HTTP requests and WebSocket connections.

Datagrams and QUIC with TLS 1.3.

Handshakes, reliable, unreliable and ordered channels, fragmentation, and round-trip and loss statistics.

Client prediction, interpolation, lag compensation and rollback, with the game world and physics saved and restored.

Entity components replicate as compact deltas, with interest management by position and per-entity priority.

The browser side is included. You provide the server and its certificates.

Key-value storage, save games and files on native platforms and in the browser.

Screen size, safe areas, light or dark mode, clipboard, sharing, links, file picking and downloads, printing and screen capture.

Local notifications, including scheduled ones.

String tables with plural rules for a fixed set of locales.

In-app purchases, ads, platform sign-in and consent work through bridges the app wires up on each store.

Text-to-speech on the web and desktop. Native mobile voices depend on the platform integration.

ARKit and ARCore sessions, and camera access on the web and Linux, through platform bridges.

Run small neural networks, and ONNX models through an optional CPU backend.