carmack-programming

Apply John Carmack's first-principles methodology to performance-critical code.

Updated Aug 23, 2026

Search Tags:#performance #profiling #systems-programming #first-principles #memory-allocation #carmack #cache-conscious

Ready to run

npx skills add https://github.com/danielsimonjr/claude-skills --skill carmack-programming

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: carmack-programming
Source: https://github.com/danielsimonjr/claude-skills/tree/main/john-carmack-programming-skill
Command: npx skills add https://github.com/danielsimonjr/claude-skills --skill carmack-programming

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This skill helps developers adopt John Carmack's first-principles approach to building high-performance, maintainable systems.

Core Features & Use Cases

First-principles design: Understand hardware behavior, minimize abstractions, and write simple, correct code.
Performance discipline: Emphasize cache-conscious structures, data-oriented layouts (SoA), minimal branching in hot paths, and measured optimization.
Pragmatic engineering: Use unity builds, simple allocators (arena/ pools), and clear state-management patterns to reduce complexity.
Use Case: A graphics engine module implementing a cache-friendly physics step with profile-driven improvements.

Quick Start

Start by reading SKILL.md to align with Carmack's principles, then apply a simple, measurable optimization on a hot loop.

Frequently Asked Questions about carmack-programming

High-intent search queries and answers about installing and using this skill.

FAQPage Schema

How do I optimize hot loops for cache-conscious performance in systems programming?▼

Cache-conscious optimization requires data-oriented layouts like Structure of Arrays (SoA) and minimal branching in hot paths. This skill applies first-principles design to enforce profile-driven improvements through clear guidelines and worked examples.

What is first-principles programming and how does it apply to game engine components?▼

First-principles programming involves understanding hardware behavior and minimizing abstractions to write simple, correct code. For game engine components, it enforces pragmatic engineering using unity builds and simple allocators to reduce complexity.

How do I set up memory allocation for performance-critical code using arena pools?▼

Memory allocation for performance-critical code uses simple allocators like arena and pools to manage state efficiently. This approach reduces complexity and maintains performance discipline in systems programming.

Does this first-principles methodology work for general systems programming or only graphics engines?▼

The first-principles methodology applies to both general systems programming and graphics engines. It covers scope across memory management and profiling workflows, making it suitable for both learning and real projects.

What is the best way to profile and measure performance improvements in a hot path?▼

The best way to profile hot paths is through measurement-driven optimization. This skill provides profile-driven workflows and practical requirements to apply measurable optimizations, demonstrated via worked examples.

Why does minimizing dependencies matter for high-performance code?▼

Minimizing dependencies matters because it enforces first-principles design and reduces unnecessary complexity in performance-critical code. This skill enforces minimal dependencies alongside cache-conscious structures to maintain lean, fast systems.