HEXA FRAMEWORK

A modern RedM framework for building roleplay servers.

Fast. Modular. Developer-friendly.

Framework · Bridge · APIs · Developer Tools

Hexa Framework is a modular framework designed for building modern RedM roleplay servers.

The project focuses on providing a clean foundation for server development without forcing every system into a single massive resource.

hexa_core provides the essential server infrastructure, while additional Hexa resources can be added, removed, or replaced independently.

• Modular — use only the systems your server needs
• Developer-friendly — predictable APIs and project structure
• Performance-focused — avoid unnecessary client and server overhead
• Extensible — build custom resources directly on top of Hexa
• Interoperable — compatibility layers for existing RedM resources
• Documented — APIs and installation guides maintained alongside the framework

Every part of Hexa is its own repository. Install only what your server needs.

hexa_core is the foundation of the Hexa ecosystem.

It handles shared functionality that other resources can access through a consistent API.

Player Management
├── Player lifecycle
├── Character data
├── Metadata
└── Player state

Economy
├── Cash
├── Bank
└── Money transactions

Jobs
├── Job data
├── Grades
└── Job state

Inventory Integration
├── Items
├── Item metadata
└── Item operations

Server APIs
├── Callbacks
├── Events
├── Exports
└── Shared functions

Administration
├── Permissions
├── Groups
└── Command access

Get the Hexa core object from your resource:

local HexaCore = exports['hexa_core']:GetCoreObject()

Access a player:

local Player = HexaCore.Functions.GetPlayer(source)

if not Player then
    return
end

Add money:

Player.Functions.AddMoney(
    'cash',
    100,
    'welcome_bonus'
)

From here, your resource can interact with Hexa through the core API without duplicating player, economy, permission, or callback logic.

local HexaCore = exports['hexa_core']:GetCoreObject()

RegisterNetEvent('example:server:reward', function()
    local src = source

    local Player = HexaCore.Functions.GetPlayer(src)

    if not Player then
        return
    end

    Player.Functions.AddMoney(
        'cash',
        100,
        'example_reward'
    )
end)

Already have resources built for another RedM ecosystem?

hexa-bridge is designed to reduce migration work by providing compatibility APIs for supported resources.

Existing Resource
       │
       ▼
┌─────────────────┐
│   hexa-bridge   │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│    hexa_core    │
└─────────────────┘

The goal is simple:

Migrate your server progressively instead of rewriting everything at once.

Compatibility depends on the APIs used by each resource. Check the documentation for currently supported bridge functionality.

Hexa follows a modular architecture where hexa_core acts as the shared foundation.

                    ┌──────────────────┐
                    │    hexa_core     │
                    └────────┬─────────┘
                             │
          ┌──────────────────┼──────────────────┐
          │                  │                  │
          ▼                  ▼                  ▼
   ┌────────────┐     ┌────────────┐     ┌────────────┐
   │ Hexa Script │     │ Hexa Script │     │ Hexa Script │
   └────────────┘     └────────────┘     └────────────┘
          │
          ▼
   ┌─────────────┐
   │ hexa-bridge │
   └──────┬──────┘
          │
          ▼
   Existing RedM Resources

This keeps individual systems independent while sharing a common foundation.

Complete installation instructions, API references, examples, and development guides are available in the official documentation.

Documentation includes:

• Installation
• Configuration
• Core API
• Player API
• Money API
• Jobs
• Items
• Callbacks
• Permissions
• Events
• Exports
• Bridge compatibility
• Resource development examples

A typical Hexa-based server can be organized like this:

resources/
│
├── [hexa]/
│   ├── hexa_core/
│   ├── hexa_inventory/
│   ├── hexa_progbar/
│   ├── hexa-bridge/
│   └── ...
│
├── [standalone]/
│   └── ...
│
└── [maps]/
    └── ...

Each system remains its own resource instead of turning the core into a monolith.

A Hexa resource should communicate with the framework through documented APIs rather than directly accessing internal framework data.

local HexaCore = exports['hexa_core']:GetCoreObject()

This provides a stable entry point for:

HexaCore
├── Functions
├── Shared
├── Commands
├── Callbacks
└── Player APIs

Keeping resources behind public APIs makes them easier to maintain, update, and reuse.

Hexa Framework is under active development.

APIs, bridge compatibility, tooling, and documentation will continue to expand as the ecosystem grows.

For production servers, review release notes before updating core resources.