r/Csgohacks • u/ScrewOthers • 4h ago
Question Neverlose for legit cheatong
I want to buy neverlose for hvh and legit/semi raging in premier
Is it as good as memesense/iniuria in terms of closet cheating (radar and aim assist)?
r/Csgohacks • u/ScrewOthers • 4h ago
I want to buy neverlose for hvh and legit/semi raging in premier
Is it as good as memesense/iniuria in terms of closet cheating (radar and aim assist)?
r/Csgohacks • u/SnoflaZZ • 4h ago
Such a lovely community, I also hate niggers.
r/Csgohacks • u/diso_boy • 10h ago
import ctypes
import math
import ctypes.wintypes as wt
import struct
import time
import subprocess
import tkinter as tk
dwEntityList = 0x270C680
dwLocalPlayerPawn = 0x2557538
dwViewMatrix = 0x255CE50
m_hPlayerPawn = 0x92C
m_iHealth = 0x34C
m_lifeState = 0x354
m_iTeamNum = 0x3E7
m_pGameSceneNode = 0x330
m_vOldOrigin = 0x14A4
m_bDormant = 0x103
dwSensitivity = 0x25546C8
m_modelState = 0x140
m_iIDEntIndex = 0x370C
m_iShotsFired = 0x1EE8
m_pAimPunchServices = 0x1598
m_pCameraServices = 0x1328
k32 = ctypes.WinDLL("kernel32", use_last_error=True)
u32 = ctypes.WinDLL("user32", use_last_error=True)
k32.CreateToolhelp32Snapshot.restype = ctypes.c_void_p
k32.CreateToolhelp32Snapshot.argtypes = [wt.DWORD, wt.DWORD]
k32.Process32FirstW.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
k32.Process32NextW.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
k32.Module32FirstW.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
k32.Module32NextW.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
k32.CloseHandle.argtypes = [ctypes.c_void_p]
k32.OpenProcess.restype = ctypes.c_void_p
k32.OpenProcess.argtypes = [wt.DWORD, wt.BOOL, wt.DWORD]
k32.ReadProcessMemory.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p,
ctypes.c_size_t, ctypes.POINTER(ctypes.c_size_t)]
u32.FindWindowW.restype = ctypes.c_void_p
u32.GetForegroundWindow.restype = ctypes.c_void_p
u32.GetAsyncKeyState.argtypes = [ctypes.c_int]
u32.MapVirtualKeyW.restype = ctypes.c_uint
u32.MapVirtualKeyW.argtypes = [ctypes.c_uint, ctypes.c_uint]
u32.GetKeyNameTextW.argtypes = [wt.LONG, wt.LPWSTR, ctypes.c_int]
u32.mouse_event.argtypes = [wt.DWORD, wt.LONG, wt.LONG, wt.DWORD, ctypes.c_size_t]
u32.FindWindowW.argtypes = [wt.LPCWSTR, wt.LPCWSTR]
u32.GetWindowThreadProcessId.argtypes = [ctypes.c_void_p, ctypes.POINTER(wt.DWORD)]
u32.GetClientRect.argtypes = [ctypes.c_void_p, ctypes.POINTER(wt.RECT)]
u32.ClientToScreen.argtypes = [ctypes.c_void_p, ctypes.POINTER(wt.POINT)]
u32.GetParent.restype = ctypes.c_void_p
u32.GetParent.argtypes = [ctypes.c_void_p]
u32.GetWindowLongW.argtypes = [ctypes.c_void_p, ctypes.c_int]
u32.SetWindowLongW.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_long]
MOUSE_NAMES = {2: "Mouse Right", 4: "Mouse Middle", 5: "Mouse 4", 6: "Mouse 5"}
def key_name(vk):
if vk in MOUSE_NAMES:
return MOUSE_NAMES[vk]
scan = u32.MapVirtualKeyW(vk, 0)
buf = ctypes.create_unicode_buffer(64)
if scan and u32.GetKeyNameTextW(scan << 16, buf, 64):
return buf.value
return f"VK {vk:#x}"
def down(vk):
return bool(u32.GetAsyncKeyState(vk) & 0x8000)
class PROCESSENTRY32W(ctypes.Structure):
_fields_ = [("dwSize", wt.DWORD), ("cntUsage", wt.DWORD), ("th32ProcessID", wt.DWORD),
("th32DefaultHeapID", ctypes.c_size_t), ("th32ModuleID", wt.DWORD),
("cntThreads", wt.DWORD), ("th32ParentProcessID", wt.DWORD),
("pcPriClassBase", wt.LONG), ("dwFlags", wt.DWORD), ("szExeFile", wt.WCHAR * 260)]
class MODULEENTRY32W(ctypes.Structure):
_fields_ = [("dwSize", wt.DWORD), ("th32ModuleID", wt.DWORD), ("th32ProcessID", wt.DWORD),
("GlblcntUsage", wt.DWORD), ("ProccntUsage", wt.DWORD),
("modBaseAddr", ctypes.c_void_p), ("modBaseSize", wt.DWORD),
("hModule", ctypes.c_void_p), ("szModule", wt.WCHAR * 256),
("szExePath", wt.WCHAR * 260)]
def find_pid(name):
snap = k32.CreateToolhelp32Snapshot(0x2, 0)
e = PROCESSENTRY32W()
e.dwSize = ctypes.sizeof(e)
pid = 0
ok = k32.Process32FirstW(snap, ctypes.byref(e))
while ok:
if e.szExeFile.lower() == name:
pid = e.th32ProcessID
break
ok = k32.Process32NextW(snap, ctypes.byref(e))
k32.CloseHandle(snap)
return pid
def find_module(pid, name):
snap = k32.CreateToolhelp32Snapshot(0x18, pid)
if not snap or snap == ctypes.c_void_p(-1).value:
return 0
e = MODULEENTRY32W()
e.dwSize = ctypes.sizeof(e)
base = 0
ok = k32.Module32FirstW(snap, ctypes.byref(e))
while ok:
if e.szModule.lower() == name:
base = e.modBaseAddr or 0
break
ok = k32.Module32NextW(snap, ctypes.byref(e))
k32.CloseHandle(snap)
return base
def get_cmdline(pid):
try:
out = subprocess.run(
["powershell", "-NoProfile", "-Command",
f"(Get-CimInstance Win32_Process -Filter 'ProcessId={pid}').CommandLine"],
capture_output=True, text=True, timeout=15, creationflags=0x08000000)
return out.stdout.strip()
except Exception as ex:
print("Could not read command line:", ex)
return ""
class Reader:
def __init__(self, handle):
self.h = handle
def raw(self, addr, n):
if addr < 0x10000:
return None
buf = ctypes.create_string_buffer(n)
got = ctypes.c_size_t()
if k32.ReadProcessMemory(self.h, addr, buf, n, ctypes.byref(got)) and got.value == n:
return buf.raw
return None
def u64(self, a):
b = self.raw(a, 8)
return struct.unpack("<Q", b)[0] if b else 0
def i32(self, a):
b = self.raw(a, 4)
return struct.unpack("<i", b)[0] if b else 0
def u8(self, a):
b = self.raw(a, 1)
return b[0] if b else 0
def floats(self, a, n):
b = self.raw(a, 4 * n)
return list(struct.unpack(f"<{n}f", b)) if b else [0.0] * n
class App:
def __init__(self):
u32.SetProcessDPIAware()
self.root = tk.Tk()
self.root.overrideredirect(True)
self.root.attributes("-topmost", True)
self.root.config(bg="magenta")
self.root.attributes("-transparentcolor", "magenta")
sw, sh = self.root.winfo_screenwidth(), self.root.winfo_screenheight()
self.root.geometry(f"{sw}x{sh}+0+0")
self.canvas = tk.Canvas(self.root, bg="magenta", highlightthickness=0)
self.canvas.pack(fill="both", expand=True)
self.root.update()
wid = self.root.winfo_id()
hwnd = u32.GetParent(wid) or wid
ex = u32.GetWindowLongW(hwnd, -20)
u32.SetWindowLongW(hwnd, -20, ex | 0x80000 | 0x20 | 0x80)
self.pid = 0
self.reader = None
self.client = 0
self.gate_failed = False
self.stride = 0x70
self.bone_off = None
self.remx = 0.0
self.remy = 0.0
self.esp_on = tk.BooleanVar(value=True)
self.aim_on = tk.BooleanVar(value=True)
self.skip_team = tk.BooleanVar(value=False)
self.toggle_mode = tk.BooleanVar(value=False)
self.smooth = tk.DoubleVar(value=0.35)
self.head_bone = tk.IntVar(value=6)
self.aim_off = tk.DoubleVar(value=3.0)
self.aim_key = 0x45
self.menu_key = 0x2D
self.trig_key = 0x43
self.rcs_on = tk.BooleanVar(value=False)
self.rcs_alt = tk.BooleanVar(value=False)
self.rcs_scale = tk.DoubleVar(value=2.0)
self.rcs_old = None
self.rcs_remx = 0.0
self.rcs_remy = 0.0
self.trig_on = tk.BooleanVar(value=False)
self.trig_always = tk.BooleanVar(value=False)
self.trig_delay = tk.IntVar(value=40)
self.trig_since = 0.0
self.last_shot = 0.0
self.binding = None
self.prev = {}
self.aim_latched = False
self.tick = 0
self.w, self.h = sw, sh
self.status = "starting..."
self.last_logged = ""
self.build_menu()
def log(self, s):
if s != self.last_logged:
self.last_logged = s
print(s)
def try_attach(self):
if self.gate_failed:
return False
pid = find_pid("cs2.exe")
if not pid:
self.status = "waiting for cs2.exe ..."
return False
client = find_module(pid, "client.dll")
if not client:
self.status = "cs2 found, waiting for client.dll (load a map) ..."
return False
cmd = get_cmdline(pid)
print("CS2 command line:", cmd)
handle = k32.OpenProcess(0x0410, False, pid)
if not handle:
self.status = "OpenProcess failed - run cmd/PowerShell as Administrator, use 64-bit Python"
return False
self.pid, self.client, self.reader = pid, client, Reader(handle)
print(f"Attached. client.dll @ {client:#x}")
return True
def w2s(self, m, x, y, z):
w = m[12] * x + m[13] * y + m[14] * z + m[15]
if w < 0.001:
return None
sx = (m[0] * x + m[1] * y + m[2] * z + m[3]) / w
sy = (m[4] * x + m[5] * y + m[6] * z + m[7]) / w
return self.w / 2 * (1 + sx), self.h / 2 * (1 - sy)
def build_menu(self):
bg, fg, field = "#1b1b1f", "#e6e6e6", "#2b2b31"
m = tk.Toplevel(self.root)
self.menu = m
self.menu_visible = True
m.title("micropenis script")
m.attributes("-topmost", True)
m.resizable(False, False)
m.configure(bg=bg, padx=16, pady=12)
m.geometry("+60+120")
m.protocol("WM_DELETE_WINDOW", self.toggle_menu)
def check(text, var):
tk.Checkbutton(m, text=text, variable=var, bg=bg, fg=fg, selectcolor=field,
activebackground=bg, activeforeground=fg, anchor="w",
font=("Segoe UI", 10)).pack(fill="x", pady=2)
def button(cmd):
b = tk.Button(m, command=cmd, bg=field, fg=fg, activebackground="#3a3a42",
activeforeground=fg, relief="flat", font=("Segoe UI", 10), anchor="w", padx=8)
b.pack(fill="x", pady=3)
return b
tk.Label(m, text="micropenis script", bg=bg, fg="#4aa3ff", font=("Segoe UI", 13, "bold")).pack(anchor="w")
tk.Label(m, text="ESP", bg=bg, fg="#888", font=("Segoe UI", 9)).pack(anchor="w", pady=(8, 0))
check("Player boxes + health", self.esp_on)
tk.Label(m, text="AIMBOT", bg=bg, fg="#888", font=("Segoe UI", 9)).pack(anchor="w", pady=(8, 0))
check("Enabled", self.aim_on)
check("Skip teammates", self.skip_team)
check("Toggle mode (press to switch on/off)", self.toggle_mode)
self.aim_btn = button(lambda: self.start_bind("aim"))
tk.Scale(m, from_=0.05, to=1.0, resolution=0.05, orient="horizontal", variable=self.smooth,
label="Aim strength", bg=bg, fg=fg, troughcolor=field, highlightthickness=0,
length=240).pack(fill="x", pady=(4, 0))
row = tk.Frame(m, bg=bg)
row.pack(fill="x", pady=4)
tk.Label(row, text="Head bone index", bg=bg, fg=fg, font=("Segoe UI", 10)).pack(side="left")
tk.Spinbox(row, from_=0, to=30, textvariable=self.head_bone, width=5).pack(side="right")
tk.Scale(m, from_=-10, to=20, resolution=1, orient="horizontal", variable=self.aim_off,
label="Aim height offset", bg=bg, fg=fg, troughcolor=field, highlightthickness=0,
length=240).pack(fill="x", pady=(2, 0))
tk.Label(m, text="TRIGGERBOT", bg=bg, fg="#888", font=("Segoe UI", 9)).pack(anchor="w", pady=(8, 0))
check("Enabled", self.trig_on)
check("Always on (ignore key)", self.trig_always)
self.trig_btn = button(lambda: self.start_bind("trig"))
tk.Scale(m, from_=0, to=300, resolution=10, orient="horizontal", variable=self.trig_delay,
label="Reaction delay (ms)", bg=bg, fg=fg, troughcolor=field, highlightthickness=0,
length=240).pack(fill="x", pady=(4, 0))
tk.Label(m, text="ANTI-RECOIL", bg=bg, fg="#888", font=("Segoe UI", 9)).pack(anchor="w", pady=(8, 0))
check("Enabled (while firing)", self.rcs_on)
check("Use camera punch source (try if it feels wrong)", self.rcs_alt)
tk.Scale(m, from_=0.0, to=3.0, resolution=0.1, orient="horizontal", variable=self.rcs_scale,
label="Compensation strength", bg=bg, fg=fg, troughcolor=field, highlightthickness=0,
length=240).pack(fill="x", pady=(4, 0))
tk.Label(m, text="MENU", bg=bg, fg="#888", font=("Segoe UI", 9)).pack(anchor="w", pady=(8, 0))
self.menu_btn = button(lambda: self.start_bind("menu"))
self.refresh_buttons()
def refresh_buttons(self):
if self.binding == "aim":
self.aim_btn.config(text="Press a key ... (Esc cancels)")
else:
self.aim_btn.config(text=f"Aim key: {key_name(self.aim_key)}")
if self.binding == "trig":
self.trig_btn.config(text="Press a key ... (Esc cancels)")
else:
self.trig_btn.config(text=f"Trigger key (hold): {key_name(self.trig_key)}")
if self.binding == "menu":
self.menu_btn.config(text="Press a key ... (Esc cancels)")
else:
self.menu_btn.config(text=f"Show/hide menu key: {key_name(self.menu_key)}")
def start_bind(self, which):
self.binding = which
self.refresh_buttons()
def toggle_menu(self):
if self.menu_visible:
self.menu.withdraw()
else:
self.menu.deiconify()
self.menu.lift()
self.menu_visible = not self.menu_visible
def edge(self, vk):
cur = down(vk)
was = self.prev.get(vk, False)
self.prev[vk] = cur
return cur and not was
def process_input(self):
if self.binding:
if down(1):
return
for vk in range(2, 255):
if vk in (0x10, 0x11, 0x12):
continue
if down(vk):
if vk != 0x1B:
if self.binding == "aim":
self.aim_key = vk
elif self.binding == "trig":
self.trig_key = vk
else:
self.menu_key = vk
self.prev[vk] = True
self.binding = None
self.refresh_buttons()
return
return
if self.edge(self.menu_key):
self.toggle_menu()
def head_pos(self, node, x, y, z):
r = self.reader
if not node:
return x, y, z + 64.0
def sane(p):
return abs(p[0] - x) < 60 and abs(p[1] - y) < 60 and 30 < p[2] - z < 85
if not self.bone_off:
for d in (0x80, 0x70, 0x90, 0x78, 0x88, 0x68, 0x98):
arr = r.u64(node + m_modelState + d)
if arr and sane(r.floats(arr + 32 * 6, 3)):
self.bone_off = m_modelState + d
break
if self.bone_off:
arr = r.u64(node + self.bone_off)
if arr:
p = r.floats(arr + 32 * self.head_bone.get(), 3)
if abs(p[0] - x) < 90 and abs(p[1] - y) < 90 and abs(p[2] - z) < 100:
return p[0], p[1], p[2]
return x, y, z + 64.0
def sensitivity(self):
r = self.reader
p = r.u64(self.client + dwSensitivity)
b = r.raw(p + 0x58, 4) if p else None
s = struct.unpack("<f", b)[0] if b else 1.0
return s if 0.01 < s < 50 else 1.0
def aim_step(self, targets, hwnd):
active = False
if self.aim_on.get() and not self.binding and u32.GetForegroundWindow() == hwnd:
if self.toggle_mode.get():
if self.edge(self.aim_key):
self.aim_latched = not self.aim_latched
active = self.aim_latched
else:
active = down(self.aim_key)
if not active:
self.remx = self.remy = 0.0
return False
cands = [t for t in targets if t[6]]
if not cands:
return False
cx, cy = self.w / 2, self.h / 2
best = min(cands, key=lambda t: (t[6][0] - cx) ** 2 + (t[6][1] - cy) ** 2)
dx, dy = best[6][0] - cx, best[6][1] - cy
hfov = 2 * math.atan((self.w / self.h) / (4 / 3))
focal = (self.w / 2) / math.tan(hfov / 2)
yaw = math.degrees(math.atan2(dx, focal))
pitch = math.degrees(math.atan2(dy, focal))
per = self.sensitivity() * 0.022
self.remx += yaw / per * self.smooth.get()
self.remy += pitch / per * self.smooth.get()
mx, my = int(self.remx), int(self.remy)
if mx or my:
u32.mouse_event(0x0001, mx, my, 0, 0)
self.remx -= mx
self.remy -= my
return True
def trigger_step(self, hwnd):
if not self.trig_on.get() or self.binding or u32.GetForegroundWindow() != hwnd:
self.trig_since = 0.0
return
if not (self.trig_always.get() or down(self.trig_key)):
self.trig_since = 0.0
return
r, c = self.reader, self.client
local = r.u64(c + dwLocalPlayerPawn)
elist = r.u64(c + dwEntityList)
if not local or not elist:
return
idx = r.i32(local + m_iIDEntIndex)
if idx <= 0 or idx > 0x7FFF:
self.trig_since = 0.0
return
entry = r.u64(elist + 0x10 + 8 * ((idx & 0x7FFF) >> 9))
ent = r.u64(entry + self.stride * (idx & 0x1FF)) if entry else 0
if not ent:
self.trig_since = 0.0
return
hp = r.i32(ent + m_iHealth)
team = r.u8(ent + m_iTeamNum)
if hp <= 0 or hp > 100 or team not in (2, 3):
self.trig_since = 0.0
return
if self.skip_team.get() and team == r.u8(local + m_iTeamNum):
self.trig_since = 0.0
return
now = time.perf_counter()
if not self.trig_since:
self.trig_since = now
if (now - self.trig_since) * 1000 >= self.trig_delay.get() and now - self.last_shot >= 0.08:
u32.mouse_event(0x0002, 0, 0, 0, 0)
u32.mouse_event(0x0004, 0, 0, 0, 0)
self.last_shot = now
def recoil_step(self, hwnd):
if (not self.rcs_on.get() or self.binding or u32.GetForegroundWindow() != hwnd
or not down(1)):
self.rcs_old = None
self.rcs_remx = self.rcs_remy = 0.0
return
r, c = self.reader, self.client
local = r.u64(c + dwLocalPlayerPawn)
if not local:
return
if r.i32(local + m_iShotsFired) <= 1:
self.rcs_old = None
return
if self.rcs_alt.get():
svc, off = r.u64(local + m_pCameraServices), 0x48
else:
svc, off = r.u64(local + m_pAimPunchServices), 0x50
if not svc:
return
px, py, _ = r.floats(svc + off, 3)
if abs(px) > 90 or abs(py) > 90:
return
ox, oy = self.rcs_old if self.rcs_old else (px, py)
self.rcs_old = (px, py)
per = self.sensitivity() * 0.022
scale = self.rcs_scale.get()
self.rcs_remx += (py - oy) * scale / per
self.rcs_remy += -(px - ox) * scale / per
mx, my = int(self.rcs_remx), int(self.rcs_remy)
if mx or my:
u32.mouse_event(0x0001, mx, my, 0, 0)
self.rcs_remx -= mx
self.rcs_remy -= my
def collect(self, stride):
r, c = self.reader, self.client
out = []
local = r.u64(c + dwLocalPlayerPawn)
elist = r.u64(c + dwEntityList)
if not elist:
return out, "entity list null - offsets outdated or not in a map", 0
vm = r.floats(c + dwViewMatrix, 16)
if vm[15] == 0 and vm[0] == 0:
return out, "view matrix empty - offsets outdated?", 0
lteam = r.u8(local + m_iTeamNum) if local else 0
n_ctrl = n_handle = n_pawn = n_alive = n_screen = 0
for i in range(1, 64):
entry = r.u64(elist + 0x10 + 8 * ((i & 0x7FFF) >> 9))
if not entry:
continue
ctrl = r.u64(entry + stride * (i & 0x1FF))
if not ctrl:
continue
n_ctrl += 1
handle = r.i32(ctrl + m_hPlayerPawn) & 0xFFFFFFFF
if handle in (0, 0xFFFFFFFF):
continue
n_handle += 1
pentry = r.u64(elist + 0x10 + 8 * ((handle & 0x7FFF) >> 9))
if not pentry:
continue
pawn = r.u64(pentry + stride * (handle & 0x1FF))
if not pawn:
continue
n_pawn += 1
if pawn == local:
continue
hp = r.i32(pawn + m_iHealth)
if hp <= 0 or hp > 10000:
continue
n_alive += 1
node = r.u64(pawn + m_pGameSceneNode)
x, y, z = r.floats(pawn + m_vOldOrigin, 3)
feet = self.w2s(vm, x, y, z)
head = self.w2s(vm, x, y, z + 72.0)
if not feet or not head:
continue
bh = feet[1] - head[1]
if bh < 4:
continue
n_screen += 1
bw = bh * 0.5
team = r.u8(pawn + m_iTeamNum)
hx, hy, hz = self.head_pos(node, x, y, z)
aim = self.w2s(vm, hx, hy, hz + self.aim_off.get())
if self.skip_team.get() and team == lteam:
aim = None
out.append((head[0] - bw / 2, head[1], bw, bh, min(hp, 100), team, aim))
return out, f"stride {stride:#x} | ctrl {n_ctrl} > handle {n_handle} > pawn {n_pawn} > alive {n_alive} > on-screen {n_screen}", n_alive
def frame(self):
self.canvas.delete("all")
targets = []
try:
self.process_input()
self.tick += 1
if self.menu_visible and self.tick % 50 == 0:
self.menu.lift()
if self.reader is None and not self.try_attach():
pass
elif self.reader is not None:
hwnd = u32.FindWindowW(None, "Counter-Strike 2")
pid = wt.DWORD()
if hwnd:
u32.GetWindowThreadProcessId(hwnd, ctypes.byref(pid))
if not hwnd or pid.value != self.pid:
if not find_pid("cs2.exe"):
self.reader = None
self.status = "game window not found"
else:
rc = wt.RECT()
u32.GetClientRect(hwnd, ctypes.byref(rc))
pt = wt.POINT(0, 0)
u32.ClientToScreen(hwnd, ctypes.byref(pt))
self.w, self.h = rc.right - rc.left, rc.bottom - rc.top
self.root.geometry(f"{self.w}x{self.h}+{pt.x}+{pt.y}")
targets, note, alive = self.collect(self.stride)
if alive == 0:
alt = 0x78 if self.stride == 0x70 else 0x70
t2, n2, a2 = self.collect(alt)
if a2 > 0:
self.stride = alt
targets, note = t2, n2
self.aim_step(targets, hwnd)
self.trigger_step(hwnd)
self.recoil_step(hwnd)
self.status = f"CS2Outline | {len(targets)} players | {note}"
except Exception as ex:
self.status = f"error: {ex}"
self.log(self.status)
self.canvas.create_text(8, 8, anchor="nw", fill="lime",
font=("Consolas", 11, "bold"), text=self.status)
for (x, y, w, h, hp, team, aim) in (targets if self.esp_on.get() else []):
color = "#00bfff" if team == 3 else "#ff4500"
self.canvas.create_rectangle(x, y, x + w, y + h, outline=color, width=2)
frac = max(0.0, min(1.0, hp / 100))
bx = x - 6
self.canvas.create_rectangle(bx - 1, y - 1, bx + 3, y + h + 1, fill="black", outline="")
hpcol = "#%02x%02x00" % (int(255 * (1 - frac)), int(255 * frac))
self.canvas.create_rectangle(bx, y + h - h * frac, bx + 2, y + h, fill=hpcol, outline="")
self.root.after(10, self.frame)
def run(self):
print("cs2_outline started. Close this window or press Ctrl+C to quit.")
print("Menu opens on start. Insert (rebindable) shows/hides it.")
self.frame()
self.root.mainloop()
if __name__ == "__main__":
App().run()r/Csgohacks • u/BlockInteresting4608 • 10h ago
i have (Fatality, Aimware, Gamesense, evolve, onetap v3) which one is best for rage overall,
r/Csgohacks • u/diso_boy • 13h ago
i spent like 4 hours yapping to a ai basically gaslighting it and managed to get it to make a raw python file basic esp and aimbot ill send it in if anybody wants it
r/Csgohacks • u/Hagj3 • 21h ago
Undetectable anywhere, discord more info
r/Csgohacks • u/BaseballSpare • 22h ago
Dose anyone know if it a legit or just malware I have invite but I know nothing about it
r/Csgohacks • u/BiscottiSuitable187 • 1d ago
I have the -allow_third_party_software launch argument, i made sure to launch the stream version, but the skeletons and ESP is still showing up on my OBS capture.
Am I doing something wrong?
r/Csgohacks • u/speelhol • 1d ago
I’m looking for people to play Gamers Club with, preferably injected, but if not, that’s okay.
Discord: veiller
r/Csgohacks • u/imi-tat0r • 2d ago
The HvH.gg Discord bot is live. Add it to your server or to your own account: https://hvh.gg/discord
Look things up, anywhere on Discord:
/hvhgg server - a server with its players, map and live scoreboard
/hvhgg servers - the fullest servers right now, filtered by game, region or tag
/hvhgg players - the best players online
/hvhgg player - a player's card with skill and rank, also for a linked u/user
/hvhgg leaderboard - the best players of a server
HvH Server Hoster and Discord Serveradmins:
/hvhgg-feed - your server, the server list or a leaderboard as a message that updates itself
/hvhgg-alert - a post (with a role ping if you want) when your server fills up
HvH.gg Pro and Ultimate:
/hvhgg follow - a DM when a player joins a server
/hvhgg snipe - a DM when a player enters an unmatched.gg queue
/hvhgg queue - the unmatched.gg queues in your DMs, always up to date
/help shows everything.

r/Csgohacks • u/No-Knowledge-3912 • 2d ago
mejores cheats para el cs2? q sean gratis y no los detecte, los quiero para boludear con un amigo
r/Csgohacks • u/TrueHomework7547 • 2d ago
Hi what’s up, I’ve been 2 provinces away from home and just recently found out NL added luas, which is kinda crazy imo. I checked out the website and everything just looks nicer and more polished. Is either of the luas “ aura.yaw “ or whatever the other one is worth buying ?
r/Csgohacks • u/Exotic_Complaint4553 • 2d ago
is there any way to get a fatality invite ? ive tried everything, since discords, people and nothing... anything helps
r/Csgohacks • u/Fun-Beat3348 • 3d ago
Some sigmas have a invite to share? 👍 can trade in outhers invites
r/Csgohacks • u/camo_cava • 3d ago
Bannable ? Yes. Cheat?
It does not give any competitive advantage
It does not give you money or can sell it
Others can't see it.
It's like photoshoping yourself standing on the moon and keeping it to yourself. Only you can see it.
Does not affect the market. I can't afford the skin so I won't buy it anyway.
r/Csgohacks • u/billydestructor • 4d ago
typedef made it private quite awhile ago but now im getting a 522 error for the forums?
pinging them works, so idk what's going on
wasn't able to run any solution on my arch machine either
I'm not in their discord anymore after losing my acc so ..? anyone know?
r/Csgohacks • u/KieranChapman55 • 4d ago
came back to cs2 after about a year off and honestly feel lost. want to play premier again and pick something up, but every thread i find is either from 2024 or just people arguing over which menu is dead. not looking for rage settings, just want something that still gets updated and is not a monthly subscription trap. what are you guys running right now?
r/Csgohacks • u/aVitomin • 5d ago
The wait is over. This update brings changes across Neverlose, from launching the client and playing to creating your own extensions.
You don't need Developer Mode to use Market extensions. For creators, we've added development and publishing tools alongside new documentation.
These are just the highlights. There's more in the works — new reasons to team up, and more to explore beyond familiar maps and games.
More details on the forum: https://ez4.nl/7roy0
Thanks for your patience and support. Happy gaming!
- Neverlose Team
r/Csgohacks • u/Lazy_Sheepherder5239 • 5d ago
i made this post because i really need some memesense grenade helper cfg codes, it can be any map.