Examples: TypeScript Components

Complete, working Pulse components. All use the TypeScript-first syntax — adapt folder paths, remote names, and values to your target game using Dex and rSpy.

---

Speed & jump hack

// src/combat/Movement.ts
defineComponent('Movement', () => {
  const speedEnabled = signal(false)
  const speed        = signal(50)
  const jumpEnabled  = signal(false)
  const jumpPower    = signal(100)

  function apply() {
    const h = _PulseGetHumanoid()
    if (!h) return
    h.WalkSpeed = speedEnabled() ? speed() : 16
    h.JumpPower = jumpEnabled() ? jumpPower() : 50
  }

  on.respawn(apply)
  on.signal(speedEnabled, apply)
  on.signal(speed,        apply)
  on.signal(jumpEnabled,  apply)
  on.signal(jumpPower,    apply)

  return [
    toggle('Speed Hack').bind(speedEnabled),
    slider('Walk Speed', { min: 16, max: 500, default: 50 }).bind(speed),
    separator(),
    toggle('Jump Hack').bind(jumpEnabled),
    slider('Jump Power', { min: 50, max: 500, default: 100 }).bind(jumpPower),
  ]
})

---

Player ESP

Highlights every other player through walls. Always parents to CoreGui to survive Roblox replication.

// src/visuals/PlayerESP.ts
defineComponent('PlayerESP', () => {
  const enabled     = signal(false)
  const showTeam    = signal(false)

  const highlights = new Map<Player, Highlight>()
  const players    = game.GetService('Players')

  function addPlayer(p: Player) {
    if (highlights.has(p)) return
    const char = p.Character as Model | undefined
    if (!char) return
    const h        = new Instance('Highlight')
    h.FillColor    = Color3.fromRGB(255, 50, 50)
    h.OutlineColor = Color3.fromRGB(255, 255, 255)
    h.FillTransparency    = 0.5
    h.OutlineTransparency = 0
    h.Adornee = char
    h.Parent  = game.GetService('CoreGui')
    highlights.set(p, h)
  }

  function removePlayer(p: Player) {
    const h = highlights.get(p)
    if (h) { h.Destroy(); highlights.delete(p) }
  }

  function clearAll() {
    for (const [, h] of highlights) h.Destroy()
    highlights.clear()
  }

  const loop = Pulse.Loop.new(0.5, () => {
    for (const p of players.GetPlayers()) {
      if (p === players.LocalPlayer) continue
      // Add missing
      if (!highlights.has(p)) addPlayer(p)
      // Refresh adornee if character changed
      const h = highlights.get(p)
      if (h && h.Adornee !== p.Character) h.Adornee = p.Character as Model
    }
    // Remove disconnected players
    for (const [p] of highlights) {
      if (!p.Parent) removePlayer(p)
    }
  })

  on.signal(enabled, (v) => {
    if (v) loop.start() else { clearAll(); loop.stop() }
  })

  on.respawn(() => {
    if (enabled()) { clearAll(); loop.stop(); loop.start() }
  })

  return [
    toggle('Player ESP', { default: true }).bind(enabled),
    toggle('Show Team',  { default: false }).bind(showTeam),
  ]
})

---

Auto ability (remote spam)

Fires a server remote on a key press. Find the remote name with rSpy.

// src/combat/AbilitySpam.ts
defineComponent('AbilitySpam', () => {
  const enabled  = signal(false)
  const cooldown = signal(0.5)

  let remote: RemoteEvent | undefined
  let lastFired  = 0

  task.spawn(() => {
    if (!game.IsLoaded()) game.Loaded.Wait()
    // Replace with the actual remote path from rSpy
    remote = game.GetService('ReplicatedStorage')
      .WaitForChild('Remotes', 10)
      ?.WaitForChild('UseAbility', 10) as RemoteEvent | undefined
  })

  on.inputBegan({ when: enabled }, (input, gpe) => {
    if (gpe) return
    if (input.KeyCode !== Enum.KeyCode.F) return
    const now = os.clock()
    if (now - lastFired < cooldown()) return
    lastFired = now
    if (remote) remote.FireServer()
    Pulse.Log.info('AbilitySpam', 'fired')
  })

  return [
    toggle('Auto Ability').bind(enabled),
    slider('Cooldown (s)', { min: 0.1, max: 3, default: 0.5 }).bind(cooldown),
    button('Fire Now', () => { if (remote) remote.FireServer() }),
  ]
})

---

FOV aimbot

Lock onto the nearest target inside a screen-space FOV circle.

// src/combat/Aimbot.ts
defineComponent('Aimbot', () => {
  const enabled    = signal(false)
  const fovRadius  = signal(150)
  const showCircle = signal(true)
  const smoothing  = signal(0.1)

  let circle: PulseDrawObject | null = null
  let locker = Pulse.Aim.locker()

  function getTargets(): Model[] {
    // Replace with your game's enemy folder
    const folder = workspace.FindFirstChild('Enemies') as Folder | undefined
    return folder ? (folder.GetChildren() as Model[]) : []
  }

  function getRoot(entity: Model): BasePart | undefined {
    return entity.FindFirstChild('HumanoidRootPart') as BasePart | undefined
  }

  // Update circle position every frame
  on.renderStepped({ when: enabled }, () => {
    if (!circle) return
    const cam = workspace.CurrentCamera
    if (!cam) return
    const sz = cam.ViewportSize
    circle.Position = new Vector2(sz.X * 0.5, sz.Y * 0.5)
    circle.Radius   = fovRadius()
    circle.Visible  = showCircle()
  })

  // Create/destroy circle when enabled changes
  on.signal(enabled, (v) => {
    if (v) {
      circle = Pulse.Draw.circle({
        color: Color3.fromRGB(255, 255, 255),
        thickness: 1.5,
        alpha: 0.8,
        filled: false,
        visible: false,
      })
      Pulse.Log.info('Aimbot', 'enabled')
    } else {
      Pulse.Draw.remove(circle)
      circle = null
      locker.release()
    }
  })

  // Right-click to lock/release
  on.inputBegan({ when: enabled }, (input, gpe) => {
    if (gpe) return
    if (input.UserInputType !== Enum.UserInputType.MouseButton2) return
    if (locker.isLocked()) {
      locker.release()
      Pulse.Log.info('Aimbot', 'released')
    } else {
      const nearest = Pulse.Aim.findNearest(getTargets(), {
        fovRadius: fovRadius(),
        getRoot,
      })
      if (nearest) {
        locker.lock(nearest, { getRoot, smoothing: smoothing() })
        Pulse.Log.info('Aimbot', 'locked', { name: nearest.Name })
      }
    }
  })

  return [
    toggle('Aimbot').bind(enabled),
    slider('FOV Radius',  { min: 50, max: 500, default: 150 }).bind(fovRadius),
    slider('Smoothing',   { min: 0,  max: 1,   default: 0.1 }).bind(smoothing),
    toggle('Show Circle', { default: true }).bind(showCircle),
  ]
})

---

Auto heal

Restores health when it drops below a threshold.

// src/player/AutoHeal.ts
defineComponent('AutoHeal', () => {
  const enabled   = signal(false)
  const threshold = signal(50)  // heal when HP drops below this %

  const cd = Pulse.Cooldown.new(2)

  on.heartbeat({ when: enabled, every: 0.5 }, () => {
    const h = _PulseGetHumanoid()
    if (!h) return
    if (h.Health / h.MaxHealth * 100 > threshold()) return
    if (!cd.ready()) return
    cd.use()
    h.Health = h.MaxHealth
    Pulse.Log.debug('AutoHeal', 'healed')
  })

  return [
    toggle('Auto Heal').bind(enabled),
    slider('HP Threshold %', { min: 10, max: 90, default: 50 }).bind(threshold),
  ]
})

---

Value monitor (IntValue / BoolValue)

Watch a game value and react when it changes — useful for watching round state, team, currency, etc.

// src/misc/RoundMonitor.ts
defineComponent('RoundMonitor', () => {
  const enabled = signal(false)

  let conn: RBXScriptConnection | undefined

  on.signal(enabled, (v) => {
    if (conn) { conn.Disconnect(); conn = undefined }
    if (!v) return

    task.spawn(() => {
      if (!game.IsLoaded()) game.Loaded.Wait()
      // Replace with your game's value path
      const val = game.GetService('ReplicatedStorage')
        .WaitForChild('GameState', 10) as StringValue | undefined
      if (!val) return

      Pulse.Log.info('RoundMonitor', 'watching', { current: val.Value })
      conn = val.Changed.Connect((newVal) => {
        Pulse.Log.info('RoundMonitor', 'changed', { value: newVal })
        // React to the state change here
      })
    })
  })

  return [toggle('Monitor Round State').bind(enabled)]
})

---

Noclip

Disables collisions for the local character. Uses on.heartbeat to keep applying every frame since Roblox resets CanCollide constantly.

// src/player/Noclip.ts
defineComponent('Noclip', () => {
  const enabled = signal(false)

  on.heartbeat({ when: enabled }, () => {
    const char = _PulseGetChar()
    if (!char) return
    for (const part of char.GetDescendants()) {
      if (part.IsA('BasePart') || part.IsA('UnionOperation')) {
        (part as BasePart).CanCollide = false
      }
    }
  })

  on.signal(enabled, (v) => {
    if (!v) {
      // Restore collision when disabled
      const char = _PulseGetChar()
      if (!char) return
      for (const part of char.GetDescendants()) {
        if (part.IsA('BasePart') || part.IsA('UnionOperation')) {
          (part as BasePart).CanCollide = true
        }
      }
    }
  })

  return [toggle('Noclip').bind(enabled)]
})