Web Bluetooth SDK for ORPHE CORE and ORPHE INSOLE

ORPHE-CORE-INSOLE.js

One SDK brings two devices to your browser. ORPHE CORE is a compact IMU sensor; ORPHE INSOLE is a smart insole with built-in pressure sensors. With this SDK, both devices connect seamlessly to your browser app over Web Bluetooth.

2 devices, 1 API Same OrpheCoreInsole class for CORE and INSOLE
ORPHE CORE 6-axis IMU, gait analysis, LED control
ORPHE INSOLE 6 pressure sensors + 6-axis IMU
BLE Web Bluetooth browser workflow

What is ORPHE-CORE-INSOLE.js?

CORE and INSOLE data, through one shared SDK.

ORPHE-CORE-INSOLE.js merges ORPHE-CORE.js and ORPHE-INSOLE.js into one SDK. Connection, reconnection, subscriptions, recording, and device commands share the same API, so code written for CORE moves to INSOLE (and back) with almost no changes.

One class, two profiles, automatic detection

Create new OrpheCoreInsole({ profile: coreProfile() }) or insoleProfile(). Omit the profile and the SDK shows both devices in the chooser and detects the type from the device name.

Reconnect, FIFO recording, gait analysis

Enable automatic reconnection with autoReconnect: true and cross-tab sharing with useSharedBridge: true. FIFO capture requires supported firmware. INSOLE also has gait analysis and a simulator.

Compatible with the previous libraries

Compatibility classes Orphe / OrpheInsole retain got* callbacks. Toolkit-created instances use the new API; use on() or attachLegacyCallbacks() when migrating.

Supported devices

Two devices, one SDK: pick the sensor that fits your idea.

ORPHE CORE, a compact IMU sensor that captures body movement in real time, and ORPHE INSOLE, a smart insole that measures plantar pressure distribution. Choose one for your use case or connect both at once: the exact same code handles either seamlessly.

ORPHE CORE 3.0 sensor module, front view
ORPHE CORE 3.0 Foot-mounted IMU module
ORPHE CORE

A compact motion sensor for measuring body movement, ready for any idea.

ORPHE CORE is a lightweight 6-axis IMU sensor device, only about 20 g, that tracks body movement with high precision. Besides raw sensor values, it computes gait analysis on the device, including step count, gait type, stride, and pronation.

Sensors 6-axis IMU + on-device gait analysis

3-axis acceleration and 3-axis gyroscope, sampled at up to 200 Hz on CORE 3.0. Gait events are delivered per step.

Range ±2–16G / ±250–2000dps

Selectable acceleration and gyroscope ranges via the SDK.

Form 45 × 29 × 14 mm, approx. 20 g

IPX7 water resistance, full-color LED, micro USB charging, about 8 hours per charge.

Mount Shoelace mount or ORPHE shoes

Attach to any laced shoe with the shoelace mount, or use dedicated shoes. Two modules are needed to measure both feet.

EASYRUN SHIBUYA 3.0 and RUNWALK ORPHE are listed as compatible shoes. The SDK supports CORE 2.0 and 3.0; 200 Hz data-loss detection is available on CORE 3.0 only.

ORPHE INSOLE beta evaluation kit
ORPHE INSOLE β Evaluation Kit
ORPHE INSOLE

A pressure and motion platform inside the insole.

ORPHE INSOLE is a smart insole that replaces a regular one. Six pressure sensors per foot and a 6-axis IMU measure foot pressure and motion in real time.

Sensors 6 pressure sensors + 6-axis motion

Each foot includes six pressure sensors plus 3-axis acceleration and 3-axis gyroscope data.

Range ±16G / ±2000dps / 0-148N

Store-listed ranges for acceleration, gyroscope, and pressure measurement.

Sampling 100Hz / 200Hz

Sampling rate may vary depending on the application and mode.

Battery Approx. 24 hours

Magnetic connector charging, plus wireless charging with the separately sold ORPHE MAT.

The official store currently lists ORPHE INSOLE β as an Evaluation Kit for approved customers and research partners, including three pairs of insoles and an iOS app. It received the CES 2026 Best of Innovation award (Sports & Fitness).

What data can you get?

Subscribe to the fields you need with on().

The SDK parses the packets; you receive values with ble.on('field', callback). Use '*' to get the whole sample. Available fields differ per device, so use the two groups below as a reference.

ORPHE CORE

Motion, gait analysis, and device control

Choose from three modes: SENSOR_VALUES (raw), STEP_ANALYSIS (gait), or both at once.

on('converted_acc' | 'converted_gyro' | 'quat' | 'euler')

Motion sensor values

Acceleration, angular velocity, quaternion, and Euler angles. Up to 200 Hz on CORE 3.0 for games, visuals, and sound.

on('steps_number' | 'gait' | 'direction' | 'distance')

Gait analysis

Step count, gait type, direction, distance, calories, and stance / swing phase durations computed on the device per step.

on('stride' | 'pronation' | 'foot_angle' | 'landing_impact')

Foot metrics

Stride length, pronation, foot angle at contact, and landing impact for running form and rehabilitation prototypes.

commands.setLED / setMountPosition / resetAttitude

Device control

Full-color LED patterns and brightness, mount position, sensor range, attitude reset, and device information read / write.

ORPHE INSOLE

Pressure, motion, and orientation

The real-time sensor stream uses SENSOR_VALUES; streamingMode 1 / 3 / 4 selects its fields. Gait analysis and FIFO recording use separate acquisition paths.

on('press' | 'converted_press')

Pressure values

Six raw pressure channels per foot and load in newtons. Conversion uses individual calibration coefficients when available, otherwise a default conversion formula shared by all channels.

on('converted_acc')

Acceleration

Converted XYZ acceleration for movement intensity, step timing, and interaction design.

on('converted_gyro')

Angular velocity

Rotational motion of the foot without writing your own BLE parser.

on('quat' | 'euler')

Orientation

In default streaming mode 4, quaternion and Euler angles arrive together with pressure and motion data.

InsoleGait

INSOLE gait analysis

InsoleGait records per-step gait rows from INSOLE and exports CSV.

createInsoleSimulator()

Simulator

Develop without hardware: a virtual INSOLE that goes through the same parsing path as a real device.

ORPHE INSOLE with the sensor coordinate frame drawn on it: Y toward the toes, X to the right of the toe direction, Z upward out of the insole surface. Top view of left and right ORPHE INSOLE with pressure sensors numbered 1 to 6.
Sensor reference (INSOLE)

Coordinate system and pressure sensor placement

The sensor frame is right-handed and Z-up: Y points toward the toes, X to the right of the toe direction, and Z upward out of the insole top surface (accZ reads about +1 G at rest). Six pressure sensors per foot are numbered 1–6 as shown; press.values[i] corresponds to sensor i + 1.

CORE + INSOLE

Shared on both devices

on('ble_frequency' | 'lost_data')

Stream health

Measured packet rate and detected gaps in serial numbers, so you can tell BLE drops from sensor behavior.

onEvent('onConnect' | 'onDisconnect' | …)

Lifecycle events

Connect, disconnect, errors, and reconnect progress. Subscribe as many times as you like; each call returns an unsubscribe function.

FifoRecorder

Recording helpers

FIFO retrieves buffered samples to recover gaps and exports CSV. Requires CORE firmware dated 20260125 or later, or INSOLE firmware dated 20260510 or later. Unrecoverable loss is reported via onDataLoss; stopOnLoss defaults to false. Unknown firmware is not filtered, so availability is unconfirmed.

Sample data

Walking and running data from real devices, with video.

12 trials recorded with ORPHE INSOLE β: normal walking, 8 simulated pathological gaits and treadmill running at 3 speeds. Check the waveforms synchronized with video in the browser, then download CSV, ARKit skeleton and video all at once or per trial.

Please read the terms of use before downloading. The data may not be redistributed.

Quick start

Connect either device and print live data.

Serve this page over HTTPS or localhost in a Web Bluetooth-capable browser. Load the CDN build and get OrpheCoreInsole from OrpheCoreInsoleJS. With no profile specified, the chooser lists both CORE and INSOLE and detects the selected type.

Device begin() type / option Data stream
CORE 'SENSOR_VALUES' Raw acceleration, gyro, quaternion at 50–200 Hz.
CORE 'STEP_ANALYSIS' Gait events are delivered when the step count increases; their timing differs from the packet notification rate. Default when the type is omitted.
CORE 'STEP_ANALYSIS_AND_SENSOR_VALUES' Both streams at once.
INSOLE { streamingMode: 4 } Gyro, acceleration, pressure, quaternion. 100 Hz sampling, 50 Hz packets. Default.
INSOLE { streamingMode: 3 } Gyro, acceleration, pressure. 200 Hz sampling, 50 Hz packets; no quaternion.
INSOLE { streamingMode: 1 } Quaternion, acceleration, gyro. 200 Hz sampling, 50 Hz packets; no pressure.

For CORE gait analysis, replace the common example’s script with the following. Use STEP_ANALYSIS_AND_SENSOR_VALUES when both streams are needed.

const { OrpheCoreInsole, coreProfile } = OrpheCoreInsoleJS;
const core = new OrpheCoreInsole({ profile: coreProfile() });
core.on("gait", (gait) => console.log(gait));
document.getElementById("connect").onclick = () =>
  core.begin("STEP_ANALYSIS").catch(console.error);

Need a connect toggle and a settings modal? Also load orphe-core-insole-toolkit.js and build the UI with buildCoreToolkit() / buildInsoleToolkit() (requires Bootstrap 5).

References: API reference (TypeDoc) / Usage in the README / Release tags.

<button id="connect">Connect ORPHE CORE / INSOLE</button>
<pre id="sensor-data"></pre>
<pre id="pressure-data"></pre>

<script src="https://cdn.jsdelivr.net/gh/Orphe-OSS/ORPHE-CORE-INSOLE.js@v0.3.0/dist/browser/orphe-core-insole.js"></script>
<script>
  const { OrpheCoreInsole } = OrpheCoreInsoleJS;
  const ble = new OrpheCoreInsole();

  ble.on("converted_acc", (acc) => {
    document.getElementById("sensor-data").textContent =
      JSON.stringify({ x: acc.x, y: acc.y, z: acc.z });
  });
  ble.on("press", (press) => {
    document.getElementById("pressure-data").textContent =
      JSON.stringify(press.values);
  });

  document.getElementById("connect").onclick = async () => {
    try {
      await ble.begin("SENSOR_VALUES");
      console.log("connected:", ble.profile.kind);
    } catch (error) {
      document.getElementById("sensor-data").textContent = String(error);
    }
  };
</script>

Try the examples

Pick an example for your device, or one that runs on both.

All examples are static pages running on the CDN build, published from the separate ORPHE-CORE-INSOLE.js-EXAMPLE repository. Open one in your browser and connect right away.

Migrating from ORPHE-CORE.js / ORPHE-INSOLE.js

Choose the migration path for your existing API.

Direct users of new Orphe() / new OrpheInsole() can use the compatibility globals. Since v0.2.0, toolkit-created cores / insoles / orpheCore are OrpheCoreInsole instances: migrate to on() / onEvent(), or use attachLegacyCallbacks() for old callbacks. Replacing script URLs alone does not migrate every app; check the README migration table.

ORPHE-CORE.js / ORPHE-INSOLE.js ORPHE-CORE-INSOLE.js
new Orphe(0) / new OrpheInsole(0) new OrpheCoreInsole({ profile: coreProfile(), id: 0 }) / insoleProfile()
ble.setup() Not needed
ble.gotAcc = (acc) => {…} ble.on('acc', (acc) => {…})
ble.onConnect = () => {…} ble.onEvent('onConnect', () => {…})
ble.setLED(1, 0) / resetMotionSensorAttitude() ble.commands.setLED(true, 0) / ble.commands.resetAttitude()
OrpheInsoleFifo / OrpheInsoleGait / OrpheInsoleSimulator FifoRecorder / InsoleGait / createInsoleSimulator()

What you can build

Prototype around the use cases CORE and INSOLE are built for.

CORE's motion and gait data suit games and body expression; INSOLE's foot pressure suits balance and load analysis. Connect both to build research tools that observe motion and ground contact together.

Sports & games

Body-controlled games and sports

Run, jump, kick, and swing with foot motion as the controller: virtual sports, rhythm games, and training feedback.

Research

Biomechanics datasets

Record synchronized motion, gait, and pressure streams for validation, exploratory analysis, and AI dataset creation.

Safety

Work-safety inspection

Explore fall, slip, trip, and fatigue-related motion signals before connecting them to larger safety systems.

Tools

Device inspection

Build dashboards for device state, packet health, left/right assignment, and data stream debugging.

Beta notice

ORPHE-CORE-INSOLE.js is currently provided as a beta library.

Documentation and tutorials are still being improved. Web Bluetooth requires Chrome or Edge (desktop / Android). Safari and Firefox are not supported; on iOS, use a Web Bluetooth browser such as Bluefy.

Send feedback

Usage policy

Free for all non-commercial projects. Commercial use requires a separate agreement.

This SDK carries over the policy of the earlier ORPHE-CORE.js / ORPHE-INSOLE.js. You can use and modify it freely at no cost for personal projects, prototypes and internal validation, education and workshops, non-commercial research at universities and similar institutions, and free or non-commercial apps and services.

Free use

Free use

Education/workshops, academic non-commercial research, personal creative projects, prototypes/internal experiments, and free non-commercial services are allowed.

Commercial

Commercial use

Paid apps, paid services, commercial SDK integrations, commissioned products, or business services require a separate commercial agreement with ORPHE.

Scope

Version scope

This page follows the ORPHE-CORE.js v1.4.0 and later policy. All releases of ORPHE-CORE-INSOLE.js use the same usage policy. See LICENSE.md in the repository.

Copyright

Copyright and licensing

Copyright (C) 2025–2026, Tetsuaki BABA and ORPHE Inc. See the usage policy for allowed uses and commercial agreement requirements.