What Keel can do today
Everything on this page is in the engine now. Supported means it works on the platforms Keel runs on. Partial means it works with a gap, and the card names the gap. Keel is pre-1.0, so APIs still change between versions.Everything from the command line
There is no GUI editor: scenes, content and settings are code and data files. The keel command-line tool lets a person or an agent do everything an editor would, and check the result without looking at a window.Project commands
Supportedkeel 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.Headless screenshots
Supportedkeel 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.Inspect one piece
Supportedkeel inspect runs a single asset, component, scene or animation in isolation and prints what it found as JSON.Repeatable runs
SupportedA 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.Input replay
SupportedRecord input and replay it, so a playtest can be repeated exactly.Run on a device
Supportedkeel run --target android builds, installs and launches on a device or emulator, and can save a screenshot.Packaging
Supportedkeel pack builds for the web, desktop and mobile.Machine-readable output
SupportedCommands accept --json and use clear exit codes, so scripts and agents can act on the result.Native on every platform, no WebView
Keel draws everything itself. The same program runs on each platform, and platform features are reached through small typed interfaces with a real implementation per platform.Desktop
SupportedLinux, Windows and macOS, drawn with the GPU or with a software renderer on machines without one.Web
SupportedWebAssembly with WebGPU, falling back to WebGL2 and then a 2D canvas. Websites render as real HTML instead.Android
SupportedGenerates the Gradle project and builds APK and AAB packages.iOS
PartialGenerates the Xcode project around your app. Device builds and store signing are manual.Terminal
SupportedThe same components can render as a text interface in a terminal.Modern GPU rendering
Rendering runs on wgpu. Each frame is a render graph that orders passes, skips unused work and reuses memory.Physically based materials
SupportedMetal and roughness materials with image-based lighting from environment maps.Lighting and shadows
SupportedClustered lighting for many lights, HDR, and cascaded directional shadows with soft edges.Post-processing
SupportedAmbient occlusion, temporal and fast anti-aliasing, bloom, auto exposure, filmic tone mapping and colour grading.Skinned meshes
SupportedCharacters with skeletons are skinned on the GPU.Custom passes
SupportedAdd your own render passes and shaders to the frame.Software fallback
SupportedA CPU renderer draws UI and 2D on machines without a GPU.Sprites, tiles and vector art
Everything a 2D game needs, drawn in batches.Sprites and tilemaps
SupportedBatched sprites, tile layers and 2D lights.Vector graphics
SupportedPaths, strokes, dashes and gradients, with SVG import.Painterly brushes
SupportedSeeded natural-media brushes such as watercolour, hatching and pigment mixing, on the CPU or the GPU.2D physics
SupportedRigid bodies, joints and collisions through Rapier.2D skeletal animation
PartialBasic Spine skeletons load. Full Spine import and constraints are missing.Bring models in and make them move
Assets load in the background, are cached by content, and can reload while the game runs.glTF import
SupportedScenes, meshes, materials, skins, morph targets, animations, cameras and lights, including compressed meshes and textures.Textures
SupportedPNG, JPEG and KTX2, with Basis Universal transcoding to whatever the device supports.Asset server
SupportedReference-counted handles, background loading, dependency tracking and asset hot reload.Animation playback
SupportedClips, crossfades, blend trees, state machines and layers.Inverse kinematics
SupportedTwo-bone, FABRIK and CCD chains, full-body IK, foot placement on uneven ground, and root motion.Animation compression
SupportedClips compress within an error bound you set and decode without allocation.Secondary motion
SupportedSpring bones for hair, cloth and accessories.Scenes and prefabs
SupportedScenes and prefabs are plain data files.Motion matching
PartialPose search works. There is no authoring pipeline yet.Rigid bodies and a lot more
Rigid-body physics runs on Rapier. The rest is built into the engine.Rigid bodies
Supported3D and 2D bodies, joints, ray and shape casts, and mesh and heightfield colliders.Character controller
SupportedMove a character through the world with collisions resolved for you.Fluids
SupportedParticle-based fluids on the CPU or the GPU.Snow, sand and goo
SupportedMaterial point simulation for elastic, snow, sand, goo and liquid materials, on the CPU or the GPU.Destruction
SupportedObjects break along precomputed fracture patterns when hit hard enough.Buoyancy
SupportedBodies float on a water plane or heightfield with drag.Rope and cloth
SupportedRope and cloth can hang from rigid bodies and pull on them.Soft bodies and cloth
PartialCloth runs on the CPU. There is no GPU solver yet.Vehicles
PartialA raycast vehicle exists but is not yet part of the main physics interface.The systems a game is made of
Game state lives in an entity-component-system world that steps at a fixed rate.Entity-component-system
SupportedEntities, components, relations and resources, stepped in fixed phases: input, simulation, late update, render.Game AI
SupportedBehaviour trees, utility AI, state machines, goal and task planners, and perception.Particles and effects
SupportedEmitters, trails, beams and screen shake.Voxel worlds
SupportedVoxel volumes with chunk streaming, level-of-detail meshing and ray casts.Tweens and timers
SupportedTweens, easing, springs, timers and scheduled ticks.Randomness and noise
SupportedA seeded random generator, coherent noise compatible with FastNoiseLite, and blue-noise sampling.GPU particles
PartialGPU kernels exist, but particles simulate on the CPU by default.A real-time mixer
Audio runs on a lock-free mixer with buses and effects, and plays on desktop, web and mobile.Mixer and effects
SupportedBuses, sends, EQ, filters, compression, delay, reverb, convolution, sidechain ducking and mixer snapshots.Spatial audio
SupportedDistance attenuation, cones, doppler, occlusion and binaural 3D sound for headphones.Streaming
SupportedLong tracks stream from disk with high-quality resampling.Sound design
SupportedProcedural sound effects, granular synthesis, and time-stretch and pitch-shift.Compressed formats
PartialWAV is always on. Ogg Vorbis and Opus are available but off by default.Every way players touch your game
Map raw input to actions once and use the same actions on every device.Action mapping
SupportedActions, contexts, dead zones, taps and holds.Keyboard, mouse and touch
SupportedPointer events and gesture recognition.On-screen controls
SupportedVirtual sticks and touch buttons.Haptics
SupportedVibration effects on supported devices.Gamepads
PartialSupported through the platform. Live polling on desktop needs an optional feature.Interfaces for apps and games
You describe the interface as components, and Keel updates only what changes when state changes.Components and state
SupportedComponents, signals and derived values, with conditional and list rendering.Layout
SupportedFlexible row and column layout that adapts to the screen.Themes
SupportedDesign tokens, and a full colour palette generated from one seed colour.Text
SupportedOpenType shaping, right-to-left and mixed-direction text, CJK line breaking, and sharp glyphs at any size.Markdown
SupportedRender Markdown with tables, task lists and code highlighting.Text input
PartialInput methods work on desktop. On mobile they depend on the platform integration.Accessibility
PartialScreen readers work on desktop. Mobile screen readers depend on the platform integration.Real websites, not a canvas
For websites Keel renders HTML instead of drawing pixels. This site is built that way.Real HTML pages
SupportedEach route becomes a real HTML page with its own title and metadata, readable by search engines and usable without JavaScript.Routing and data loading
SupportedRoutes, layouts and data loaders, with loading and error states.Streaming and hydration
SupportedPages can stream in as they render and become interactive where they need to.Minimal page updates
SupportedInteractive parts change only the elements that changed.Local development
Supportedkeel dev serves the site and reloads the page on every change.From HTTP to rollback netcode
Everything from a web request to a real-time multiplayer session.HTTP and WebSocket
SupportedHTTP requests and WebSocket connections.UDP and QUIC
SupportedDatagrams and QUIC with TLS 1.3.Connections and channels
SupportedHandshakes, reliable, unreliable and ordered channels, fragmentation, and round-trip and loss statistics.Multiplayer
SupportedClient prediction, interpolation, lag compensation and rollback, with the game world and physics saved and restored.Replication
SupportedEntity components replicate as compact deltas, with interest management by position and per-entity priority.WebTransport
PartialThe browser side is included. You provide the server and its certificates.The parts of an app that talk to the device
Each service is a small interface with a real implementation per platform, plus a test double you can script.Storage
SupportedKey-value storage, save games and files on native platforms and in the browser.Device basics
SupportedScreen size, safe areas, light or dark mode, clipboard, sharing, links, file picking and downloads, printing and screen capture.Notifications
SupportedLocal notifications, including scheduled ones.Localization
SupportedString tables with plural rules for a fixed set of locales.Purchases, ads and sign-in
PartialIn-app purchases, ads, platform sign-in and consent work through bridges the app wires up on each store.Speech
PartialText-to-speech on the web and desktop. Native mobile voices depend on the platform integration.AR and camera
PartialARKit and ARCore sessions, and camera access on the web and Linux, through platform bridges.On-device ML
PartialRun small neural networks, and ONNX models through an optional CPU backend.What Keel does not do today
So you can decide with the full picture.Visual editor
Not planned. Content is code and data files, driven from the command line.Consoles
Console builds produce a project skeleton only, with no platform SDK integration.VR headsets
There is no stereo rendering for headsets yet.Code hot reload
Assets reload while the game runs. Code changes need a rebuild.Keel Engine is invite-only for now
Keel is pre-1.0 and its source is private. We are working with a small number of teams building games, apps and websites. Invited teams get the source, the documentation and the keel command-line tool.To ask for an invitation, email:hi@sylphx.com