BindableCore - A Clean, Type-Safe BindableEvent/BindableFunction Library

[Release] BindableCore - A Clean, Type-Safe BindableEvent/BindableFunction Library

:link: Module: BindableCore
:scroll: License: MIT

:rocket: Why BindableCore?

A lightweight, high-performance solution for managing BindableEvent/BindableFunction instances without the boilerplate. Designed for developers who like to work code-based and value:

:zap: Optimized Performance

  • Automatic instance caching – Eliminates redundant Instance.new() calls, reducing memory overhead.
  • Event pooling – Reuses existing Bindables instead of creating new ones.

:shield: Type-Safe & Debug-Friendly

  • Luau type checking – Catches mismatched events/functions at edit-time with strict annotations.
  • Clear warnings – Detailed error messages for invalid usage (e.g., firing a BindableFunction as an event).

:package: Zero-Dependency & Lightweight

  • Under 100 lines – Minimal footprint, no external bloat.
  • Works everywhere – Compatible with both client and server scripts.

:electric_plug: Structured Event Handling

  • Active listener tracking – Avoids firing events with no receivers.

:open_book: Usage Examples

:one: BindableEvent (Fire/Listen)

-- SENDER
BindableCore:Fire("PlayerHit", { player = "Player1", damage = 50 })

-- RECEIVER 
BindableCore:ListenToEvent("PlayerHit"):Connect(function(data) 
    print(data.player, "took", data.damage, "damage!") 
end)

:two: BindableFunction (Invoke/Respond)

-- REQUESTER
local result = BindableCore:Invoke("GetPlayerLevel", "Player1")
print("Player level:", result)

-- HANDLER
BindableCore:ListenToFunction("GetPlayerLevel", function(playerName)
    return game.Players[playerName].Level.Value
end)

:gear: Features

:sparkles: Event Caching – Reuses instances to avoid memory leaks.
:sparkles: Debug-Friendly – Warns on compatibility issues (e.g., using BindableFunction as BindableEvent).
:sparkles: Cross-Side Safety – Prevents accidental client/server overlaps with prefixes.


:package: Installation

  1. Paste the ModuleScript into ReplicatedStorage.
  2. Require it in any script:
local BindableCore = require(path.to.BindableCore)

:bulb: Ideal For

:heavy_check_mark: Game-wide events (e.g., UI updates, gameplay triggers).
:heavy_check_mark: Safe inter-script communication without RemoteEvents.
:heavy_check_mark: Structured codebases using Luau types.


:link: Resources


:speech_balloon: Feedback Welcome!

Questions? Suggestions? Let me know below!


:tada: Credits

Developed with :heart: by @AexesDev. Licensed under MIT.

3 Likes

Hello, might provide problems that your module tries to solve, I just can’t find the reason to use it

Using this module will create a more clean & efficient workflow in my opinion!

You don’t have to manually create BindableEvents/BindableFunctions. Which results in a cleaner explorer.

Also clients can’t access the Bindables with exploits as they are stored in memory!

They still can. The point is, why wouldn’t I just pre-create bindables in Studio over doing it in my code?

If you want to manage everything that is not scripted sure. this provides a way to reuse your code without needing to store bindable events in your hierachy. it simplifies the process and speeds up your workflow. by giving you easily created bindables.

Not sure having module scripts with these bindables is more convenient than just having a folder somewhere in server scripts, but alright.

It’s your own preference I guess :man_shrugging:

I like doing things code-based

please just use defaul signal library from roblox, here nothing better