System

Functions and messages for using system resources, controlling the engine, error handling and debugging.

sys.save(filename, table)

saves a lua table to a file stored on disk

The table can later be loaded by sys.load. Use sys.get_save_file to obtain a valid location for the file. Internally, this function uses a workspace buffer sized output file sized 512kb. This size reflects the output file size which must not exceed this limit. Additionally, the total number of rows that any one table may contain is limited to 65536 (i.e. a 16 bit range). When tables are used to represent arrays, the values of keys are permitted to fall within a 32 bit range, supporting sparse arrays, however the limit on the total number of rows remains in effect.

PARAMETERS

filename - file to write to

table - lua table to save

RETURN

success - a boolean indicating if the table could be saved or not

EXAMPLES

Save data:

local my_table = {}
table.insert(my_table, "my_value")
local my_file_path = sys.get_save_file("my_game", "my_file")
if not sys.save(my_file_path, my_table) then
  -- Alert user that the data could not be saved
end


sys.load(filename)

loads a lua table from a file on disk

If the file exists, it must have been created by sys.save to be loaded.

PARAMETERS

filename - file to read from

RETURN

loaded - lua table, which is empty if the file could not be found

EXAMPLES

Load data that was previously saved, e.g. an earlier game session:

local my_file_path = sys.get_save_file("my_game", "my_file")
local my_table = sys.load(my_file_path)
if not next(my_table) then
  -- empty table
end


sys.exists(path)

check if a path exists

Check if a path exists Good for checking if a file exists before loading a large file

PARAMETERS

path - path to check

RETURN

result - true if the path exists, false otherwise

EXAMPLES

Load data but return nil if path didn't exist

if not sys.exists(path) then
    return nil
end
return sys.load(path) -- returns {} if it failed


sys.get_host_path(filename)

create a path to the host device for unit testing

Create a path to the host device for unit testing Useful for saving logs etc during development

PARAMETERS

filename - file to read from

RETURN

host_path - the path prefixed with the proper host mount

EXAMPLES

Save data on the host

local host_path = sys.get_host_path("logs/test.txt")
sys.save(host_path, mytable)
Load data from the host
local host_path = sys.get_host_path("logs/test.txt")
local table = sys.load(host_path)


sys.get_save_file(application_id, file_name)

gets the save-file path

The save-file path is operating system specific and is typically located under the user's home directory.

PARAMETERS

application_id - user defined id of the application, which helps define the location of the save-file

file_name - file-name to get path for

RETURN

path - path to save-file

EXAMPLES

Find a path where we can store data (the example path is on the macOS platform):

local my_file_path = sys.get_save_file("my_game", "my_file")
print(my_file_path) --> /Users/my_users/Library/Application Support/my_game/my_file


sys.get_application_path()

gets the application path

The path from which the application is run.

RETURN

path - path to application executable

EXAMPLES

Find a path where we can store data (the example path is on the macOS platform):

-- macOS: /Applications/my_game.app
local application_path = sys.get_application_path()
print(application_path) --> /Applications/my_game.app

-- Windows: C:\Program Files\my_game\my_game.exe
print(application_path) --> C:\Program Files\my_game

-- Linux: /home/foobar/my_game/my_game
print(application_path) --> /home/foobar/my_game

-- Android package name: com.foobar.my_game
print(application_path) --> /data/user/0/com.foobar.my_game

-- iOS: my_game.app
print(application_path) --> /var/containers/Bundle/Applications/123456AB-78CD-90DE-12345678ABCD/my_game.app

-- HTML5: http://www.foobar.com/my_game/
print(application_path) --> http://www.foobar.com/my_game


sys.get_config_string(key, [default_value])

get string config value with optional default value

Get string config value from the game.project configuration file with optional default value

PARAMETERS

key - key to get value for. The syntax is SECTION.KEY

[default_value] - (optional) default value to return if the value does not exist

RETURN

value - config value as a string. default_value if the config key does not exist. nil if no default value was supplied.

EXAMPLES

Get user config value

local text = sys.get_config_string("my_game.text", "default text"))
Start the engine with a bootstrap config override and add a custom config value
$ dmengine --config=bootstrap.main_collection=/mytest.collectionc --config=mygame.testmode=1
Read the custom config value from the command line
local testmode = sys.get_config_int("mygame.testmode")


sys.get_config_int(key, [default_value])

get integer config value with optional default value

Get integer config value from the game.project configuration file with optional default value

PARAMETERS

key - key to get value for. The syntax is SECTION.KEY

[default_value] - (optional) default value to return if the value does not exist

RETURN

value - config value as an integer. default_value if the config key does not exist. 0 if no default value was supplied.

EXAMPLES

Get user config value

local speed = sys.get_config_int("my_game.speed", 20) -- with default value
local testmode = sys.get_config_int("my_game.testmode") -- without default value
if testmode ~= nil then
    -- do stuff
end


sys.get_config_number(key, [default_value])

get number config value with optional default value

Get number config value from the game.project configuration file with optional default value

PARAMETERS

key - key to get value for. The syntax is SECTION.KEY

[default_value] - (optional) default value to return if the value does not exist

RETURN

value - config value as an number. default_value if the config key does not exist. 0 if no default value was supplied.

EXAMPLES

Get user config value

local speed = sys.get_config_number("my_game.speed", 20.0)


sys.open_url(url, [attributes])

open url in default application

Open URL in default application, typically a browser

PARAMETERS

url - url to open

[attributes] - table with attributes target - string : Optional. Specifies the target attribute or the name of the window. The following values are supported: - _self - (default value) URL replaces the current page. - _blank - URL is loaded into a new window, or tab. - _parent - URL is loaded into the parent frame. - _top - URL replaces any framesets that may be loaded. - name - The name of the window (Note: the name does not specify the title of the new window).

RETURN

success - a boolean indicating if the url could be opened or not

EXAMPLES

Open an URL:

local success = sys.open_url("http://www.defold.com", {target = "_blank"})
if not success then
  -- could not open the url...
end


sys.load_resource(filename)

loads resource from game data

Loads a custom resource. Specify the full filename of the resource that you want to load. When loaded, the file data is returned as a string. If loading fails, the function returns nil plus the error message. In order for the engine to include custom resources in the build process, you need to specify them in the "custom_resources" key in your "game.project" settings file. You can specify single resource files or directories. If a directory is included in the resource list, all files and directories in that directory is recursively included: For example "main/data/,assets/level_data.json".

PARAMETERS

filename - resource to load, full path

RETURN

data - loaded data, or nil if the resource could not be loaded

error - the error message, or nil if no error occurred

EXAMPLES

-- Load level data into a string
local data, error = sys.load_resource("/assets/level_data.json")
-- Decode json string to a Lua table
if data then
  local data_table = json.decode(data)
  pprint(data_table)
else
  print(error)
end


sys.get_sys_info([options])

get system information

Returns a table with system information.

PARAMETERS

[options] - optional options table - ignore_secure boolean this flag ignores values might be secured by OS e.g. device_ident

RETURN

sys_info - table with system information in the following fields:

device_model
string Only available on iOS and Android.
manufacturer
string Only available on iOS and Android.
system_name
string The system name: "Darwin", "Linux", "Windows", "HTML5", "Android" or "iPhone OS"
system_version
string The system OS version.
api_version
string The API version on the system.
language
string Two character ISO-639 format, i.e. "en".
device_language
string Two character ISO-639 format (i.e. "sr") and, if applicable, followed by a dash (-) and an ISO 15924 script code (i.e. "sr-Cyrl" or "sr-Latn"). Reflects the device preferred language.
territory
string Two character ISO-3166 format, i.e. "US".
gmt_offset
number The current offset from GMT (Greenwich Mean Time), in minutes.
device_ident
string This value secured by OS. "identifierForVendor" on iOS. "android_id" on Android. On Android, you need to add READ_PHONE_STATE permission to be able to get this data. We don't use this permission in Defold.
user_agent
string The HTTP user agent, i.e. "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/602.4.8 (KHTML, like Gecko) Version/10.0.3 Safari/602.4.8"

EXAMPLES

How to get system information:

local info = sys.get_sys_info()
if info.system_name == "HTML5" then
  -- We are running in a browser.
end


sys.get_engine_info()

get engine information

Returns a table with engine information.

RETURN

engine_info - table with engine information in the following fields:

version
string The current Defold engine version, i.e. "1.2.96"
version_sha1
string The SHA1 for the current engine build, i.e. "0060183cce2e29dbd09c85ece83cbb72068ee050"
is_debug
boolean If the engine is a debug or release version

EXAMPLES

How to retrieve engine information:

-- Update version text label so our testers know what version we're running
local engine_info = sys.get_engine_info()
local version_str = "Defold " .. engine_info.version .. "\n" .. engine_info.version_sha1
gui.set_text(gui.get_node("version"), version_str)


sys.get_application_info(app_string)

get application information

Returns a table with application information for the requested app. On iOS, the app_string is an url scheme for the app that is queried. Your game needs to list the schemes that are queried in an LSApplicationQueriesSchemes array in a custom "Info.plist". On Android, the app_string is the package identifier for the app.

PARAMETERS

app_string - platform specific string with application package or query, see above for details.

RETURN

app_info - table with application information in the following fields:

installed
boolean true if the application is installed, false otherwise.

EXAMPLES

Check if twitter is installed:

sysinfo = sys.get_sys_info()
twitter = {}

if sysinfo.system_name == "Android" then
  twitter = sys.get_application_info("com.twitter.android")
elseif sysinfo.system_name == "iPhone OS" then
  twitter = sys.get_application_info("twitter:")
end

if twitter.installed then
  -- twitter is installed!
end
Info.plist for the iOS app needs to list the schemes that are queried:
...
<key>LSApplicationQueriesSchemes</key>
 <array>
   <string>twitter</string>
 </array>
...


sys.get_ifaddrs()

enumerate network interfaces

Returns an array of tables with information on network interfaces.

RETURN

ifaddrs - an array of tables. Each table entry contain the following fields:

name
string Interface name
address
string IP address. might be nil if not available.
mac
string Hardware MAC address. might be nil if not available.
up
boolean true if the interface is up (available to transmit and receive data), false otherwise.
running
boolean true if the interface is running, false otherwise.

EXAMPLES

How to get the IP address of interface "en0":

ifaddrs = sys.get_ifaddrs()
for _,interface in ipairs(ifaddrs) do
  if interface.name == "en0" then
    local ip = interface.address
  end
end


sys.set_error_handler(error_handler)

set the error handler

Set the Lua error handler function. The error handler is a function which is called whenever a lua runtime error occurs.

PARAMETERS

error_handler - the function to be called on error

source
string The runtime context of the error. Currently, this is always "lua".
message
string The source file, line number and error message.
traceback
string The stack traceback.

EXAMPLES

Install error handler that just prints the errors

local function my_error_handler(source, message, traceback)
  print(source)    --> lua
  print(message)   --> main/my.script:10: attempt to perform arithmetic on a string value
  print(traceback) --> stack traceback:
                   -->         main/test.script:10: in function 'boom'
                   -->         main/test.script:15: in function <main/my.script:13>
end

local function boom()
  return 10 + "string"
end

function init(self)
  sys.set_error_handler(my_error_handler)
  boom()
end


sys.set_connectivity_host(host)

set host to check for network connectivity against

Sets the host that is used to check for network connectivity against.

PARAMETERS

host - hostname to check against

EXAMPLES

sys.set_connectivity_host("www.google.com")


sys.get_connectivity()

get current network connectivity status

Returns the current network connectivity status on mobile platforms. On desktop, this function always return sys.NETWORK_CONNECTED.

RETURN

status - network connectivity status:

EXAMPLES

Check if we are connected through a cellular connection

if (sys.NETWORK_CONNECTED_CELLULAR == sys.get_connectivity()) then
  print("Connected via cellular, avoid downloading big files!")
end


sys.exit(code)

exits application

Terminates the game application and reports the specified code to the OS.

PARAMETERS

code - exit code to report to the OS, 0 means clean exit

EXAMPLES

This examples demonstrates how to exit the application when some kind of quit messages is received (maybe from gui or similar):

function on_message(self, message_id, message, sender)
    if message_id == hash("quit") then
        sys.exit(0)
    end
end


sys.reboot(arg1, arg2, arg3, arg4, arg5, arg6)

reboot engine with arguments

Reboots the game engine with a specified set of arguments. Arguments will be translated into command line arguments. Calling reboot function is equivalent to starting the engine with the same arguments. On startup the engine reads configuration from "game.project" in the project root.

PARAMETERS

arg1 - argument 1

arg2 - argument 2

arg3 - argument 3

arg4 - argument 4

arg5 - argument 5

arg6 - argument 6

EXAMPLES

How to reboot engine with a specific bootstrap collection.

local arg1 = '--config=bootstrap.main_collection=/my.collectionc'
local arg2 = 'build/game.projectc'
sys.reboot(arg1, arg2)


sys.set_vsync_swap_interval(swap_interval)

set vsync swap interval

Set the vsync swap interval. The interval with which to swap the front and back buffers in sync with vertical blanks (v-blank), the hardware event where the screen image is updated with data from the front buffer. A value of 1 swaps the buffers at every v-blank, a value of 2 swaps the buffers every other v-blank and so on. A value of 0 disables waiting for v-blank before swapping the buffers. Default value is 1. When setting the swap interval to 0 and having vsync disabled in "game.project", the engine will try to respect the set frame cap value from "game.project" in software instead. This setting may be overridden by driver settings.

PARAMETERS

swap_interval - target swap interval.

EXAMPLES

Setting the swap intervall to swap every v-blank

sys.set_vsync_swap_interval(1)


sys.set_update_frequency(frequency)

set update frequency

Set game update-frequency (frame cap). This option is equivalent to display.update_frequency in the "game.project" settings but set in run-time. If Vsync checked in "game.project", the rate will be clamped to a swap interval that matches any detected main monitor refresh rate. If Vsync is unchecked the engine will try to respect the rate in software using timers. There is no guarantee that the frame cap will be achieved depending on platform specifics and hardware settings.

PARAMETERS

frequency - target frequency. 60 for 60 fps

EXAMPLES

Setting the update frequency to 60 frames per second

sys.set_update_frequency(60)


sys.serialize(table)

serializes a lua table to a buffer and returns it

The buffer can later deserialized by sys.deserialize. This method has all the same limitations as sys.save.

PARAMETERS

table - lua table to serialize

RETURN

buffer - serialized data buffer

EXAMPLES

Serialize table:

local my_table = {}
table.insert(my_table, "my_value")
local buffer = sys.serialize(my_table)


sys.deserialize(buffer)

deserializes buffer into a lua table

deserializes buffer into a lua table

PARAMETERS

buffer - buffer to deserialize from

RETURN

table - lua table with deserialized data

EXAMPLES

Deserialize a lua table that was previously serialized:

local buffer = sys.serialize(my_table)
local table = sys.deserialize(buffer)


sys.NETWORK_DISCONNECTED

no network connection found

no network connection found


sys.NETWORK_CONNECTED_CELLULAR

network connected through mobile cellular

network connected through mobile cellular


sys.NETWORK_CONNECTED

network connected through other, non cellular, connection

network connected through other, non cellular, connection


exit

exits application

Terminates the game application and reports the specified code to the OS. This message can only be sent to the designated @system socket.

PARAMETERS

code - exit code to report to the OS, 0 means clean exit

EXAMPLES

This examples demonstrates how to exit the application when some kind of quit messages is received (maybe from gui or similar):

function on_message(self, message_id, message, sender)
    if message_id == hash("quit") then
        msg.post("@system:", "exit", {code = 0})
    end
end


toggle_profile

shows/hides the on-screen profiler

Toggles the on-screen profiler. The profiler is a real-time tool that shows the numbers of milliseconds spent in each scope per frame as well as counters. The profiler is very useful for tracking down performance and resource problems. In addition to the on-screen profiler, Defold includes a web-based profiler that allows you to sample a series of data points and then analyze them in detail. The web profiler is available at http://<device IP>:8002 where is the IP address of the device you are running your game on. This message can only be sent to the designated @system socket.

EXAMPLES

msg.post("@system:", "toggle_profile")


toggle_physics_debug

shows/hides the on-screen physics visual debugging

Toggles the on-screen physics visual debugging mode which is very useful for tracking down issues related to physics. This mode visualizes all collision object shapes and normals at detected contact points. Toggling this mode on is equal to setting physics.debug in the "game.project" settings, but set in run-time. This message can only be sent to the designated @system socket.

EXAMPLES

msg.post("@system:", "toggle_physics_debug")


start_record

starts video recording

Starts video recording of the game frame-buffer to file. Current video format is the open vp8 codec in the ivf container. It's possible to upload this format directly to YouTube. The VLC video player has native support but with the known issue that not the entire file is played back. It's probably an issue with VLC. The Miro Video Converter has support for vp8/ivf. Video recording is only supported on desktop platforms. Audio is currently not supported Window width and height must be a multiple of 8 to be able to record video. This message can only be sent to the designated @system socket.

PARAMETERS

file_name - file name to write the video to

frame_period - frame period to record, ie write every nth frame. Default value is 2

fps - frames per second. Playback speed for the video. Default value is 30. The fps value doens't affect the recording. It's only meta-data in the written video file.

EXAMPLES

Record a video in 30 fps given that the native game fps is 60:

msg.post("@system:", "start_record", { file_name = "test_rec.ivf" } )
To write a video in 60 fps given that the native game fps is 60:
msg.post("@system:", "start_record", { file_name = "test_rec.ivf", frame_period = 1, fps = 60 } )


stop_record

stop current video recording

Stops the currently active video recording. Video recording is only supported on desktop platforms. This message can only be sent to the designated @system socket.

EXAMPLES

msg.post("@system:", "stop_record")


reboot

reboot engine with arguments

Reboots the game engine with a specified set of arguments. Arguments will be translated into command line arguments. Sending the reboot command is equivalent to starting the engine with the same arguments. On startup the engine reads configuration from "game.project" in the project root. This message can only be sent to the designated @system socket.

PARAMETERS

arg1 - argument 1

arg2 - argument 2

arg3 - argument 3

arg4 - argument 4

arg5 - argument 5

arg6 - argument 6

EXAMPLES

How to reboot engine with a specific bootstrap collection.

local arg1 = '--config=bootstrap.main_collection=/my.collectionc'
local arg2 = 'build/game.projectc'
msg.post("@system:", "reboot", {arg1 = arg1, arg2 = arg2})


set_vsync

set vsync swap interval

Set the vsync swap interval. The interval with which to swap the front and back buffers in sync with vertical blanks (v-blank), the hardware event where the screen image is updated with data from the front buffer. A value of 1 swaps the buffers at every v-blank, a value of 2 swaps the buffers every other v-blank and so on. A value of 0 disables waiting for v-blank before swapping the buffers. Default value is 1. When setting the swap interval to 0 and having vsync disabled in "game.project", the engine will try to respect the set frame cap value from "game.project" in software instead. This setting may be overridden by driver settings. This message can only be sent to the designated @system socket.

PARAMETERS

swap_interval - target swap interval.

EXAMPLES

msg.post("@system:", "set_vsync", { swap_interval = 1 } )


set_update_frequency

set update frequency

Set game update-frequency (frame cap). This option is equivalent to display.update_frequency in the "game.project" settings but set in run-time. If Vsync checked in "game.project", the rate will be clamped to a swap interval that matches any detected main monitor refresh rate. If Vsync is unchecked the engine will try to respect the rate in software using timers. There is no guarantee that the frame cap will be achieved depending on platform specifics and hardware settings. This message can only be sent to the designated @system socket.

PARAMETERS

frequency - target frequency. 60 for 60 fps

EXAMPLES

msg.post("@system:", "set_update_frequency", { frequency = 60 } )


sys.load_buffer(path)

loads a buffer from a resource or disk path

The sys.load_buffer function will first try to load the resource from any of the mounted resource locations and return the data if any matching entries found. If not, the path will be tried as is from the primary disk on the device. In order for the engine to include custom resources in the build process, you need to specify them in the "custom_resources" key in your "game.project" settings file. You can specify single resource files or directories. If a directory is included in the resource list, all files and directories in that directory is recursively included: For example "main/data/,assets/level_data.json".

PARAMETERS

path - the path to load the buffer from

RETURN

buffer - the buffer with data

EXAMPLES

Load binary data from a custom project resource:

local my_buffer = sys.load_buffer("/assets/my_level_data.bin")
local data_str = buffer.get_bytes(my_buffer, "data")
local has_my_header = string.sub(data_str,1,6) == "D3F0LD"
Load binary data from non-custom resource files on disk:
local asset_1 = sys.load_buffer("folder_next_to_binary/my_level_asset.txt")
local asset_2 = sys.load_buffer("/my/absolute/path")


sys.load_buffer_async(path, status_callback)

loads a buffer from a resource or disk path asynchronously

The sys.load_buffer function will first try to load the resource from any of the mounted resource locations and return the data if any matching entries found. If not, the path will be tried as is from the primary disk on the device. In order for the engine to include custom resources in the build process, you need to specify them in the "custom_resources" key in your "game.project" settings file. You can specify single resource files or directories. If a directory is included in the resource list, all files and directories in that directory is recursively included: For example "main/data/,assets/level_data.json". Note that issuing multiple requests of the same resource will yield individual buffers per request. There is no implic caching of the buffers based on request path.

PARAMETERS

path - the path to load the buffer from

status_callback - A status callback that will be invoked when a request has been handled, or an error occured. The result is a table containing:

status
number The status of the request, supported values are:
buffer
buffer If the request was successfull, this will contain the request payload in a buffer object, and nil otherwise. Make sure to check the status before doing anything with the buffer value!

RETURN

handle - a handle to the request

EXAMPLES

Load binary data from a custom project resource and update a texture resource:

function my_callback(self, request_id, result)
  if result.status == resource.REQUEST_STATUS_FINISHED then
     resource.set_texture("/my_texture", { ... }, result.buf)
  end
end

local my_request = sys.load_buffer_async("/assets/my_level_data.bin", my_callback)
Load binary data from non-custom resource files on disk:
function my_callback(self, request_id, result)
  if result.status ~= sys.REQUEST_STATUS_FINISHED then
    -- uh oh! File could not be found, do something graceful
  elseif request_id == self.first_asset then
    -- result.buffer contains data from my_level_asset.bin
  elif request_id == self.second_asset then
    -- result.buffer contains data from 'my_level.bin'
  end
end

function init(self)
  self.first_asset = hash("folder_next_to_binary/my_level_asset.bin")
  self.second_asset = hash("/some_absolute_path/my_level.bin")
  self.first_request = sys.load_buffer_async(self.first_asset, my_callback)
  self.second_request = sys.load_buffer_async(self.second_asset, my_callback)
end


sys.REQUEST_STATUS_FINISHED

an asyncronous request has finished successfully

an asyncronous request has finished successfully


sys.REQUEST_STATUS_ERROR_IO_ERROR

an asyncronous request is unable to read the resource

an asyncronous request is unable to read the resource


sys.REQUEST_STATUS_ERROR_NOT_FOUND

an asyncronous request is unable to locate the resource

an asyncronous request is unable to locate the resource