C++ Domain Tracks
C++ is used differently in each domain. These tracks go beyond the language — into the idioms, libraries, constraints, and trade-offs that define professional C++ work in each field.
C++ powers every major game engine. Learn Unreal Engine architecture, Entity-Component-System (EnTT, flecs), cache-friendly data layouts, and how real-time budget constraints shape every design decision.
- Unreal Engine C++ deep dive
- ECS with EnTT and flecs
- Frame budget & profiling
- Asset streaming & memory
- Custom allocators for game loops
High-frequency trading demands sub-microsecond latency. Explore lock-free data structures, CPU cache optimization, kernel bypass networking (DPDK, RDMA), NUMA awareness, and latency measurement.
- Lock-free queues & ring buffers
- Cache line alignment & false sharing
- DPDK & kernel bypass
- Custom allocators (pool, arena)
- Latency measurement & jitter
C++ on microcontrollers and safety-critical systems. Freestanding implementations, MISRA-C++ compliance, RTOS integration (FreeRTOS, Zephyr), deterministic timing, and zero-overhead abstractions.
- Freestanding C++ (no stdlib)
- MISRA-C++ rules & rationale
- RTOS integration patterns
- Interrupt-safe data structures
- Static analysis for safety
Modern GPU programming from first principles. Vulkan/DX12 explicit APIs, render graph architecture, bindless resources, GPU-driven rendering, shader compilation pipelines, and real-time ray tracing.
- Vulkan from scratch
- Render graph design
- Bindless resources & GPU-driven
- Real-time ray tracing (DXR/VKR)
- Multi-threading the GPU pipeline
Maximum compute throughput for simulations, machine learning infrastructure, and numerical methods. SIMD vectorization, parallel patterns (OpenMP, MPI), GPU computing (CUDA/SYCL), and performance portability.
- Vectorization & intrinsics
- OpenMP parallel patterns
- CUDA C++ programming
- Performance portability (Kokkos)
- Numerical stability & precision
C++ is the runtime for most ML inference. Learn how libtorch, ONNX Runtime, TensorRT, and GGML work under the hood, and how to integrate, optimize, and deploy ML models in C++ applications.
- ONNX Runtime C++ API
- TensorRT inference pipelines
- GGML / llama.cpp internals
- Quantization & model optimization
- Custom operator authoring
Writing software that talks directly to hardware and the OS. Kernel module patterns, device driver architecture, IPC mechanisms, syscall wrappers, and memory-mapped IO.
- Memory-mapped IO & DMA
- IPC: pipes, shared memory, sockets
- Kernel/userspace interfaces
- Atomic operations & memory ordering
- Signal handling & async-signal-safety
High-performance networking in C++. Asio (Boost + standalone), io_uring for Linux, zero-copy transfers, async/await patterns for network I/O, and building custom protocol stacks.
- Asio async model deep dive
- io_uring (Linux 5.1+)
- Zero-copy with splice/sendfile
- Coroutine-based networking (C++20)
- Custom protocol implementation
Real-time audio has the strictest latency requirements of any domain. Lock-free audio thread patterns, JUCE framework, VST/AU plugin development, DSP algorithm implementation, and deterministic memory allocation.
- Lock-free audio thread patterns
- JUCE framework deep dive
- VST3 / AU / CLAP plugins
- Real-time DSP algorithms
- Audio graph architecture
C++ in robotics: ROS2 architecture and patterns, real-time control loops, sensor fusion with Eigen, motion planning, and the intersection of safety-critical systems and autonomous decision-making.
- ROS2 C++ (rclcpp) patterns
- Real-time control loops
- Sensor fusion & Kalman filters
- ROS2 lifecycle nodes
- DDS / Fast-DDS internals
Writing secure C++ code and integrating cryptographic primitives. OpenSSL / libsodium APIs, TLS implementation, fuzzing with libFuzzer/AFL++, memory hardening techniques, and C++26 safety profiles.
- TLS with OpenSSL / BoringSSL
- libsodium for modern crypto
- Fuzzing with libFuzzer
- Memory hardening (C++26 profiles)
- Secure coding patterns
How browsers are built with C++. Chromium/Blink/V8 architecture, garbage-collected C++ (Oilpan), JIT compilation patterns, multi-process architecture, and the Mojo IPC system.
- Chromium multi-process model
- V8 JIT compilation
- Oilpan GC in C++
- Mojo IPC system
- Blink rendering pipeline
More domains coming
Each track is actively being built out with deep-dive articles, code examples, and library guides. Domains are prioritized by traffic and community requests — game dev, HFT, and embedded ship first.