# Where the SDKs run

Every SDK ships as source and speaks plain HTTPS to the same four endpoints. There is no prebuilt binary in any of them. The platform specific code is small: the LÖVE SDK's HTTPS transports, and the app background handling on iOS and Android. The C++ and Odin SDKs link libcurl for the HTTP calls. The LÖVE SDK runs on the desktop, and on the web through the JavaScript SDK; see the [LÖVE SDK reference](https://ravensight.io/docs/love-sdk/). A cell says Untested where no build of that SDK has been run on that platform yet.

## Support matrix

| SDK | Desktop | iOS | Android | Web | Console |
| --- | --- | --- | --- | --- | --- |
| Godot | Yes | Untested | Untested | Yes, on the web export | Untested, subject to cert |
| Unity | Yes on macOS, in the Unity 6 Editor and a macOS player. Windows and Linux untested | Untested | Untested | Untested, on WebGL | Untested, subject to cert |
| Unreal | Untested. Mac editor and game targets build on Unreal Engine 5.8.3, no packaged game has run yet | Untested | Untested | No web target in UE5 | Untested, subject to cert |
| JavaScript (web and Node) | Yes, in Electron or Node | Untested, in a web view | Untested, in a web view | Yes | Not applicable |
| C++ | Yes on macOS, C++17 plus libcurl. Linux in CI, Windows untested | Untested | Untested | Not applicable | Untested, subject to cert |
| Odin | Yes on macOS, via libcurl. Windows and Linux untested | Untested | Untested | Not applicable | Untested |
| LÖVE | Yes on macOS. Windows and Linux untested | Not supported yet | Not supported yet | Through ravensight-js and the love.js bridge | Not supported yet |
| iOS native Swift | Yes, macOS 12+ | iOS 15+. Tests pass on the iOS Simulator, untested on a device. tvOS 15+: tests pass on a tvOS simulator | Not applicable | Not applicable | Not applicable |
| Android native Kotlin | Not applicable | Not applicable | minSdk 24. Tests pass under Robolectric, untested on a device or emulator. Meta Quest runs Horizon OS, which is Android, so the same SDK runs there unchanged | Not applicable | Not applicable |
| Any engine via HTTP | Yes | Yes | Yes | Yes | Yes, subject to cert |

These are honest cells, not a marketing grid. A Yes here means a build of that SDK has run there, and Untested means it has not yet. What we have not done is ship a title on every one of them, so treat even a Yes in the mobile and console columns as "nothing in the way" rather than "verified in a submitted build". Each SDK's README lists exactly what was run.

## Consoles

Nothing in any SDK is blocked on a console. What is blocked is everything else about console networking: each platform holder requires that outbound traffic, privacy disclosure, and any data collection be declared and approved as part of certification, and NDA restrictions mean we cannot ship console specific code publicly anyway. Ravensight is an ordinary HTTPS call from your title's own network stack, and passing cert with it is the developer's responsibility, exactly as it would be for a leaderboard or a patch notes fetch.

## Mobile privacy

Ravensight does not touch an advertising identifier. Every SDK generates its own random device id on first run and stores it locally. The Godot and LÖVE SDKs write 32 lowercase hex characters, a hyphen and the OS name, so `3f9ac2e17b5d4c0e8a61f2b9d7c04e5a-android` is what one looks like. The Unity, C++, Odin, iOS and Android SDKs write `dev_` and 32 hex characters from 16 random bytes; Unreal writes `dev_` and a random UUID, and the JavaScript SDK writes `dev_` and a random UUID where the browser or Node offers one, else 32 hex characters. No IDFA on iOS, no Android advertising id, no hardware identifier, and no IP based fingerprinting. That id is meaningless outside your game's own data, and nothing in Ravensight ever joins it to a name, an email or an account, because the SDK has no field for any of those.

An event row holds the game id, the device id, the session id, the event name, a timestamp, and the level, platform, version and payload you sent. Unless you switch them off, it also holds the country the session connected from and the device model, OS version and GPU the SDK sent (see [country and device](https://ravensight.io/docs/platform-support/#country-device)). It holds no IP address, no user agent and nothing finer than a country, and it is deleted after 90 days. To detect abuse, a keyed hash and a masked form of the address a session connects from are kept for 30 days, or for as long as you keep that address blocked, never the full address (see [traffic sources](https://ravensight.io/docs/traffic/)). Two things outlive that window: one record per game and device with the first day it was seen, kept for the game's lifetime so lifetime and new-player counts stay correct, and any feedback text a player typed, kept until you delete it or the game.

## Country and device

Two more things are collected by default, and one switch per game turns both off: **Record country and device fields** on the game's card under **Settings > Projects**, or `countryDeviceEnabled: false` on `PATCH /api/v1/games/:gameId`.

- **Country.** When a session starts, the server looks up the country of the address the request connected from, in an offline database bundled with the server, so no request leaves Ravensight to answer it. Only the two-letter country code (such as `US`) is kept, on the session and on each of its events. The address itself is never stored. A private or unknown address gives an empty value, and the SDK cannot send or change the country. IP geolocation by [DB-IP](https://db-ip.com), used under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/).
- **Device.** SDK builds that support it send an optional `device` object when a session starts: `model` (the device model name, never a serial or other unique id), `osVersion` (the version only, since the platform already names the OS) and `gpu` (the graphics adapter name). Each is trimmed and cut to 128 characters, and a value with a control character is stored as empty. An SDK sends only what its engine exposes without a permission prompt: Godot 0.5.0, Unity 0.5.0 and Unreal 0.5.0 send all three, C++ 0.5.0 and Odin 0.6.0 send the values your game sets in their config, iOS 0.6.0 and Android 0.5.0 send the model and OS version, and LÖVE 0.7.0 sends the GPU name. A Meta Quest headset reports its model as `Meta Quest 3`, and so on, to tell it from a phone.

With the switch off, new sessions store empty values for all four, the game's live sessions are cleared, and every batch that arrives after the switch is written without them. Events already accepted and waiting to be written at the moment you switch it off may still carry them. Events written before the fields existed, or while the switch was off, read as unknown: nothing is filled in afterwards.

## Tracking prompt, opt-out and reset

**No App Tracking Transparency prompt is required for Ravensight.** Apple defines tracking as linking data collected from your app about a user or device with data collected from other companies' apps, websites or offline properties for targeted advertising or advertising measurement, or sharing it with a data broker. Ravensight does neither: the id is yours alone, it is never combined with another company's data, and nothing reaches an ad network or a data broker. So on Ravensight's account you do not need to call `requestTrackingAuthorization`. If something else in your app does track across companies, that decision is unchanged by this.

Two SDK calls exist for studios that show their own consent screen. Ravensight ships no consent UI; wire these to your own settings menu if your audience or your lawyer wants one.

- **The opt-out** stops the SDK sending anything: queued events are dropped and no further request is made, not even the startup check. Every SDK except JavaScript saves the choice locally, so it survives a restart until the player turns it back on. The JavaScript SDK does not store it: keep the choice in your own settings and apply it before the first event on every launch.
- **The reset** saves a new random id and opens a new session under it, so a player can start a fresh analytics identity from your game's own settings. Rows already stored under the old id are not rewritten; they expire with the game's selected raw-event window (90 days by default, or 180 or 400 days with extended retention), or sooner if you delete the game.

| SDK | Opt-out | Reset |
| --- | --- | --- |
| Godot | `Ravensight.set_tracking_enabled(false)` | `Ravensight.reset_device_id()` |
| JavaScript | `rs.setEnabled(false)`, not saved | `await rs.resetDeviceId()` |
| LÖVE | `ravensight.setTrackingEnabled(false)` | `ravensight.resetDeviceId()` |
| Unity | `Ravensight.SetTrackingEnabled(false)` | `Ravensight.ResetDeviceId()` |
| Unreal | `SetTrackingEnabled(false)` on the subsystem | `ResetDeviceId()` |
| C++ | `client.set_tracking_enabled(false)` | `client.reset_device_id()` |
| Odin | `rs.set_tracking_enabled(client, false)` | `rs.reset_device_id(client)` |
| iOS | `Ravensight.setTrackingEnabled(false)` | `Ravensight.resetDeviceId()` |
| Android | `Ravensight.setTrackingEnabled(context, false)` | `Ravensight.resetDeviceId()` |

## Store disclosures and the privacy manifest

You do still have disclosure obligations, and they are yours rather than ours, because Apple and Google ask the publisher of record. The answers below cover what Ravensight collects on its own account; add whatever your own events carry on top, and if you send something personal, disclose it.

- **App Store privacy details.** Declare **Device ID** under Identifiers and **Product Interaction** under Usage Data, both under **Data Not Linked to You**, purpose **Analytics**, and answer **Data Not Used to Track You**. With the country and device fields on (the default), also declare **Coarse Location** under Location and **Other Diagnostic Data** under Diagnostics, the same way. Add **Crash Data** under Diagnostics only if you send crash events.
- **Apple privacy manifest.** With any SDK other than the Swift package, add the `NSPrivacyCollectedDataTypes` entries below to your `PrivacyInfo.xcprivacy`, with `NSPrivacyCollectedDataTypeLinked` false and `NSPrivacyCollectedDataTypeTracking` false on both, and `NSPrivacyTracking` false. The required-reason entries depend on the SDK. The Swift package ships its own `PrivacyInfo.xcprivacy`, which Xcode merges into your app's privacy report: it declares `NSPrivacyAccessedAPICategoryUserDefaults` with reason `CA92.1`, tracking false, and Device ID and Product Interaction as collected, so you do not add those two yourself. With the country and device fields on, add `NSPrivacyCollectedDataTypeCoarseLocation` and `NSPrivacyCollectedDataTypeOtherDiagnosticData` to your app's own manifest with any SDK, the Swift package included, linked false, tracking false, purpose Analytics. Unity's `PlayerPrefs` is `UserDefaults` on iOS, so a Unity game's manifest must declare `NSPrivacyAccessedAPICategoryUserDefaults` with `CA92.1` if the engine's own manifest does not already. Godot and Unreal store a file in the app's own container and add no required-reason entry of their own, so leave whatever your engine's export already declares exactly as it is.
- **Android.** The `android.permission.INTERNET` permission is the only one any SDK needs. No `AD_ID` permission, and nothing that triggers a runtime permission dialog. In the Play Console Data safety form declare **Device or other IDs** and **App interactions** as collected, not shared, for Analytics, not for advertising, and with the country and device fields on also **Approximate location** and **Diagnostics** the same way; answer yes to encrypted in transit, because every request is HTTPS; and answer yes to a deletion path, which is the reset call above plus deleting the game. With the native Android SDK, merge its Auto Backup rules so the device id and the saved opt-out stay on the device rather than following the player's cloud backup to a new phone.

PrivacyInfo.xcprivacy, the Ravensight entries

```
<key>NSPrivacyTracking</key>
<false/>
<key>NSPrivacyCollectedDataTypes</key>
<array>
  <dict>
    <key>NSPrivacyCollectedDataType</key>
    <string>NSPrivacyCollectedDataTypeDeviceID</string>
    <key>NSPrivacyCollectedDataTypeLinked</key>
    <false/>
    <key>NSPrivacyCollectedDataTypeTracking</key>
    <false/>
    <key>NSPrivacyCollectedDataTypePurposes</key>
    <array>
      <string>NSPrivacyCollectedDataTypePurposeAnalytics</string>
    </array>
  </dict>
  <dict>
    <key>NSPrivacyCollectedDataType</key>
    <string>NSPrivacyCollectedDataTypeProductInteraction</string>
    <key>NSPrivacyCollectedDataTypeLinked</key>
    <false/>
    <key>NSPrivacyCollectedDataTypeTracking</key>
    <false/>
    <key>NSPrivacyCollectedDataTypePurposes</key>
    <array>
      <string>NSPrivacyCollectedDataTypePurposeAnalytics</string>
    </array>
  </dict>
  <!-- With the country and device fields on -->
  <dict>
    <key>NSPrivacyCollectedDataType</key>
    <string>NSPrivacyCollectedDataTypeCoarseLocation</string>
    <key>NSPrivacyCollectedDataTypeLinked</key>
    <false/>
    <key>NSPrivacyCollectedDataTypeTracking</key>
    <false/>
    <key>NSPrivacyCollectedDataTypePurposes</key>
    <array>
      <string>NSPrivacyCollectedDataTypePurposeAnalytics</string>
    </array>
  </dict>
  <dict>
    <key>NSPrivacyCollectedDataType</key>
    <string>NSPrivacyCollectedDataTypeOtherDiagnosticData</string>
    <key>NSPrivacyCollectedDataTypeLinked</key>
    <false/>
    <key>NSPrivacyCollectedDataTypeTracking</key>
    <false/>
    <key>NSPrivacyCollectedDataTypePurposes</key>
    <array>
      <string>NSPrivacyCollectedDataTypePurposeAnalytics</string>
    </array>
  </dict>
</array>
```

**What our sub-processors see**, so your "shared with third parties" answer is honest. The event stream is stored with our cloud, event database and operational database providers, who process it only to run Ravensight for you. When you use the AI analyst, the model provider receives the text a player typed into feedback and the rows and totals the analyst's tools queried, under contract; it never receives a player's report image. The embedding provider receives feedback text so you can search it. A product analytics service runs in the dashboard and on this website, never inside a game. Nothing reaches an ad network or a data broker, and nothing is sold. Both stores treat a service provider acting on your instructions as your own processing rather than sharing, which is why "not shared" is the correct answer. The [privacy policy](https://ravensight.io/privacy/) names every provider.

Ravensight itself is the processor here, not the controller. What ends up in an event payload is entirely what you chose to put there, so if you send something personal, disclose it.

## What your privacy label can say

These are the answers for a game that uses Ravensight and nothing else that collects data. Each row says why, against the store's own definition, so you can defend it in review. Apple's rule for "not linked": direct identifiers are stripped before collection and you never try to link the data back to a person afterwards. Ravensight never collects a direct identifier in the first place, and there is no account to link to.

App Store privacy details

| Data type | Answer | Why |
| --- | --- | --- |
| Identifiers: Device ID | Collected. Analytics. Data Not Linked to You. Data Not Used to Track You. | A random per-install id that is never joined to a name, email or account, and never combined with another company's data, so it meets neither the "linked" test nor the tracking definition. |
| Usage Data: Product Interaction | Collected. Analytics. Data Not Linked to You. Data Not Used to Track You. | Event names, levels and session timing from your own game only, stored against the same unlinked id and used for nothing but your dashboard. |
| Diagnostics: Crash Data | Only if you send crash events. Same answers as above. | Ravensight has no crash reporter; a crash you report as an event is Product Interaction unless it carries a stack trace, in which case declare Crash Data too. |
| User Content: Other User Content | Only if you enable player feedback or Player Reports. Analytics. Not Linked. Not Used to Track. | Free text a player types and any image they attach are stored under the device id until you delete them; disclose what your players can type. |
| Contact Info, Location, Financial Info, Health, Browsing History, Search History, Purchases | Not collected. | The SDK has no field for any of these, and the privacy policy commits that it never will. |

Google Play Data safety

| Question or data type | Answer | Why |
| --- | --- | --- |
| Device or other IDs | Collected. Not shared. Analytics. Not used for advertising or marketing. | The random per-install id above; it leaves your game only for Ravensight's own storage, which Play treats as your processing, not sharing. |
| App activity: App interactions | Collected. Not shared. Analytics. | Your gameplay events, under the same id, used only for your dashboard. |
| App info and performance: Crash logs | Only if you send crash events. | Ravensight has no crash reporter of its own. |
| Messages or other user-generated content | Only if you enable player feedback or Player Reports. | Text a player types is stored until you delete it and reaches the model provider for analysis under contract. |
| Is the data encrypted in transit? | Yes. | Every SDK talks to Ravensight over HTTPS only. |
| Is there a way to request deletion? | Yes. | The SDK's reset call (see the table under Mobile privacy) severs the player from their history and the old rows expire under the game's selected raw-event retention (90 days by default, optionally 180 or 400); deleting the game removes its stored gameplay data. |
| Is collection required or optional? | Optional if you wire the SDK's opt-out call (see the table under Mobile privacy) to a setting, otherwise required. | The switch sends nothing while off, and every SDK except JavaScript saves it; Ravensight ships no consent screen, so this one is your call. |

For a game that runs no ads, the one sentence this lets you put on your store page, and mean it: **"No ads, no tracking, no account needed."** If you later add an ad network, an attribution SDK or a sign-in, revisit every row above, because the first two are exactly what the tracking definition is about.

A public demo that asks before it sends keeps the player's opt-in choice on the player's own device, in the game's save folder or the browser's storage, so clearing it asks again. A random device id is still an identifier: it is not linked to a person, but it is collected, so declare it as the rows above do.

## SDK repositories

| SDK | Status | Repository |
| --- | --- | --- |
| Godot | Stable | [ravensight-godot](https://github.com/Reality-Software-Entertainment/ravensight-godot) |
| JavaScript | Stable | [ravensight-js](https://github.com/Reality-Software-Entertainment/ravensight-js), [ravensight on npm](https://www.npmjs.com/package/ravensight) |
| Unity | Beta: verified in the Unity 6 Editor and a macOS player | [ravensight-unity](https://github.com/Reality-Software-Entertainment/ravensight-unity) |
| Unreal | Beta: compiled and spec tested on Unreal Engine 5.8.3 | [ravensight-unreal](https://github.com/Reality-Software-Entertainment/ravensight-unreal) |
| C++ | Beta | [ravensight-cpp](https://github.com/Reality-Software-Entertainment/ravensight-cpp) |
| Odin | Beta | [ravensight-odin](https://github.com/Reality-Software-Entertainment/ravensight-odin) |
| LÖVE | Desktop, web through the JavaScript SDK | [ravensight-love](https://github.com/Reality-Software-Entertainment/ravensight-love) |
| iOS | Beta | [ravensight-ios](https://github.com/Reality-Software-Entertainment/ravensight-ios) |
| Android | Beta | [ravensight-android](https://github.com/Reality-Software-Entertainment/ravensight-android) |

Beta means the SDK meets the same contract as the others and its own tests pass, but no released game has shipped with it yet; it becomes Stable when one does.

Every SDK implements the common ingest protocol, and its batching and retry logic is tested with a fake network rather than the live API. For the 0.2.0 releases these suites were run: the Godot behaviour tests, headless on macOS and in CI; the Unity SDK's engine-free core tests in CI and, for 0.2.1, its 58 EditMode and 4 Play Mode tests in the Unity 6000.6.5f1 Editor, plus a macOS player run end to end; the Unreal plugin for 0.2.1, built on Unreal Engine 5.8.3 with warnings treated as errors, its 78 automation specs run headless in the editor, and the Mac editor and game targets built, though no packaged game has run yet; the C++ and Odin suites on macOS; the Swift package's tests on macOS and the iOS Simulator; the Android SDK's JVM and Robolectric tests; and the LÖVE SDK's suite (`luajit spec/run.lua`). Each SDK's README names the commands and toolchain versions. If your engine is not here, the [HTTP API](https://ravensight.io/docs/http-api/) is three headers and a JSON body.

Current SDK versions are Godot 0.5.0, JavaScript 0.7.0, LÖVE 0.7.0, Unity 0.5.0, Unreal 0.5.0, C++ 0.5.0, Odin 0.6.0, iOS 0.6.0 and Android 0.5.0. They include typed event helpers, opt-in performance sampling, remote config and experiment exposure, and from these versions every one keeps a saved queue across launches, compresses large requests (C++ when built with zlib, Odin on macOS and Linux), signs requests on a public key, and sends ad and attribution events. JavaScript 0.7.0, Doctor 0.5.1 and skills 0.2.2 are available from npm. Native SDKs are available from their linked repositories and version tags. The engine results above describe earlier versions. Each repository's validation notes record the current checks and remaining platform limits.

Source: https://ravensight.io/docs/platform-support/
Last updated: 2026-11-15
