Collapse Sidebar


Show deprecated


Show deprecated

An object that allows you to give access to functions to external scripts. Functions put in BindableFunctions will not be replicated, therefore making it impossible to use these objects to pass functions between scripts. Functions are invoked through BindableFunction/Invoke, which calls BindableFunction/OnInvoke.

BindableFunctions do not allow for communication between the server and client. If you are looking for this functionality use RemoteFunction|RemoteFunctions.

BindableEvents vs BindableFunctions

Unlike BindableFunctions, BindableEvent|BindableEvents only allow for one-way communication between two scripts:

  • When a script invokes a BindableFunction it yields until the event is handled and returned by the subscribed script synchronously. This allows for scripts to effectively pass data during and after an event.
  • When a script fires a BindableEvent, however, it does not yield for a return. The script continues executing as the event is handled by the subscribed script asynchronously.

BindableFunctions vs RemoteFunctions

While BindableFunctions allow for two-way communication server-server scripts or client-client LocalScript|LocalScripts, RemoteFunction|RemoteFunctions allow for two-way communicate the server and client. For more information on RemoteFunctions, read the Articles/Remote Functions and Events|Remote Functions and Events article.


### Subscription Only one function can be bound to `BindableFunction/Invoke` at a time. If you assign multiple functions, only the last one assigned will be used.

Parameter Limitations

Any type of Roblox object such as an Enumeration, Instance, or userdata can be passed as a parameter when a RemoteEvent is fired or a RemoteFunction invoked. Lua types such as numbers, strings, and booleans can also be passed, although there are some limitations on how data can be passed.

Table Identity

Copies of tables are produced when passed as arguments to or returned from the OnInvoke callback. This means that means that tables passed as arguments will not be exactly equivalent to those provided on invocation, and tables returned to the invoker will not be exactly equivalent to the ones returned by the OnInvoke callback. You can demonstrate this by running the following script in a BindableFunction:

local bindableFunction = script.Parent

bindableFunction.OnInvoke = function (t)
	print("OnInvoke", tostring(t), t)
	t = {bar = "foo"}
	print("OnInvoke2", tostring(t), t)
	return t

local t = {foo = "bar"}
print("Subscriber", tostring(t), t)
local retVal = script.Parent:Invoke(t)
print("return", tostring(retVal), retVal)

The above code may produce the following results in the output. Notice how the memory addresses of every table printed are completely different from each other, indicating they each represent different tables:

  13:55:22.228  Subscriber table: 0xc7daaba4d5307f10  ▶ {...} - Publisher:11
  13:55:22.229  OnInvoke table: 0x2ee92a7818e7d210  ▶ {...} - Publisher:4
  13:55:22.229  OnInvoke2 table: 0xfa4ee529ddadf290  ▶ {...} - Publisher:6
  13:55:22.229  return table: 0x35b7bc1bc323d510  ▶ {...} - Publisher:13

Mixed Tables

Avoid passing a mixed table (some values indexed by number and others by key), as only the data indexed by number will be passed. For example, when the server receives the colorData table illustrated below, it will only see indices 1 and 2 containing "Blue" and "Yellow" while the other data will be lost in the transfer. Note, however, that sub-tables do not need to be indexed in the same way as their parent — in other words, as long as each individual sub-table is indexed with the same type, all of the data will be preserved.

Non-String Indices

If any indices of a passed table are non-string type (Instance, userdata, function, another table, etc.), those indices will be converted to a string.

-- Mixed table
local colorData = {}
colorData[1] = "Blue"
colorData[2] = "Yellow"
colorData["Color1"] = "Green"
colorData["Color2"] = "Red"

-- Table with two key-indexed sub-tables
local playerData = {}
playerData["CharData"] = {
	-- All children indexed by key
	CharName = "Diva Dragonslayer",
	CharClass = "Knight"
playerData["Inventory"] = {
	-- All children numerically indexed


Functions passed as parameters will not be replicated, therefore making it impossible to use these objects to pass functions between scripts.


Inherited from Instance: Show Hide



Determines if an Instance can be cloned using /Instance/Clone or saved to file.



[ReadOnly] [NotReplicated]

A read-only string representing the class this Instance belongs to



[Hidden] [ReadOnly] [NotReplicated] [Deprecated]

The cost of saving the instance using data persistence.



A non-unique identifier of the Instance




Determines the hierarchical parent of the Instance




A deprecated property that used to protect CoreGui objects



[Hidden] [NotReplicated] [Deprecated]


[ReadOnly] [NotReplicated] [Deprecated]



Invoke ( Tuple arguments )


Calls the BindableFunction/OnInvoke callback of the BindableFunction, returning any values if there were any

Inherited from Instance: Show Hide


ClearAllChildren ( )

This function destroys all of an Instance’s children.


Clone ( )

Create a copy of an object and all its descendants, ignoring objects that are not Instance/Archivable|Archivable


Destroy ( )

Sets the Instance/Parent property to nil, locks the Instance/Parent property, disconnects all connections and calls Destroy on all children.


FindFirstAncestor ( string name )

Returns the first ancestor of the Instance whose Instance/Name is equal to the given name.


FindFirstAncestorOfClass ( string className )

Returns the first ancestor of the Instance whose Instance/ClassName is equal to the given className.


FindFirstAncestorWhichIsA ( string className )

Returns the first ancestor of the Instance for whom Instance/IsA returns true for the given className.


FindFirstChild ( string name , bool recursive )

Returns the first child of the Instance found with the given name.


FindFirstChildOfClass ( string className )

Returns the first child of the Instance whose Instance/ClassName|ClassName is equal to the given className.


FindFirstChildWhichIsA ( string className , bool recursive )

Returns the first child of the Instance for whom Instance/IsA returns true for the given className.


FindFirstDescendant ( string name )


GetActor ( )


GetAttribute ( string attribute )

Returns the attribute which has been assigned to the given name


GetAttributeChangedSignal ( string attribute )

Returns an event that fires when the given attribute changes


GetAttributes ( )

Returns a dictionary of string → variant pairs for each of the Instance|Instance’s attributes


GetChildren ( )

Returns an array containing all of the Instance’s children.


GetDebugId ( int scopeLength )


Returns a coded string of the Instances DebugId used internally by Roblox.


GetDescendants ( )


Returns an array containing all of the descendants of the instance


GetFullName ( )

Returns a string describing the Instance’s ancestry.


GetPropertyChangedSignal ( string property )

Get an event that fires when a given property of an object changes.


IsA ( string className )


Returns true if an Instance’s class matches or inherits from a given class


IsAncestorOf ( Instance descendant )

Returns true if an Instance is an ancestor of the given descendant.


IsDescendantOf ( Instance ancestor )

Returns true if an Instance is a descendant of the given ancestor.


Remove ( )


Sets the object’s Parent to nil, and does the same for all its descendants.


SetAttribute ( string attribute , Variant value )

Sets the attribute with the given name to the given value


WaitForChild ( string childName , double timeOut )

[CustomLuaState] [CanYield]

Returns the child of the Instance with the given name. If the child does not exist, it will yield the current thread until it does.


children ( )


Returns an array of the object’s children.


clone ( )


destroy ( )


findFirstChild ( string name , bool recursive )


getChildren ( )


isA ( string className )

[Deprecated] [CustomLuaState]

isDescendantOf ( Instance ancestor )


remove ( )



Inherited from Instance: Show Hide


AncestryChanged ( Instance child , Instance parent )

Fires when the Instance/Parent property of the object or one of its ancestors is changed.


AttributeChanged ( string attribute )

Fires whenever an attribute is changed on the Instance


Changed ( string property )

Fired immediately after a property of an object changes.


ChildAdded ( Instance child )

Fires when an object is parented to this Instance.


ChildRemoved ( Instance child )

Fires when a child is removed from this Instance.


DescendantAdded ( Instance descendant )

Fires when a descendant is added to the Instance


DescendantRemoving ( Instance descendant )

Fires immediately before a descendant of the Instance is removed.


childAdded ( Instance child )




OnInvoke ( Tuple arguments )

Callback for when the BindableEvent is invoked

Code Samples

BindableFunction Addition

This code sample sets the OnInvoke callback of the parent BindableFunction to a function that returns the sum of two numbers. Test this code sample by pasting this code inside a Script within a BindableFunction. You’ll then be able to use Invoke on the BindableFunction from other scripts.

local bf = script.Parent

-- Define a function for use with the BindableFunction
local function AddTwoNumbers(a, b)
	return a + b

-- Set the OnInvoke callback to be our function
bf.OnInvoke = AddTwoNumbers

-- Invoke the BindableFunction
print(bf:Invoke(25, 44))

BindableFunction Valid Values

This code sample shows the kinds of values that can be sent to and from BindableFunctions via Invoke/OnInvoke. Test this code by placing a Script within a BindableFunction inside the Workspace or ServerScriptService. It will raise errors on the values that cannot be sent.

local bf = script.Parent

-- Dummy function
bf.OnInvoke = function (...) return ... end

-- These values CAN be sent to/from BindableFunctions
bf:Invoke()           -- nil
bf:Invoke(25)         -- numbers
bf:Invoke("hello")    -- strings
bf:Invoke(true)       -- booleans
bf:Invoke("buy", 25)  -- multiple values are OK
bf:Invoke{1, 2, 3}    -- tables as arrays with no gaps
                      -- note the curly braces
bf:Invoke{            -- tables with string keys only
	hello = "world";
	goodbye = "world";
bf:Invoke{            -- tables with string keys
	point = {1, 2};   -- whose values are also valid
	point2 = {3, 4};
bf:Invoke{            -- tables as arrays
	{1, 2, 3};        -- whose values also are valid
	{hello = "world";};

-- These are some values you CANNOT send to/from BindableFunctions
bf:Invoke{1, nil, 3}  -- tables as arrays cannot have nil gaps
	[{}] = "hello";   -- table keys can only be numbers OR strings
bf:Invoke{            -- tables keys cannot be BOTH numbers AND strings  
	[1] = "apple";
	hello = "world";