CS2 Aimbot Development Guide 2026 — Silent Aim, Bone Selection & Smoothing

Building an aimbot for Counter-Strike 2 requires deep understanding of the Source 2 engine, its entity system, and the networking layer. This guide covers everything from reading player bones to implementing silent aim — the technique that makes your aimbot invisible to spectators.

Source 2 Entity System Overview

CS2 uses a completely different entity system from CS:GO. The key classes you need to understand:

• CCSPlayerController — The player controller entity (contains m_hPlayerPawn, m_sSanitizedPlayerName)
• CCSPlayerPawn — The actual player pawn with position, health, bones
• CGameSceneNode — Scene graph node containing transform data (m_vecAbsOrigin)
• CSkeletonInstance — Bone data for the player model

Getting Player Pawns

// Read the entity list from CGameEntitySystem
uintptr_t entityList = mem.Read<uintptr_t>(client + offsets::dwEntityList);

// Each controller is at index * 0x78 in the entity list chunks
uintptr_t listEntry = mem.Read<uintptr_t>(entityList + 0x8 * (idx >> 9) + 0x10);
uintptr_t controller = mem.Read<uintptr_t>(listEntry + 0x78 * (idx & 0x1FF));

// Get the pawn handle from the controller
uint32_t pawnHandle = mem.Read<uint32_t>(controller + offsets::m_hPlayerPawn);

// Resolve the pawn handle to actual pawn address
uintptr_t pawnEntry = mem.Read<uintptr_t>(entityList + 0x8 * ((pawnHandle & 0x7FFF) >> 9) + 0x10);
uintptr_t pawn = mem.Read<uintptr_t>(pawnEntry + 0x78 * (pawnHandle & 0x1FF));

Reading Bone Positions

CS2's skeleton system is accessed through CSkeletonInstance, which is part of the game scene node hierarchy:

// Get the game scene node
uintptr_t gameSceneNode = mem.Read<uintptr_t>(pawn + offsets::m_pGameSceneNode);

// Get bone array from the skeleton instance
uintptr_t boneArray = mem.Read<uintptr_t>(gameSceneNode + offsets::m_modelState + 0x80);

// CS2 bone indices (Source 2 skeleton)
enum BoneIndex {
    HEAD = 6,
    NECK = 5,
    SPINE_1 = 4,
    SPINE_2 = 2,
    PELVIS = 0,
    LEFT_SHOULDER = 8,
    RIGHT_SHOULDER = 13,
    LEFT_HAND = 11,
    RIGHT_HAND = 16,
    LEFT_KNEE = 23,
    RIGHT_KNEE = 26,
};

// Each bone is a 32-byte structure (position at offset 0)
struct BoneData {
    Vector3 position;  // 12 bytes
    float scale;       // 4 bytes
    // ... rotation quaternion follows
};

Vector3 headPos = mem.Read<Vector3>(boneArray + HEAD * 32);

Angle Calculation

Once you have the target bone position, calculate the aim angles:

Vector3 CalcAngle(const Vector3& src, const Vector3& dst) {
    Vector3 delta = dst - src;
    float hyp = sqrt(delta.x * delta.x + delta.y * delta.y);

    Vector3 angles;
    angles.x = -atan2f(delta.z, hyp) * (180.0f / M_PI);  // pitch
    angles.y = atan2f(delta.y, delta.x) * (180.0f / M_PI); // yaw
    angles.z = 0.0f;
    return angles;
}

// Get local player eye position
Vector3 eyePos = localPawnPos + mem.Read<Vector3>(localPawn + offsets::m_vecViewOffset);
Vector3 aimAngles = CalcAngle(eyePos, targetBonePos);

Silent Aim — The Invisible Technique

Silent aim is the most advanced aimbot technique. Instead of visibly moving your crosshair, it manipulates the view angles sent to the server via the CreateMove function, while leaving your local view unchanged.

// Hook CreateMove to intercept user commands
void __fastcall hkCreateMove(CCSPlayerController* pController, CUserCmd* pCmd) {
    // Call original first
    oCreateMove(pController, pCmd);

    // Only modify when attack button is pressed
    if (!(pCmd->buttons & IN_ATTACK)) return;

    // Find best target within FOV
    int bestTarget = GetBestTarget(pCmd->viewangles, settings.fov);
    if (bestTarget == -1) return;

    // Calculate angle to target's head
    Vector3 aimAngle = CalcAngle(GetEyePos(), GetBonePos(bestTarget, BONE_HEAD));

    // Apply recoil compensation
    Vector3 aimPunch = mem.Read<Vector3>(localPawn + offsets::m_aimPunchAngle);
    aimAngle -= aimPunch * 2.0f;

    // Modify the command angles (server-side only)
    pCmd->viewangles = aimAngle;
    // Local view remains unchanged — spectators see nothing
}

Smoothing for Legit Play

If you're not using silent aim and want visible aiming that looks natural, smoothing is essential:

Vector3 SmoothAngle(const Vector3& current, const Vector3& target, float factor) {
    Vector3 delta = target - current;

    // Normalize angles
    if (delta.x > 180.f) delta.x -= 360.f;
    if (delta.x < -180.f) delta.x += 360.f;
    if (delta.y > 180.f) delta.y -= 360.f;
    if (delta.y < -180.f) delta.y += 360.f;

    // Apply smoothing with randomization for anti-detection
    float randomFactor = factor + ((rand() % 100) / 100.0f * 2.0f - 1.0f);
    return current + delta / randomFactor;
}

Recommended Aimbot Settings for CS2