Ravensight

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. A cell says Untested where no build of that SDK has been run on that platform yet.

Support matrix

SDKDesktopiOSAndroidWebConsole
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). 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). 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, used under CC 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.

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.
SDKOpt-outReset
GodotRavensight.set_tracking_enabled(false)Ravensight.reset_device_id()
JavaScriptrs.setEnabled(false), not savedawait rs.resetDeviceId()
LÖVEravensight.setTrackingEnabled(false)ravensight.resetDeviceId()
UnityRavensight.SetTrackingEnabled(false)Ravensight.ResetDeviceId()
UnrealSetTrackingEnabled(false) on the subsystemResetDeviceId()
C++client.set_tracking_enabled(false)client.reset_device_id()
Odinrs.set_tracking_enabled(client, false)rs.reset_device_id(client)
iOSRavensight.setTrackingEnabled(false)Ravensight.resetDeviceId()
AndroidRavensight.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 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 typeAnswerWhy
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 typeAnswerWhy
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

SDKStatusRepository
Godot Stable ravensight-godot
JavaScript Stable ravensight-js, ravensight on npm
Unity Beta: verified in the Unity 6 Editor and a macOS player ravensight-unity
Unreal Beta: compiled and spec tested on Unreal Engine 5.8.3 ravensight-unreal
C++ Beta ravensight-cpp
Odin Beta ravensight-odin
LÖVE Desktop, web through the JavaScript SDK ravensight-love
iOS Beta ravensight-ios
Android Beta 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 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.