NEOLearn

Cargo features

The neo crate's cargo features: the profiles and collections, which features NEO's builds turn on, and the optional ones you can add.

Updated October 20, 2026

On this page

The neo crate is split into cargo features, so a build only compiles the parts it uses. Its default features give you the full engine for 2D, 3D, UI and audio. You can turn on more, or start from nothing and pick, for example for a headless server.

What NEO's builds use#

NEO's games, the Studio and the samples all build neo with its default features, plus:

FeatureWhy
system_font_discoveryText can use the fonts installed on the system.
mesh_pickingPointer picking against 3D meshes (already part of the defaults' picking).
android-native-activityAndroid builds only: the game runs as a NativeActivity.

When a page in this guide says a feature "isn't on in NEO's builds", it means it's outside this set and you have to add it yourself.

Profiles#

Profiles are the high-level groups. The default is all four:

ProfileWhat it gives you
2dThe core app, 2D rendering (sprites, 2D meshes, text), scenes and picking.
3dThe core app, 3D rendering (PBR, lights, glTF, post-processing, anti-aliasing), scenes and picking.
uiThe core app, NEO UI and its renderer, the headless widgets, scenes and picking.
audioAudio playback with Ogg Vorbis.

To build less, turn the defaults off and list what you need:

Cargo.toml
[dependencies]
neo = { workspace = true, default-features = false, features = ["2d"] }

Collections#

Collections are the mid-level groups the profiles are made of. Use them to build your own profile.

CollectionWhat's in it
default_appThe pieces almost every app needs, with no rendering: async tasks, assets, logging, states and automatic reflection registration. A good base for servers and command-line tools.
default_platformPlatform support: std, gamepads, windowing and input (winit), the clipboard, the default font, multithreading, WebGL 2, X11 and Wayland, custom cursors and system information diagnostics.
common_apiScene types without a renderer: animation, cameras, colours, curves, gizmos, images, meshes, shaders, materials, text, windows, and HDR and PNG images.
2d_api, 2d_neo_render2D types (sprites), then the built-in 2D renderer.
3d_api, 3d_neo_render3D types (lights, tangents, KTX2, morph targets, SMAA and tonemapping lookup tables), then the built-in 3D renderer (PBR, glTF, anti-aliasing, post-processing).
ui_api, ui_neo_renderUI and input focus, then the UI renderer.
sceneScenes and world serialization.
pickingPicking with all three backends: meshes, sprites and UI.
devDevelopment helpers: debug names, the developer tools, render debug tools and asset hot reload. Not for published games.
audio-all-formatsAudio with AAC, FLAC, MP3, MP4, Vorbis and WAV.
default_no_stdA starting point for no_std targets.

Optional features#

These are off in NEO's builds. Add the ones you need to your game crate's neo dependency, or try one for a single run with --features neo/<name>.

Development#

FeatureWhat it adds
file_watcherReloads assets when their files change. See Hot reload.
dynamic_linkingBuilds the engine as a shared library, for faster relinking during development. Not for packaged builds.
neo_dev_toolsThe developer tools, such as the FPS overlay. See Developer tools.
debugKeeps the names of systems and components for diagnostics and profilers.
track_locationRecords where in your code each entity was spawned and each component changed.
neo_remoteThe remote protocol, to inspect and edit a running app from another program. See Remote protocol.
neo_ui_debugAn overlay that outlines UI nodes.
trace, trace_tracy, trace_chromeProfiling spans, for Tracy or Chrome's trace viewer. See Profiling.

Assets and formats#

FeatureWhat it adds
jpeg, bmp, gif, webp, tga, tiff, exr, qoi, dds, basis-universalMore image formats. Only PNG, HDR and KTX2 are on by default.
wav, mp3, flac, aac, mp4More audio formats. Only Ogg Vorbis is on by default.
asset_processorThe asset processor, which prepares assets ahead of time. See Asset processing.
http, httpsLoading assets from web addresses. Think about what you allow before you turn it on.
serializeserde support on the engine's types.
neo_settingsLoading and saving settings.

Rendering#

FeatureWhat it adds
pbr_transmission_textures, pbr_specular_textures, pbr_anisotropy_texture, pbr_multi_layer_material_texturesMore texture slots on StandardMaterial. They can exceed the texture limit on older GPUs.
pbr_clustered_decals, pbr_light_texturesDecals and light textures.
experimental_pbr_pcssSoft shadows (PCSS).
area_light_luts, dfg_lut, bluenoise_textureLookup tables some lighting features need.
meshletA renderer for dense, high-polygon scenes. Experimental.
neo_solariRay-traced lighting. Experimental, and needs a GPU with ray queries.
webgpuWebGPU in the browser instead of WebGL 2. NEO's web builds use WebGL 2.
glesA native OpenGL or GLES backend, for GPUs without Vulkan. Not for the web.
statically-linked-dxcLinks the DirectX 12 shader compiler into the game. NEO's packaged Windows builds do this.

Other#

FeatureWhat it adds
neo_camera_controller, free_camera, pan_cameraReady-made camera controllers. NEO games use the camera director instead.
neo_feathers, neo_inspectorA styled widget set and an entity inspector built with it.
system_clipboardThe operating system's clipboard.
reflect_functions, reflect_documentationCalling functions through reflection, and doc comments at runtime.

multi_threaded is on by default (in default_platform). Without it, everything runs on one thread, as it does in the browser.

A headless app#

A server or tool with no window or renderer needs only the core:

Cargo.toml
neo = { workspace = true, default-features = false, features = ["default_app"] }

See The App for the code.

Next steps#