Roblox developer specialized in Scripting & UI Design.
I build polished, exploit-proof game systems — from advanced FPS and combat mechanics
to seamless inventory and building systems.
đŸŸĸ Available for freelance work.

Game Systems

Advanced FPS-System

Smooth movement, precise aiming mechanics, seamless animations, dynamic grenade throwing, and fluid melee combat.

Movement System

Directional animations, sprint, slide, physics-based roll, dynamic FOV/camera bobbing, and full parkour (vaulting, wall-run, wall-climb).

Katana Combat System

Server-authoritative melee with combo attacks, block/parry, and cinematic finishers. Isolated managers for exploit resistance.

Advanced Building System

Server-authorized placement validator, personal plot system, grid-placement, and reliable data-saving via custom raycasts.

Advanced Pet System

Exploit-proof hatching, full inventory system, rarity tiers, and an intuitive UI with toggleable grids and search bars.

Advanced Combat System

Precise hit detection, responsive dashes, built-in parry, impactful health/damage system with immersive VFX and SFX.

Core Architecture

Aethercore: Custom Services, Signals & States


            --!strict
            -- ==============================================================================
            -- AETHERCORE v2.0 - ENTERPRISE DEPENDENCY INJECTION & SIGNAL FRAMEWORK
            -- ==============================================================================
            -- Features: Custom Signals, Event Tracking, Topological Sort, Strict Typing, 
            -- RunService Hooks, State Management & Middleware
            -- ==============================================================================

            const RunService = game:GetService("RunService")

            local Aethercore = {}
            Aethercore.__index = Aethercore


            -- ==========================================
            -- 1. TYPE DEFINITIONS
            -- ==========================================

            export type Connection = {
              Disconnect: (self: Connection) -> (),
              Connected: boolean
            }

            export type Signal = {
              Name: string,
              
              Fire: (self: Signal, ... any) -> (),
              Connect: (self: Signal, listenerName: string, callback: (...any) -> ()) -> Connection,
              Wait: (self: Signal) -> (...any),
              Destroy: (self: Signal) -> (),
              GetListeners: (self: Signal) -> ({string})
            }

            export type ServiceOptions = {
              Name: string,
              Dependencies: {string}
            }

            export type Service = {
              Name: string,
              Dependencies: {string},
              
              -- Lifecycle Hooks
              OnInit: ((self: Service) -> ())?,
              OnStart: ((self: Service) -> ())?,
              OnUpdate: ((self: Service, deltaTime: number) -> ())?,
              OnPhysics: ((self: Service, deltaTime: number) -> ())?,
              
              -- Signals
              RegisterSignal: (self: Service, signalName: string) -> Signal,
              GetSignal: (self: Service, signalName: string) -> Signal,
              SetState: (self: Service, stateName: string, value: any) -> (),
              GetState: (self: Service, sStateName: string) -> any,
              ObserveState: (self: Service, key: string, callback: (...any) -> ()) -> Connection
            }

            -- ==========================================
            -- 2. PRIVATE INTERNAL CACHES
            -- ==========================================


            local services: { [string]: Service } = {}
            local isInitialized: boolean = false
            local hasStarted: boolean = false

            -- ==========================================
            -- 3. INTERNAL LOGGER MODULE
            -- ==========================================

            type LogMessagePrefix = "Info (ℹī¸)" | "Success (✅)" |"Warning (⚠ī¸)"| "Error (⛔)"

            local Logger = {}
            Logger.LoggedMessages = {}

            function Logger.Log(prefix: LogMessagePrefix, message: string, source: string?)
              local formattedMessage =
                if source then
                  `[AetherCore] {string.sub(message, -2)} "[{source}] {message}"`
                else
                  `[AetherCore] {string.sub(message, -2)} {message}"`
              table.insert(Logger.LoggedMessages, formattedMessage)
              
              if prefix == "Warning (⚠ī¸)" or prefix == "Error (⛔)" then
                warn(formattedMessage)
              else
                print(formattedMessage)
              end
            end

            -- ==========================================
            -- 4. FAST SIGNAL CLASS (Custom Event System)
            -- ==========================================

            local SignalClass = {}
            SignalClass.__index = SignalClass

            function SignalClass.new(name: string): Signal
              local self = setmetatable({
                Name = name,
                _connections = {},
                _threads = {},
                _listenerNames = {}
              }, SignalClass)
              
              return self :: any
            end

            function SignalClass:Fire(...)
              for callback, _ in self._connections:: {any} do
                task.spawn(callback, ...)
              end
              for _, thread in self._threads do
                task.spawn(thread, ...)
              end
              table.clear(self._threads)
            end

            function SignalClass:Connect(listenerName: string, callback: (...any) -> ())
              assert(typeof(callback) == "function", `[AetherCore] {self.Name}:Connect expects a function`)
              self._connections[callback] = true
              table.insert(self._listenerNames, listenerName)
              
              local connection = {
                Connected = true
              }
              
              local SignalInstance = self
              function connection:Disconnect()
                if not self.Connected then return end
                self.Connected = false
                SignalInstance._connections[callback] = nil
                local idx = table.find(SignalInstance._listenerNames, listenerName)
                if idx then
                  table.remove(SignalInstance._listenerNames, idx)
                end
              end
              
              return connection :: Connection
            end

            function SignalClass:Wait()
              table.insert(self._threads, coroutine.running())
              return coroutine.yield()
            end

            function SignalClass:Destroy()
              table.clear(self._connections)
              table.clear(self._listenerNames)
              table.clear(self._threads)
            end

            function SignalClass:GetListenerNames()
              return self._listenerNames
            end

            -- ==========================================
            -- 5. SERVICE PROXY & METATABLE PROTECTION
            -- ==========================================

            local function CreateServiceProxy(ServiceData: {any}): Service
              local proxy = setmetatable({}, {
                __index = ServiceData,
                __newindex = function(_, key, value)
                  if isInitialized and key ~= "_state" then
                    Logger.Log("Error (⛔)", `Cannot overwrite property: '{tostring(key)}' during session!`, ServiceData.Name)
                  else
                    ServiceData[key] = value
                  end
                end,
                __metatable = "Aethercore Protected Engine"
              })
              return proxy :: Service
            end

            -- ==========================================
            -- 6. PUBLIC API: SERVICE CREATION
            -- ==========================================

            function Aethercore.CreateService(options: ServiceOptions): Service
              if services[options.Name] then
                Logger.Log("Error (⛔)", `Service: '{options.Name}' already exists!`)
                error(`Service: '{options.Name}' already exists!`)
              end
              
              local serviceData = {
                Name = options.Name,
                Dependencies = options.Dependencies or {},
                _signal = {},
                _state = {},
                _stateSignals = {},
              }
              
              function serviceData:RegisterSignal(name: string)
                if self._signal[name] then
                  Logger.Log("Error (⛔)", `Signal: '{name} already exists'`)
                  error(`Signal: '{name} already exists'`)
                end
                local newSignal = SignalClass.new(`{self.Name}_{name}`)
                self._signal[name] = newSignal
                return newSignal
              end
              
              function serviceData:GetSignal(name: string)
                assert(self._signal[name], `Signal: '{name}' does not exist`)
                return self._signal[name]
              end
              
              function serviceData:SetState(key: string, value: any)
                self._state[key] = value
                if self._stateSignals[key] then
                  self._stateSignals[key]:Fire(value)		
                end
              end
              
              function serviceData:GetState(stateName: string)
                local state = self._state[stateName]
                assert(state, `State: '{stateName}' does not exist!`)
                return state
              end
              
              function serviceData:ObserveState(key: string, callback)
                if not self._stateSignals[key] then
                  self._stateSignals[key] = SignalClass.new(`{self.Name}_{key}`)
                end
                task.spawn(callback, self._state[key])
                return self._stateSignals[key]:Connect(self.Name, callback)
              end
              local proxy = CreateServiceProxy(serviceData)
              services[options.Name] = proxy
              return proxy
            end

            -- ==========================================
            -- 7. PUBLIC API: SERVICE RETRIEVAL
            -- ==========================================

            function Aethercore.GetService(name: string)
              local targetService = services[name]
              if not targetService then
                Logger.Log("Error (⛔)", `Tried to get not-existing Service: '{name}'`)
              end
              return targetService
            end

            -- ==========================================
            -- 8. DEPENDENCY RESOLUTION ENGINE (Topological Sort)
            -- ==========================================

            local function ResolveStartOrder(): {Service}
              local sorted: {Service} = {}
              local visited: {[string]: boolean} = {}
              local processing: {[string]: boolean} = {}
              
              local function visit(serviceName: string)
                if processing[serviceName] then
                  error(`[Aethercore] Circular dependency detected in {serviceName}`)
                end
                
                if visited[serviceName] then return end
                processing[serviceName] = true
                local service: Service = services[serviceName]
                if service and service.Dependencies then
                  for _, depName in service.Dependencies do
                    assert(services[depName], `Dependencie: '{depName}' was not found`)
                    visit(depName)
                  end
                  
                end
                processing[serviceName] = false
                visited[serviceName] = true
                table.insert(sorted, services[serviceName])
              end
              
              for service, _ in services do
                if not visited[service] then
                  visit(service)
                end
              end
              
              return sorted
            end

            -- ==========================================
            -- 9. LIFECYCLE CONTROLLER (Der Motor)
            -- ==========================================

            function Aethercore.Start()
              if isInitialized then
                Logger.Log("Warning (⚠ī¸)", `Already started Aethercore, don't need to start again`)
                return
              end
              
              Logger.Log("Info (ℹī¸)", `Aethercore has successfully started!`)
              
              local executionOrder = ResolveStartOrder()
              
              for _, service in ipairs(executionOrder) do
                if type(service.OnInit) == "function" then
                  local success, err = pcall(function()
                    service:OnInit()
                  end)
                  if not success then
                    Logger.Log("Error (⛔)",`OnInit failed: {err}`)
                  end
                end
              end

              isInitialized = true

              for _, service in ipairs(executionOrder) do
                if type(service.OnStart) == "function" then
                  task.spawn(function()
                    local success, err = pcall(function()
                      service:OnStart()
                    end)
                    if not success then
                      Logger.Log("Error (⛔)", `OnStart failed: {err}`)
                    end
                  end)
                end
              end

              for _, service in ipairs(executionOrder) do
                if type(service.OnUpdate) == "function" then
                  RunService.Heartbeat:Connect(function(deltaTime)
                    service:OnUpdate(deltaTime)
                  end)
                end

                if type(service.OnPhysics) == "function" then
                  RunService.Stepped:Connect(function(_, deltaTime)
                    service:OnPhysics(deltaTime)
                  end)
                end
              end

              hasStarted = true
              Logger.Log("Success (✅)", "🚀 Aethercore successfully ignited!")
            end

            -- ==========================================
            -- 10. DEBUG API
            -- ==========================================

            function Aethercore.PrintLogs()
              print("=== AETHERCORE DIAGNOSTIC LOGS ===")
              for _, log in ipairs(Logger.LoggedMessages) do
                print(log)
              end
              print("==================================")
            end

            function Aethercore.GetEventListener(serviceName: string, signalName: string)
              local service = services[serviceName]
              if service then
                local sig = service:GetSignal(signalName)
                if sig then
                  return sig:GetListeners()
                end
              end
              return {}
            end

            return Aethercore

UI Designs

Realistic HUD

Realistic HUD

Radio UI

Radio UI

Ability UI

Ability Frame

My Development Process

01

Architecture & Planning

Designing isolated modules, strict client-server communication, and scalable logic before writing a single line of code.

02

Clean Implementation

Writing highly optimized, strictly-typed Luau code. Focusing on performance, memory management, and modular frameworks.

03

Exploit Prevention

Implementing rigorous server-side sanity checks and validation to ensure every system is inherently secure and exploit-proof.

04

Polishing & Delivery

Smoothing out animations, syncing immersive VFX/SFX, balancing mechanics, and delivering a production-ready product.