<!-- Page: https://rustic-game-engine.pages.dev/docs/api/path/follow -->

# Path.follow()

[Path](https://rustic-game-engine.pages.dev/markdown/api/path.md)

## Compatibility

**Supported languages:** C, C++, C#, Python, JavaScript, Lua 5.4, Luau, Java, PHP and HTML/inline JavaScript (binding spellings and return shapes differ).

Use a compatible native engine build and the language tools required by your binding. This does not establish browser/mobile export or release qualification for every OS.

The signature below is the shared reference notation; language examples show the actual binding syntax. Question marks mark optional arguments and explicit defaults are shown where recorded. Do not copy reference notation as a typed declaration.

See [Feature status and compatibility](https://rustic-game-engine.pages.dev/markdown/reference/compatibility.md) for API 1.0/1.1 and per-method restrictions. Engine release tags and Docs v0.1 are independent versions.

## Signature

`Path.follow(entity, path, options)`

## Setup and usage

These engine-owned services work in Lua 5.4, Luau, JavaScript, Python, C, C++, C#, Java, PHP, and HTML inline JavaScript. Follow [Use gameplay actions](https://rustic-game-engine.pages.dev/markdown/guides/gameplay-actions.md) to create and attach a script, install external toolchains, and choose the correct language binding. PHP and HTML scripts belong under `ui/`; CSS alone runs no gameplay code.

The Calls section uses JavaScript signatures. The function examples below include native syntax for all ten script types, including SDK-specific alternatives and limitations. Attach a JavaScript Object Component script to the specified target and press **Play**. Globals are supplied by the engine. Schedule actions from `Start` or a callback, rather than at script top level. Native languages use typed options and their own builder conventions; see the guide's language bindings.

## Parameters

Points are vectors or {point, easing} entries. Kind is Linear, Bezier, CubicBezier, CatmullRom or Spline. Follow options require exactly one of duration or speed, with optional easing, loop, pingPong and orientToPath.

## Return and timing

Create returns reusable path data. Follow returns an operation handle advanced by the shared scheduler.

## Execution behavior

Core write timing differs between immediate Lua host calls, deferred JavaScript/Web commands and external SDK query flushes. Scheduled actions advance with the scene clock; synchronous queries evaluate at the call. Follow [execution rules](https://rustic-game-engine.pages.dev/markdown/guides/scripting.md#when-mutations-take-effect) and the return/timing notes for this category.

## Language examples

Choose one snippet at a time and place it inside your language's Start/on_start callback. These are independent examples; each creates its own handles or builders. Follow [Gameplay language bindings](https://rustic-game-engine.pages.dev/markdown/guides/gameplay-actions/language-bindings.md) for imports and callback registration. Python must import the modules used in its snippet from rustic; C# uses using static Rustic; Java examples belong inside a Rustic subclass; PHP callbacks declare global $rustic. HTML snippets go inside an inline script in a ui/ HTML asset.

Use an anchored Part for transform and effect examples, an unanchored collidable Part for forces, and a perspective camera named Camera for camera examples. Create Target for follow examples. Audio examples require assets/music.ogg in the Play snapshot. Replace scene paths with those listed by Game.scene.List(). Animation playback and sequence-animation examples require the Reveal fixture on the [Animation page](https://rustic-game-engine.pages.dev/markdown/api/animation.md); marker callbacks also require its Halfway marker. Run clock controls separately; a paused clock cannot advance a timer.

C callback examples use these file-scope functions before on_start:

```c
static void on_done(void) { rustic.log("info", "done"); }
static void on_sample(RusticValue value) { (void)value; rustic.log("info", "sample received"); }
static void on_event(const RusticValue *args, size_t count) {
    (void)args; (void)count; rustic.log("info", "event received");
}
```

### Lua 5.4

```lua
local path = Path.create({{0,0,0}, {10,0,0}}, "Linear")
Path.follow(rustic.entity_id(), path, {duration=2,orientToPath=true})
```

### JavaScript

```javascript
const path = Path.create([[0,0,0], [10,0,0]], "Linear");
Path.follow(rustic.entity_id(), path, {duration:2,orientToPath:true});
```

### Python

```python
path = Path.create([[0,0,0], [10,0,0]], "Linear")
Path.follow(rustic.entity_id(), path, {'duration':2,'orientToPath':True})
```

### C++

```cpp
auto path = Path::create({{{0,0,0}}, {{10,0,0}}}, "Linear");
Path::follow(rustic.entity_id(), path, 2, Ease::OutCubic, false, false, true);
```

### C#

```csharp
var path = Path.create(new double[][]{new double[]{0,0,0}, new double[]{10,0,0}}, "Linear");
Path.follow(rustic.entity_id(), path, 2, Ease.OutCubic, false, false, true);
```

### Luau

```lua
local path = Path.create({{0,0,0}, {10,0,0}}, "Linear")
Path.follow(rustic.entity_id(), path, {duration=2,orientToPath=true})
```

### C

```c
RusticPathPoint points[] = {{{0,0,0}, "Linear"}, {{10,0,0}, "Linear"}};
RusticPath path = Path.create(points, 2, "Linear");
Path.follow(rustic.entity_id(), path, 2, 0, Ease.OutCubic, false, false, true, NULL);
Path.destroy(&path);
```

### Java

```java
var path = Path.create(new double[][]{{0,0,0}, {10,0,0}}, "Linear");
Path.follow(rustic.entity_id(), path, 2, Ease.OutCubic, false, false, true);
```

### PHP

```php
$path = Path::create([[0,0,0], [10,0,0]], "Linear");
Path::follow($rustic->entity_id(), $path, ["duration"=>2,"orientToPath"=>true]);
```

### HTML / inline JS

```javascript
const path = Path.create([[0,0,0], [10,0,0]], "Linear");
Path.follow(rustic.entity_id(), path, {duration:2,orientToPath:true});
```

## Shared Path constraints

- An anchored Part traverses the local path in eight seconds, reverses at its end and repeats, facing its direction of travel.
- Bezier supports 2–32 control points; CubicBezier requires four. Other paths support 2–4096 points. Spline uses uniform Catmull-Rom.
- Global and segment easing change traversal, not curve geometry. Starting-point easing applies to the following segment; Bezier uses its first point for the single span.
- Speed uses approximate arc length. Looping repeats a span; a geometrically closed loop needs matching endpoints. OrientToPath faces local -Z along the tangent.
- C path storage requires Path.destroy after use; the scheduled action owns its path data.
- Check script attachment, enabled state and the Console when an operation fails. Asynchronous errors also appear in operation state. Callback exceptions disable the owner and clean up its actions.
- Owner destruction, disable, successful reload or Stop cleans up owned actions and subscriptions. Failed reload retains the previous behavior's operations. See [Operation handles](https://rustic-game-engine.pages.dev/markdown/api/operation-handles.md) for controls and lifetime details.

## Errors and debugging

Read the constraints above and the Console diagnostic. Invalid types, non-finite values, stale targets or unavailable native services can fail validation. A failed callback disables the behavior; a failed source reload keeps the last good instance. Exact error messages depend on the language adapter. See [Troubleshooting](https://rustic-game-engine.pages.dev/markdown/troubleshooting.md).

## Related APIs

- [Path.create()](https://rustic-game-engine.pages.dev/markdown/api/path/create.md)

[All path APIs](https://rustic-game-engine.pages.dev/markdown/api/path.md)