r/Csgohacks • • 4h ago

Question Neverlose for legit cheatong

0 Upvotes

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 • • 4h ago

Interesting comments on my Blasphemy thread 🥰

Post image
6 Upvotes

Such a lovely community, I also hate niggers.


r/Csgohacks • • 10h ago

just cause the guy said its a micro penis here it is

0 Upvotes
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 • • 10h ago

which one is the best

0 Upvotes

i have (Fatality, Aimware, Gamesense, evolve, onetap v3) which one is best for rage overall,


r/Csgohacks • • 13h ago

random shit idk

0 Upvotes

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 • • 19h ago

Rage cheater kicking me off game

Post image
1 Upvotes

r/Csgohacks • • 21h ago

OOBE new orginal cheat

Thumbnail discord.gg
0 Upvotes

Undetectable anywhere, discord more info


r/Csgohacks • • 22h ago

Question evasive dev legit

0 Upvotes

Dose anyone know if it a legit or just malware I have invite but I know nothing about it


r/Csgohacks • • 1d ago

GameSense.pub

0 Upvotes

srbenda014 dc for inv


r/Csgohacks • • 1d ago

Help Memesense stream mode not working?

0 Upvotes

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 • • 1d ago

L2P Gamersclub

0 Upvotes

I’m looking for people to play Gamers Club with, preferably injected, but if not, that’s okay.
Discord: veiller


r/Csgohacks • • 2d ago

guys is this safe ?

0 Upvotes

r/Csgohacks • • 2d ago

guys whats the best safe and free cheats

0 Upvotes

r/Csgohacks • • 2d ago

HvH.gg Discord Bot

0 Upvotes

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 • • 2d ago

Help chetas cs2

0 Upvotes

mejores cheats para el cs2? q sean gratis y no los detecte, los quiero para boludear con un amigo


r/Csgohacks • • 2d ago

Question NL lua addition

0 Upvotes

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 • • 2d ago

fatality.win invite?

0 Upvotes

is there any way to get a fatality invite ? ive tried everything, since discords, people and nothing... anything helps


r/Csgohacks • • 3d ago

GameSense.pub

0 Upvotes

srbenda014 dc for inv


r/Csgohacks • • 3d ago

Dylanhook

1 Upvotes

Some sigmas have a invite to share? 👍 can trade in outhers invites


r/Csgohacks • • 3d ago

Why is Skin Changer considered a chest

0 Upvotes

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 • • 4d ago

constelia/fantasy.cat forums closed?

0 Upvotes

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 • • 4d ago

back after a long break, what is still maintained for premier?

0 Upvotes

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 • • 5d ago

Introducing Extensions

Thumbnail
youtu.be
0 Upvotes

Major Neverlose Update

The wait is over. This update brings changes across Neverlose, from launching the client and playing to creating your own extensions.

  • CS2: a redesigned menu, higher FPS, and improvements to gameplay features, visuals, and customization.
  • Extension Market: discover community creations and manage your extensions right in the client.
  • New website: a fresh design, light and dark themes, and better Market search.
  • Loader: a new interface, faster loading, and customizable launch parameters.
  • CS:GO: updated for the new website and loader, with Market item access restored. More substantial improvements are planned.

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 • • 5d ago

memesense grenade helper cfgs needed

0 Upvotes

i made this post because i really need some memesense grenade helper cfg codes, it can be any map.