Your experience.
Your integration.

A processor inside your app.

SimplyBeautyKit processes camera pixels on the device. Your app controls capture, permission prompts, effect selection, previews and publishing. LiveKit and WebRTC integrations apply effects before video encoding.

The examples below assume an initialized engine with models or injected observations configured. Apply a look on selection or strength changes; process frames on your camera processing queue.

Profiles coordinate skin and makeup and reset face reshaping to zero. Individual reshape controls remain an explicit app choice. A profile change also disables the active LUT contribution; apply your filter afterward to combine them.

Fine-tune the finish.

Adjust smoothing, brightening, rosiness and sharpening independently. Skin-only processing uses face tracking to localize the treatment; configure models or current injected landmarks first. These Kotlin controls apply to an initialized engine:

engine.setBeautySkinOnly(true)
engine.setSmoothing(0.3f)
engine.setWhitening(0.08f)
engine.setRosiness(0.06f)
engine.setSharpening(0.1f)

Intensities run from zero to one. Changing intensity changes the appearance; it does not imply a proportional reduction in processing cost. These controls do not change face proportions.

Start coordinated. Make it personal.

Fourteen authored looks plus Off combine skin settings with makeup. Natural is makeup-free; Velvet Night and Glam use more defined lips and eyes. An overall strength controls the selected recipe, and individual setters let your app customize it.

import com.simplybeauty.BeautyProfile

val status = engine.applyBeautyProfile(
    BeautyProfile.VELVET_NIGHT, 0.5f
)
if (status == SimplyBeautyEngine.Status.OK.code) {
    engine.setLipstick(0.4f)
    engine.setBlush(0.25f)
}

Apply individual edits after the profile. Reapplying the profile or its strength replaces those edits. Read getParams() to keep the app’s controls synchronized. Full makeup requires High quality and usable face observations.

Proportions, by choice.

Dedicated controls cover the face, jaw, chin, nose, eyes, lips and brows. The original 26 controls use signed values from −1 to 1, with zero neutral. Keep them separate from a look’s skin and makeup strength.

import com.simplybeauty.Reshape

engine.setReshape(Reshape.FACE_V_SHAPE, 0.15f)
// Restore this control to neutral:
engine.setReshape(Reshape.FACE_V_SHAPE, 0f)

Applying a built-in profile resets all face reshaping to zero. If your interface offers explicit shaping alongside a look, apply the user’s chosen values afterward. Shaping depends on current face landmarks.

Give the scene a new setting.

Choose background blur, a solid color or an image. Person segmentation supplies the foreground boundary: enable built-in segmentation with its model for CPU pixel processing, or provide a current person mask for the GPU texture path.

engine.setVirtualBackgroundBlur(0.35f)

// Turn virtual background processing off:
engine.clearVirtualBackground()

Background effects are independent of beauty profiles; choosing Off does not clear an existing background. Chroma key is a separate option for keyed scenes. See the API reference for masks, fill modes and image loading.

Native Kotlin controls.

import com.simplybeauty.BeautyProfile
import com.simplybeauty.SimplyBeautyEngine

// engine is already initialized.
val status = engine.applyBeautyProfile(
    BeautyProfile.VELVET_NIGHT, 0.5f
)
if (status == SimplyBeautyEngine.Status.OK.code) {
    val controls = engine.getParams()
    // Synchronize your sliders with this snapshot.
}

Build from your SDK checkout

Use JDK 17+, the Android SDK, NDK 27.1.12297006 and SDK CMake 3.22.1. Run from the repository root:

scripts/build_aar.sh

# Optional models for built-in tracking / segmentation:
scripts/download_models.sh
cd android
./gradlew :models:assembleRelease

Link android/lib/build/outputs/aar/lib-release.aar. The optional models artifact is android/models/build/outputs/aar/models-release.aar. A Gradle composite build can consume the source modules directly; see the build guide.

Install bundled model files off the UI thread with SimplyBeautyModels.install(context), then pass its modelDir and resourcePath into SimplyBeautyEngine.Config. Without models, supply face observations from your own detector.

Swift, with a shared core.

import SimplyBeauty

// engine is already initialized.
let status = engine.applyBeautyProfile(
    .velvetNight, strength: 0.5
)
if status == .ok {
    let controls = engine.params
    // Synchronize your sliders with this snapshot.
}

Choose source or a Release framework

Add the SDK checkout as a local Swift package and link the SimplyBeauty product. Local CocoaPods integration is also available. To produce the optimized device and Simulator framework:

scripts/download_models.sh
scripts/sync_models.sh
scripts/build_ios_xcframework.sh

Link build/SimplyBeauty.xcframework and embed build/SimplyBeauty_SimplyBeauty.bundle. The bundle includes resources and the privacy manifest. Set SBConfig.useBundledResources = true to opt into bundled models.

Use Release builds when evaluating performance. Source packages follow the host app’s build configuration; Debug performance is not representative.

One engine underneath.

# In your CMake project:
add_subdirectory(SimplyBeautyKit/core simplybeauty)
target_link_libraries(app PRIVATE simplybeauty::simplybeauty)

#include <simplybeauty/simplybeauty.h>
using namespace simplybeauty;

// engine is an initialized SBEngine.
const auto status = engine->ApplyBeautyProfile(
    SBBeautyProfile::VelvetNight, 0.5f);
if (status == SBStatus::Ok) {
    const auto controls = engine->GetParams();
}

Create an engine with frame dimensions, pixel format and model configuration, then call Init(). The API reference covers the complete lifecycle, status codes, ownership and threading contract.

Keep frames and effects together.

• Match the camera. Configure actual buffer dimensions, rotation and mirror state. Resize the existing engine when dimensions change.
• Keep observations current. Injected landmarks and masks must describe the same upright, unmirrored capture. GPU texture inputs require host-supplied observations for detection-dependent effects.
• Handle one frame at a time. Keep processing off the UI thread, check returned status, and define your host’s error and dropped-frame behavior.
• Choose quality deliberately. High quality enables the complete beauty stack. Lower tiers can suppress makeup and other effects; profiles do not override the selected tier.
• Own the interface. Store profile selection and edits in your app. Read parameters after applying a look so older saved settings do not overwrite it.

CPU frame formats include I420, NV12, NV21, RGBA, BGRA and Android YUV_420_888. iOS also exposes CVPixelBuffer processing. GLES and Metal paths have their own setup and input requirements.

Explore the LiveKit integration guide →

A shared collection. Your app’s rules.

The mask catalog modules provide bundled defaults, cached discovery, thumbnails and verified material downloads. Your backend controls access and purchases. Your app controls selection and rendering.

Android includes com.simplybeauty.mask in the library. Swift uses the separate ios/MaskCatalog package, product SimplyBeautyMaskCatalog, requiring iOS 15+.

A downloaded material is not a face tracker or a complete mask renderer. The host must provide synchronized geometry and compositing. Concealing a face reliably requires a separate host privacy policy and fallback.

Read the catalog integration contract →

The details, available to read.

These instructions use a source checkout or locally built artifacts. Public package-registry distribution is not assumed. The core is Apache-2.0 licensed; model and resource notices must be reviewed separately.