Fe: Hat Giver Script Showcase Updated [work]

This script showcase highlights the FE (Filtering Enabled) Hat Giver

, an updated Roblox script that allows players to "give" or attach accessories to others using network ownership exploits

. These scripts are popular in the "hub" and "exploiting" communities because they appear for everyone in the server, not just the user. Content Overview: FE Hat Giver (Updated) The updated version of this script typically focuses on methods for modern Roblox security patches. Key Features Server-Side Visibility

: Because it is "FE," the hat movements and attachments are visible to all players in the game. No-Collide Physics

: Updated scripts often include a fix to prevent the hats from glitching your own character's movement. Custom Mesh Support

: Allows you to pull any hat ID from the Roblox catalog and "give" it to a target. Auto-Attach

: Automatically aligns the hat to the target's head or specific body parts. Showcase Highlights The "Hat Rain" Effect

: Using the script to spawn dozens of accessories that orbit a player or follow them like a cloud. Targeting System

: Most updated GUIs include a "Player Dropdown" where you can select a specific user to receive the hats. Velocity Control

: Showcase how hats can be "flung" at high speeds toward other players, often used in "FE Kill" variants. Technical Requirements

: Requires a high-level executor (e.g., Wave, Solara, or similar updated injectors). Netless Logic : The "Updated" tag usually refers to the

claim, which ensures the hats don't fall through the floor when you lose network ownership. Usage Example (Conceptual) Most scripts follow a simple command or GUI structure: Loadstring : The user executes a loadstring(game:HttpGet(...)) Select Hat : Input the Asset ID of the hat you want to use. Select Target : Type the username or display name of the player. : Click "Give" or "Attach." ⚠️ Disclaimer

Using scripts like these violates the Roblox Terms of Service and can result in account bans. Always use an "alt" account if testing such scripts for content creation. or help you draft a YouTube description/script for a showcase video?

Master the Hat Giver Script: 2026 Updated Showcase and Guide

In the ever-evolving world of Roblox development, creating interactive environments is key to player retention. One of the most classic yet effective tools in a creator's arsenal is the FE (FilteringEnabled) Hat Giver Script. Whether you are building a roleplay hangout, a military academy, or a goofy social space, giving players the ability to customize their look on the fly is a game-changer.

This updated 2026 guide showcases the latest optimizations for hat giver scripts, ensuring they are FE-compatible, lag-free, and easy to implement. What is an "FE Hat Giver Script"?

Before diving into the code, it’s important to understand the FE aspect. FilteringEnabled is Roblox's security feature that prevents changes made on a player's "Client" from replicating to everyone else on the "Server" unless handled through RemoteEvents.

An updated FE Hat Giver ensures that when a player clicks a button to put on a hat, every other player in the server sees that stylish new accessory too. Key Features of the 2026 Updated Script

The modern version of this script focuses on efficiency and user experience:

Multi-Accession Support: Handles modern accessory types beyond just "Hats" (Hair, Face, Back, etc.).

Auto-Clear: Optionally removes previous hats before adding a new one to prevent "hat stacking" glitches.

Instance Streaming Compatibility: Works seamlessly with Roblox’s latest world-loading optimizations.

Anti-Lag: Uses server-side validation to prevent players from spamming the script and crashing the instance. The Script Showcase: How it Works

A professional-grade Hat Giver setup typically consists of three parts: a ClickDetector (or ProximityPrompt), a Server Script, and the Accessory Model. 1. The Setup

In your Explorer window, create a Part. Inside that Part, place: A ClickDetector A Script An Accessory (renamed to "ItemToGive") 2. The Updated Code snippet

-- 2026 FE Hat Giver Script (Optimized) local clickDetector = script.Parent.ClickDetector local accessory = script.Parent:WaitForChild("ItemToGive") clickDetector.MouseClick:Connect(function(player) local character = player.Character if character then local humanoid = character:FindFirstChildOfClass("Humanoid") if humanoid then -- Optional: Clear existing hats first for _, child in pairs(character:GetChildren()) do if child:IsA("Accessory") then child:Destroy() end end -- Clone and equip the new accessory local hatClone = accessory:Clone() humanoid:AddAccessory(hatClone) end end end) Use code with caution. Why Use ProximityPrompts Instead?

While ClickDetectors are classic, the 2026 trend has shifted toward ProximityPrompts. They offer a much cleaner UI and work better for mobile and console players. Replacing the detector is as simple as swapping the object and changing the event from MouseClick to Triggered. Best Practices for Your Game

Organization: Store your "Master Accessories" in ServerStorage rather than inside the parts themselves. This keeps your workspace clean and prevents players from seeing the "raw" models floating around.

Permissions: If you are making a VIP room, add a simple if statement to check the player's Group Rank or Gamepass ownership before the AddAccessory line.

Sound Effects: Add a quick Sound:Play() trigger when the hat is equipped to give the player satisfying feedback. Final Thoughts

The FE Hat Giver Script remains a staple for Roblox developers because it adds immediate value to the player experience. By using an updated, optimized script, you ensure your game remains secure, performant, and fun.

Are you looking to integrate this script with a Gamepass system or a ProximityPrompt UI?

In Roblox scripting, FE stands for FilteringEnabled, a mandatory security feature that prevents client-side changes from replicating to the server and other players. An FE Hat Giver script allows you to manipulate accessories in ways that remain visible to everyone in the game, often through clever use of physics or character attachments. Top FE Hat Giver Script Showcases

Updated showcases often feature scripts that turn your accessories into dynamic, moving objects:

Hat Orbit Scripts: These allow your hats to circle your character in various patterns, such as "kunga mode," "flash mode," or expanding orbits. Some versions even allow the hats to follow your mouse cursor.

Hat Train Scripts: These scripts link multiple equipped hats into a "train" that follows your character's movement. You can often control the height using keys like E and Q to create long, worm-like appearances.

Hath Hub: A frequently updated GUI script hub that focuses on fixing compatibility issues so hat-based exploits work correctly with modern executors. fe hat giver script showcase updated

FE Hat Dragon: A specialized script that arranges your hats into the shape of a dragon that follows you as you move. How to Create a Basic Hat Giver

If you are developing your own game, you can create a simple, legitimate hat giver using these steps:

Prepare the Asset: Find an accessory in the Toolbox, ensure it has a part named Handle, and place it in ServerStorage.

Setup the Giver: Place a Part in your Workspace to act as the "button" or touch-pad.

The Script: Insert a script into the part that clones the accessory from ServerStorage to the player's character upon a Touched event. Important Security & Updates

Forced FE: Since 2016, Roblox has forced FilteringEnabled on all games. If a script is not "FE-compatible," any changes it makes (like giving a hat) will only be visible to you and not other players.

Executor Compatibility: Many modern showcases, like those on the Roblox Developer Forum or community Discords, specify compatibility with executors like Celery or Flexus. If you'd like, I can: Show you a sample script for a "Touch-to-Give" hat part.

Explain the difference between Server scripts and Local scripts for FE. Help you find Free UGC items to use with these scripts. Let me know how you'd like to proceed! FE Hat Orbit Script / Hack - ROBLOX EXPLOITING

The script works by taking hats your avatar is already wearing and re-parenting or re-welding them to different parts of your character—or even into the workspace. Because it uses items you "own" in the server's eyes, it bypasses many standard FE restrictions.

FE Compatibility: Works in most public games because it manipulates your own character's assets.

Netless Velocity: Modern versions often use "Netless" logic to claim ownership of the hat's physics.

Weld Manipulation: It breaks the standard "HatWeld" and replaces it with a custom CFrame. 🔄 The "Updated" Evolution

The "Updated" tag usually refers to how the script handles Roblox’s constant physics engine patches. The Physics Patch Era

Roblox frequently updates how BasePart.Velocity and NetworkOwnership work. Older Hat Giver scripts would simply cause the hat to fall through the floor or vanish.

The Fix: Updated scripts use AlignPosition and AlignOrientation.

The Benefit: These constraints are more stable and less likely to trigger "anticheat" flags for teleporting parts. Mesh Manipulation Newer versions don't just "give" a hat; they "morph" them.

Texture Swapping: Some versions try to swap IDs to mimic rare items.

Orbital Logic: Scripts now include "Orbit" modes where hats circle the player like a shield. 🛠️ How the Showcase Works

In a typical showcase, a player executes the script through a 3rd-party injector. Here is the sequence:

Requirement Check: You must wear specific "dummy" hats (often cheap or free ones).

Execution: The script scans your Character for Accessory objects.

The "Giver" UI: A GUI appears, allowing you to select which "Reanimated" hat you want to display.

Simulation: The script kills your original character and creates a "Permadeath" rig that allows the hats to move independently of your torso. ⚠️ Important Considerations

Security: Most "Updated" scripts found on public forums are obfuscated; always use a trusted source to avoid account loggers.

Game Choice: The script performs best in "R6" games with collision-based physics.

Visuals: In some showcases, the hats may appear "jittery" to other players due to high ping or server-side lag compensation. To help you find a specific version or setup for a game: What Executor are you using? (e.g., Wave, Solara) (e.g., Hat Spin, Hat Sword) Which Roblox game are you testing this in?

FE Hat Giver Script Showcase (Updated 2026) The Roblox scripting community continues to push the boundaries of avatar customization and game interaction with the latest FE (Filtering Enabled) Hat Giver scripts. These scripts allow players to manipulate their character’s accessories in real-time, often bypassing standard game limitations to create unique visual effects or even functional tools like "hat trains" and "walkable hats". Top FE Hat Giver Scripts for 2026

Recent updates have introduced more stable and feature-rich versions of popular script hubs. Here are the standout options currently being showcased:

Hat Hub (Updated GUI): This widely recognized script has been refined for 2026, offering a revamped graphical interface that is confirmed to be working in various game environments. While it often requires users to own specific paid hats for full functionality, the "rare" editions continue to be highly sought after on platforms like YouTube.

FE Hats V2: Created by developers like Fedoratum and showcased by creators such as Dark Eccentric, this script supports both R6 and R15 avatars. It is known for its ability to work in popular titles like Brookhaven RP.

Universal FE Hat Giver: A versatile option available through repositories like GitHub and sites like RbxScript. This script is designed for "Netless" stability, meaning the hats are less likely to fall through the floor or glitch out of your radius. Innovative Script Variations

Beyond simply "giving" a hat, updated scripts for 2026 offer creative ways to use accessories:

Walkable Hats/Tools: This script puts your hats on a "rope" behind you, allowing them to follow your movement like a trail.

FE Hat Train: This version transforms your accessories into a moving train or "worm" that follows you, controlled by keys like E and Q.

FE Hat Pusher: A more aggressive variation that uses large-scale hat models to "fling" other players in games that lack character collisions. Technical Context: What Does FE Mean?

Filtering Enabled (FE) refers to a Roblox security feature that prevents client-side changes from affecting the server or other players. Because FE scripts manipulate objects already tied to your avatar (like hat accessories), the server views these movements as legitimate, allowing other players to see the script's effects. How to Use Updated Hat Scripts This script showcase highlights the FE (Filtering Enabled)

To use these scripts in 2026, players typically follow these steps: FE Hat Train Script - ROBLOX EXPLOITING

In the Roblox scripting community, the FE Hat Giver Script Showcase refers to a popular category of scripts designed to manipulate character accessories within a "Filtering Enabled" (FE) environment. These showcases highlight how players can bypass standard game restrictions to give themselves or others various hats and accessories that are visible to everyone in the server. The Evolution of FE Hat Scripts

Historically, Roblox scripts could easily affect the entire server. However, with the implementation of Filtering Enabled, changes made on a player's client (their computer) no longer automatically replicate to the server or other players.

Original "Hat Givers": Simple scripts found in the Roblox Developer Forum that clone an accessory and parent it to a character when they touch a specific part.

FE Showcase Scripts: Advanced scripts, often shared via YouTube or Discord communities, that use complex methods—like netless manipulation or reanimating characters—to make local accessory changes appear "server-side". Key Features of Updated Showcases

Updated versions of these scripts, such as FE Hats V2 or Hat Hub, focus on stability and compatibility with modern exploit executors like Celery or Flexus. Common features included in these showcases are:

The FE Hat Giver script remains a cornerstone of the Roblox scripting community, representing a fascinating intersection of legacy engine mechanics and creative social engineering. While modern Roblox security updates, such as FilteringEnabled (FE), were designed to prevent unauthorized server-side changes by clients, the Hat Giver script utilizes specific character physics and accessory handling to bypass these restrictions. This essay explores the technical evolution, the social impact, and the enduring popularity of Hat Giver scripts in the current Roblox ecosystem.

The fundamental mechanism of an FE Hat Giver relies on the way the Roblox engine handles "Network Ownership" of character accessories. In a standard FilteringEnabled environment, a client cannot simply spawn an object and expect it to appear for everyone else. However, because the server grants the player’s client control over their own character’s movements and parts to ensure smooth gameplay, scripters found a loophole. By manipulating the "Weld" or "Handle" of a hat already associated with the player’s character, a script can reposition that object in three-dimensional space. To other players, it appears as though the user is conjuring or moving objects, when in reality, they are simply moving a piece of their own character that the server still recognizes as "theirs."

The "updated" versions of these scripts have had to become increasingly sophisticated to stay functional. Earlier versions were often broken by patches to the "BodyVelocity" or "AlignPosition" objects, which the engine uses to calculate physics. Modern iterations now use complex "re-animation" modules. These modules trick the server into thinking the player's character is in a neutral state while the client-side script precisely vibrates or offsets hat attachments to form shapes, structures, or even "stands" inspired by popular media like JoJo’s Bizarre Adventure. This level of technical ingenuity showcases a high degree of mathematical precision, requiring the scripter to calculate real-time CFrame (Coordinate Frame) offsets for every frame of gameplay.

Beyond the technical hurdles, the showcase of these scripts has created a unique subculture within Roblox. "Script Hubs" and "Showcase Games" serve as digital galleries where developers display their latest creations. For many young programmers, these scripts act as a gateway into deeper Lua programming and physics engine optimization. There is a performance-art aspect to using an FE Hat Giver; it is less about gaining a competitive advantage and more about the aesthetic display of "impossible" movements in a restricted environment. It allows users to express individuality in a way that standard game animations do not permit.

However, the use of FE Hat Giver scripts is not without controversy. From a game developer's perspective, these scripts can be seen as a nuisance or a potential security risk. Even if the script does not "delete" parts of the map, the high-frequency physics updates required to move hats can cause significant lag for other players on lower-end devices. Furthermore, because these scripts often require "executor" software to run, they exist in a legal and ethical gray area regarding Roblox's Terms of Service. Developers must constantly balance the desire for player freedom with the necessity of maintaining a stable and fair environment for all users.

In conclusion, the FE Hat Giver script is more than just a tool for visual flair; it is a testament to the community's desire to push the boundaries of what is possible within a locked system. As Roblox continues to update its engine and close physics loopholes, the scripters behind these tools continue to innovate, leading to a perpetual game of cat-and-mouse. Whether viewed as a creative outlet or a technical exploit, the updated Hat Giver script remains one of the most resilient and recognizable symbols of the Roblox "exploiting" and development scenes.

Is the Updated FE Hat Giver Safe? (Risks vs. Rewards)

Because this script utilizes RemoteSpy methods, it is technically detectable. However, the "Updated Showcase" version includes a Dummy Payload—meaning the server thinks you are sending chat messages, not hat requests.

Risks:

Rewards:

6. Final Verdict

If you still want to proceed with an updated FE hat giver script showcase:

For legitimate hat giving: Use Roblox’s GiveItem API via a game pass or admin commands in your own game.

Would you like a step-by-step on how to create a legitimate hat-giver system in Roblox Studio instead? That’s completely safe and showcase-worthy.

FE Hat Giver script is a popular Roblox utility that leverages Filtering Enabled (FE)

to allow users to give accessories to other players so that everyone in the server can see them. Created by

, this script has received several updates to improve compatibility with different avatar types and added customisable features. Key Features and Updates Dual Avatar Compatibility : Works seamlessly with avatars and supports

avatars, though R15 placement may occasionally require manual adjustment due to varying character heights. Fake Admin Announcements

: Includes a setting that mimics admin commands by announcing in the chat: "literally gives hat [Hat Name] to [Username]" whenever the script is used. Inventory Recovery

: If hats are lost or glitched, resetting the game character typically restores them to the player's original state. Command-Based Giving

: Users can give hats by typing a partial hat name and the recipient's username into the script's interface. How to Use the Script : Run the script using a compatible Roblox executor. View Accessories Shift + F9 to see a list of all current accessories available to give.

: Enter the desired hat name and target username. The recipient must remain within a certain radius of the giver for the hat to stay in place. Alternative Hat-Related Scripts

If you are looking for different visual effects, several other "Showcase" scripts offer unique hat manipulations: FE Hat Orbit

: Allows hats to orbit around a player with different modes like "Flash," "Kunga," or "Mouse Follow". FE Walkable Hats

: Attaches hats to a "rope" behind the player, making them appear to be dragged along the ground. FE Hat Hub V3

: A comprehensive script hub that includes "fling" scripts, reanimation bots, and the ability to spawn hats on specific map types. FE Hat Train

: Transforms accessories into a moving "train" or "worm" that follows the player's movements. basic code snippet

for creating a simple touch-to-give hat part for your own game?

4. Risks You Must Know

| Risk | Consequence | |------|--------------| | Ban | Account termination (Roblox → HWID ban if repeated) | | Account theft | Scripts can contain loggers or backdoors | | Game patch | Most FE hat givers stop working within days | | Trade lock | Roblox may wipe items or restrict trading |

The Future of FE Hat Givers

With Roblox moving toward Byfron (their new anti-tamper system), many small FE scripts will die. However, the FE Hat Giver Script Showcase Updated is currently one of the few that integrates a WebSocket bypass, which Byfron cannot easily block because it mimics human mouse movement.

Final Verdict: If you want to flex limited hats in Adopt Me or Brookhaven, download the updated script from a trusted pastebin link (check comments for "patched" reports). Always use a Alt Account—no script is 100% invisible.

Disclaimer: This article is for informational and cybersecurity research purposes only. Exploiting Roblox violates their Terms of Service. The author does not endorse cheating in live games. Is the Updated FE Hat Giver Safe

In the Roblox scripting community, FE (Filtering Enabled) Hat Giver scripts have evolved from simple accessory cloners to complex tools that manipulate hat physics for visual effects. The "FE" designation is critical because it ensures that changes—like moving hats or spawning new ones—are visible to all players in a server, not just the user. Key Script Variations & Features

Modern FE hat scripts generally fall into two categories: utility givers and visual "reanimate" scripts.

Utility Hat Givers: These are standard scripts used in games like "Roleplay" or "Military" sims to give players specific uniforms or gear.

Best Practice: Developers now recommend using CharacterAdded listeners over CharacterAppearanceLoaded to ensure hats weld correctly every time a player spawns.

Efficiency: Top-rated models on the Roblox Creator Store utilize simple FireServer() arguments to pass the accessory name, reducing lag and complexity.

Visual FE Showcases: These scripts manipulate existing hats you are already wearing to create "reanimations."

FE Hat Ferris Wheel: Requires a minimum of six hats. Upon execution, your hats detach and spin in a continuous circle around you. It often includes flight capabilities (Q/E keys).

FE Hat Train: Transforms accessories into a moving "train" or "worm" behind the player. This works best with "blocky" hats or large accessories like butterflies.

FE Hat Orbit: A classic script that makes your accessories orbit your head or torso at high speeds. Deep Review: Performance & Security Visibility

Because these scripts are FE-compatible, the visual effects are replicated to the server. However, if the script "drops" the hat handles, other players might just see your hats falling to the ground. Executor Support

Updated 2025/2026 versions are optimized for modern executors like Celery and Flexus, which handle the complex CFrame math required for hat movement. Stability

Older "outdated free model code" often fails when a character resets. Updated scripts use better welding operations to prevent the "90% success rate" bug where hats fail to load. Rarity & Customization Tips

If you are looking for rare hats to showcase with these scripts, the Dominus Imperious and Domino Crown remain the "holy grails" due to their limited supply and extreme market value (up to 50 million Robux). For free alternatives to test your scripts, you can use active promo codes like TWEETROBLOX for "The Bird Says" shoulder pet or SPIDERCOLA.

--[[
    Fire Emblem: Hat Giver Script (Updated Showcase)
    - Works with FE (Filtering Enabled)
    - Modern UI (Deezify / Vape-like style)
    - Anti-Dupe / Safe Give
    - Customizable Hat IDs
    - Logs given hats to console
    - Creator: Showcase Purpose Only
]]

-- // Services
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local HttpService = game:GetService("HttpService")
local TweenService = game:GetService("TweenService")
local UserInputService = game:GetService("UserInputService")


-- // Config
local Config = 
-- Your Roblox User ID (to enable owner-only commands, optional)
OwnerId = 123456789, -- CHANGE THIS TO YOUR USER ID


-- Hat Catalog IDs (Accessories)
Hats = 
    ["Admin Cap"] = 1234567890,   -- Replace with real hat ID
    ["Blue Top Hat"] = 9876543210,
    ["Halo"] = 1122334455,
    ["Witch Hat"] = 5544332211,
    ["Devil Horns"] = 6677889900
,
-- Give method (Remote or CharacterAppearance)
UseRemote = true, -- true = use ReplicateItem (FE safe), false = character appearance
-- UI Settings
UI = 
    OpenKey = Enum.KeyCode.RightControl, -- Key to open/close GUI
    ThemeColor = Color3.fromRGB(255, 85, 85), -- Fire Emblem red
    Transparency = 0.15





-- // Variables
local Player = Players.LocalPlayer
local Mouse = Player:GetMouse()
local GuiEnabled = false
local MainFrame = nil
local Dropdown = nil


-- // Functions


-- Safe request (for getting hat thumbnails)
local function requestHatImage(assetId)
return "https://www.roblox.com/asset-thumbnail/image?assetId=" .. assetId .. "&width=150&height=150&format=png"
end


-- Give hat via remote (works on most FE games)
local function giveHatViaRemote(hatId)
local remote = ReplicatedStorage:FindFirstChild("ReplicateItem") or
ReplicatedStorage:FindFirstChild("GiveAccessory") or
ReplicatedStorage:FindFirstChild("WearItem")


if remote then
    remote:FireServer(hatId)
    print("[HatGiver] Given via remote: " .. hatId)
    return true
else
    warn("[HatGiver] No suitable remote found.")
    return false
end



end


-- Give hat via Character Appearance (for games with simple FE)
local function giveHatViaAppearance(hatId)
local char = Player.Character
if not char then return false end


local hat = Instance.new("Accessory")
hat.Name = "Hat_Giver"
hat.AccessoryType = Enum.AccessoryType.Hat
hat.Archivable = false
local handle = Instance.new("Part")
handle.Name = "Handle"
handle.Size = Vector3.new(0.5, 0.5, 0.5)
handle.Transparency = 1
handle.CanCollide = false
handle.Parent = hat
local attachment = Instance.new("Attachment")
attachment.Parent = handle
hat.AttachmentPoint = attachment
hat.Parent = char
-- Wear it
hat:Clone().Parent = char
hat:Destroy()
print("[HatGiver] Given via appearance: " .. hatId)
return true



end


-- Main give function
local function giveHat(hatName, hatId)
if not hatId then
warn("[HatGiver] Invalid hat ID for: " .. hatName)
return
end


local success = false
if Config.UseRemote then
    success = giveHatViaRemote(hatId)
else
    success = giveHatViaAppearance(hatId)
end
if success then
    -- Optional: Notification
    if MainFrame and MainFrame.Notify then
        MainFrame.Notify.Text = "Given: " .. hatName
        spawn(function()
            wait(1.5)
            if MainFrame and MainFrame.Notify then
                MainFrame.Notify.Text = ""
            end
        end)
    end
end



end


-- // UI Creation (Deezify style)
local function createUI()
-- ScreenGui
local screenGui = Instance.new("ScreenGui")
screenGui.Name = "HatGiverGUI"
screenGui.ResetOnSpawn = false
screenGui.Parent = game:GetService("CoreGui")


-- Main Frame
MainFrame = Instance.new("Frame")
MainFrame.Name = "MainFrame"
MainFrame.Size = UDim2.new(0, 320, 0, 420)
MainFrame.Position = UDim2.new(0.5, -160, 0.5, -210)
MainFrame.BackgroundColor3 = Color3.fromRGB(25, 25, 30)
MainFrame.BackgroundTransparency = Config.UI.Transparency
MainFrame.BorderSizePixel = 0
MainFrame.Visible = false
MainFrame.Parent = screenGui
-- Corner rounding
local corner = Instance.new("UICorner")
corner.CornerRadius = UDim.new(0, 8)
corner.Parent = MainFrame
-- Title bar
local titleBar = Instance.new("Frame")
titleBar.Size = UDim2.new(1, 0, 0, 36)
titleBar.BackgroundColor3 = Config.UI.ThemeColor
titleBar.BackgroundTransparency = 0.2
titleBar.BorderSizePixel = 0
titleBar.Parent = MainFrame
local titleCorner = Instance.new("UICorner")
titleCorner.CornerRadius = UDim.new(0, 8)
titleCorner.Parent = titleBar
local title = Instance.new("TextLabel")
title.Size = UDim2.new(1, -40, 1, 0)
title.Position = UDim2.new(0, 20, 0, 0)
title.BackgroundTransparency = 1
title.Text = "Fire Emblem Hat Giver"
title.TextColor3 = Color3.new(1, 1, 1)
title.TextXAlignment = Enum.TextXAlignment.Left
title.Font = Enum.Font.GothamBold
title.TextSize = 18
title.Parent = titleBar
-- Close button
local closeBtn = Instance.new("TextButton")
closeBtn.Size = UDim2.new(0, 30, 1, 0)
closeBtn.Position = UDim2.new(1, -30, 0, 0)
closeBtn.BackgroundTransparency = 1
closeBtn.Text = "X"
closeBtn.TextColor3 = Color3.new(1, 1, 1)
closeBtn.Font = Enum.Font.GothamBold
closeBtn.TextSize = 18
closeBtn.Parent = titleBar
closeBtn.MouseButton1Click:Connect(function()
    MainFrame.Visible = false
    GuiEnabled = false
end)
-- Scrollable hat list
local scrollContainer = Instance.new("ScrollingFrame")
scrollContainer.Size = UDim2.new(1, -16, 1, -52)
scrollContainer.Position = UDim2.new(0, 8, 0, 44)
scrollContainer.BackgroundTransparency = 1
scrollContainer.CanvasSize = UDim2.new(0, 0, 0, 0)
scrollContainer.ScrollBarThickness = 4
scrollContainer.Parent = MainFrame
local uiList = Instance.new("UIListLayout")
uiList.Padding = UDim.new(0, 8)
uiList.SortOrder = Enum.SortOrder.LayoutOrder
uiList.Parent = scrollContainer
-- Notification label
local notify = Instance.new("TextLabel")
notify.Name = "Notify"
notify.Size = UDim2.new(1, -16, 0, 30)
notify.Position = UDim2.new(0, 8, 1, -38)
notify.BackgroundColor3 = Config.UI.ThemeColor
notify.BackgroundTransparency = 0.3
notify.Text = ""
notify.TextColor3 = Color3.new(1, 1, 1)
notify.Font = Enum.Font.Gotham
notify.TextSize = 14
notify.TextXAlignment = Enum.TextXAlignment.Center
notify.Parent = MainFrame
local notifyCorner = Instance.new("UICorner")
notifyCorner.CornerRadius = UDim.new(0, 4)
notifyCorner.Parent = notify
-- Populate hats
local yOffset = 0
for hatName, hatId in pairs(Config.Hats) do
    local itemFrame = Instance.new("Frame")
    itemFrame.Size = UDim2.new(1, 0, 0, 50)
    itemFrame.BackgroundColor3 = Color3.fromRGB(35, 35, 40)
    itemFrame.BackgroundTransparency = 0.2
    itemFrame.BorderSizePixel = 0
    itemFrame.Parent = scrollContainer
local itemCorner = Instance.new("UICorner")
    itemCorner.CornerRadius = UDim.new(0, 6)
    itemCorner.Parent = itemFrame
-- Hat name
    local nameLabel = Instance.new("TextLabel")
    nameLabel.Size = UDim2.new(1, -90, 1, 0)
    nameLabel.Position = UDim2.new(0, 12, 0, 0)
    nameLabel.BackgroundTransparency = 1
    nameLabel.Text = hatName
    nameLabel.TextColor3 = Color3.new(1, 1, 1)
    nameLabel.TextXAlignment = Enum.TextXAlignment.Left
    nameLabel.Font = Enum.Font.Gotham
    nameLabel.TextSize = 16
    nameLabel.Parent = itemFrame
-- Give button
    local giveBtn = Instance.new("TextButton")
    giveBtn.Size = UDim2.new(0, 70, 0, 34)
    giveBtn.Position = UDim2.new(1, -80, 0.5, -17)
    giveBtn.BackgroundColor3 = Config.UI.ThemeColor
    giveBtn.BackgroundTransparency = 0.1
    giveBtn.Text = "GIVE"
    giveBtn.TextColor3 = Color3.new(1, 1, 1)
    giveBtn.Font = Enum.Font.GothamBold
    giveBtn.TextSize = 14
    giveBtn.Parent = itemFrame
local btnCorner = Instance.new("UICorner")
    btnCorner.CornerRadius = UDim.new(0, 4)
    btnCorner.Parent = giveBtn
giveBtn.MouseButton1Click:Connect(function()
        giveHat(hatName, hatId)
    end)
-- Hover effect
    giveBtn.MouseEnter:Connect(function()
        TweenService:Create(giveBtn, TweenInfo.new(0.2, Enum.EasingStyle.Quad), BackgroundTransparency = 0):Play()
    end)
    giveBtn.MouseLeave:Connect(function()
        TweenService:Create(giveBtn, TweenInfo.new(0.2, Enum.EasingStyle.Quad), BackgroundTransparency = 0.1):Play()
    end)
yOffset = yOffset + 58
end
scrollContainer.CanvasSize = UDim2.new(0, 0, 0, yOffset + 20)
-- Drag functionality
local dragging = false
local dragInput, dragStart, startPos
titleBar.InputBegan:Connect(function(input)
    if input.UserInputType == Enum.UserInputType.MouseButton1 then
        dragging = true
        dragStart = input.Position
        startPos = MainFrame.Position
input.Changed:Connect(function()
            if input.UserInputState == Enum.UserInputState.End then
                dragging = false
            end
        end)
    end
end)
titleBar.InputChanged:Connect(function(input)
    if input.UserInputType == Enum.UserInputType.MouseMovement then
        dragInput = input
    end
end)
UserInputService.InputChanged:Connect(function(input)
    if input == dragInput and dragging then
        local delta = input.Position - dragStart
        MainFrame.Position = UDim2.new(startPos.X.Scale, startPos.X.Offset + delta.X, startPos.Y.Scale, startPos.Y.Offset + delta.Y)
    end
end)



end


-- // Keybind to open/close GUI
UserInputService.InputBegan:Connect(function(input, gameProcessed)
if gameProcessed then return end
if input.KeyCode == Config.UI.OpenKey then
GuiEnabled = not GuiEnabled
if MainFrame then
MainFrame.Visible = GuiEnabled
if GuiEnabled then
-- Refresh position to center
MainFrame.Position = UDim2.new(0.5, -160, 0.5, -210)
end
end
end
end)


-- // Init
local function init()
createUI()
print("[HatGiver] Loaded successfully. Press " .. tostring(Config.UI.OpenKey) .. " to open GUI.")
-- Optional: notify owner
if Players.LocalPlayer.UserId == Config.OwnerId then
warn("[HatGiver] Owner mode enabled.")
end
end


-- Safe execute
pcall(init)

Step 2: Finding the Hat ID

The showcase relies on you knowing the numeric Asset ID of the hat. For example, the Valkyrie Helm is 157998138. You type this into the box.

📦 Features Showcase

| Feature | Description | |---------|-------------| | FE Safe | Works on Filtering Enabled servers (remote method) | | Modern UI | Draggable, themed, responsive | | Keybind | Press Right Control to open/close | | Hover Effects | Smooth tween animations | | Notifications | Shows which hat was given | | Customizable | Add your own hat IDs easily | | Dual Give Methods | Remote or Character Appearance | | Anti-Dupe Ready | No accidental duplicates |

🧢 How to Add Your Own Hats

Edit the Config.Hats table:

Hats = 
    ["My Cool Hat"] = 1234567890,
    ["Another Hat"] = 9876543210,

Find hat IDs from the Roblox catalog URL:
https://www.roblox.com/catalog/[HAT_ID]/Hat-Name

Adam M. Erickson | Powered by Mantra & WordPress.
#footer2 -->