Note: As an Amazon Associate I earn from qualifying purchases.

Starting out as a graphics programmer in 2023: My thoughts

My thoughts on starting as a graphics programmer: tools tech skills industry and future adaptation
Sid Metcalfe

Cartesian Mathematics Foundation


November 23, 2023


I began my journey in graphics programming driven by a fascination with creating stunning visual experiences. As I navigated through the complexities of rendering and real-time graphics, I discovered a world that perfectly blended art and science. The deeper I delved, the more I realized that mastering this craft demanded a robust understanding of both the math behind the pixels and the art of efficient code. With technology evolving rapidly, I learned that staying relevant meant adapting and learning continuously. Here, I’d like to share insights from my voyage into the ever-changing landscape of graphics programming, hoping to guide those who are just starting out or looking to refine their skills.


Graphics Programming Foundations and Concepts

An illustration of foundational graphics concepts such as mathematical formulas and diagrammatic representations of rendering

As I reflect on my journey into graphics programming, I find myself wrestling with a fundamental tension that many beginners encounter: the balancing act between diving deep into the nuts and bolts of rendering versus swiftly climbing the abstraction ladder. From scratch-building a software rasterizer to grappling with the minutiae of shader programming, the foundational knowledge gained from these experiences is undeniably invaluable.

Consider for a moment the educational wealth found in implementing a Bresenham’s algorithm for line drawing. Here, you’re not only programming; you’re engaging with an elegant dance of mathematics and logic. The same goes for writing a function to render a spinning cube pixel by pixel. It’s a rite of passage that offers a profound comprehension of what OpenGL or DirectX abstract away in their high-level dance with your GPU.

Yet, I must admit the drawbacks. The landscape of graphics programming in 2023 presents a steep learning curve, where the machine’s language is one of high performance and concurrency, not the straightforward pixel plotting of yesteryear. Beginners can quickly become disenchanted when the concepts they master on a CPU don’t translate to the parallel universe of modern GPU architectures.

However, the thrill of seeing your first triangle rendered on a screen you commandeer from the ground up cannot be overstated. There’s a unique sense of ownership and understanding that comes from this. This approach also instills a more robust capacity for debugging—when something goes wrong later on in your graphics programming career, you’ll have a better idea of where to look. The GitHub repository ssloy/tinyrenderer is an excellent place for any aspiring graphics programmer to grasp these foundational concepts.

But, let’s be realistic: not everyone wants to build their engine or write low-level optimization code. Thankfully, nowadays the line between creating and understanding has been somewhat blurred thanks to a mixture of open-source tools and readily-available knowledge sharing. You’ll find many of these principles and techniques discussed openly in communities like HackerNews and Reddit’s graphics programming boards.

In the context of the industry and considering tools like Unity and Unreal Engine, it’s evident that most developers will end up standing on the shoulders of giants. These giants, being engines and APIs that have abstracted the tech’s complexity, not only empower creators with less of a mathematical or low-level programming background but also significantly speed up the time from concept to production-ready graphics.

I’d argue mastering the basic concepts doesn’t necessarily trap you in a niche, but rather opens doors across various technically demanding fields—from game development to visualization and beyond. There’s a moving intersection of disciplines here, and grounding yourself in the universal language of graphics programming offers a passport to them all. At the core is an unchanging truth: whether through a game engine scripting interface or debugging a custom vertex shader, the fundamentals of putting pixels on the screen remain largely the same.

The real question for the budding graphics programmer isn’t if they should understand these foundations. It’s about the timing and the depth to which they dive before leveraging the tools that offer greater abstraction, and thus, accelerate the creative process. Balancing foundational knowledge with practical tool proficiency seems to be the most prudent path forward.

Choosing the Right Tools and Technologies

A collage showcasing various graphics programming tools like unity touchdesigner and c++

Selecting the right tools and technologies in the realm of graphics programming can seem like navigating an intricate labyrinth—there are numerous paths, some leading to swift success while others to dead ends. I’ve seen beginners eagerly jump into the latest game engines or visual effects tools only to realize they are carrying the equivalent of a Swiss Army knife to a specialized tradesman’s job. Conversely, focusing too narrowly on niche APIs or languages can leave you stranded as the tech landscape shifts.

In my journey, versatility and adaptability have been crucial. For instance, when looking at programming languages, C++ has historically been the lingua franca of graphics programming. The control it offers over hardware interactions and performance is unmatched. A strong grasp of C++ can open doors, especially in industries that prioritize performance, like gaming or simulation software. Gaming on the Steam Deck OLED: My impressions reflects on the importance of such performance in real-world applications. But it’s worth considering newer players—Rust, for example, which promises safety alongside performance, is garnering interest.

Diving into game engines, Unity and Unreal Engine dominate the scene. They’re not just tools for (game building)[]; I view them as gateways to graphics programming. They abstract away the low-level details, allowing you to craft visually stunning experiences without reinventing the wheel. However, there’s a trade-off: these abstractions can sometimes obscure what’s happening under the hood, and customizing your application beyond the engine’s default capabilities may require a deep dive into the underlying systems.

The world of web graphics is an entirely different beast. Technologies like three.js provide powerful libraries to create and display 3D content in web browsers, leveraging WebGL. For developers who want to reach a broad audience without requiring hefty downloads, it’s an attractive avenue. But it might not be ideal for applications demanding cutting-edge graphics or intricate user interactions which are better suited for standalone applications with more robust frameworks.

Honing skills in GPUs and shading languages like GLSL or HLSL can also be incredibly empowering. They afford precision control over visual output, leading to optimum performance in graphics-intensive applications. However, keep in mind that GPU programming has a steep learning curve, and it’s pivotal to stay abreast of best practices to avoid potential performance pitfalls.

In my experience, the open-source community is invaluable. Collaborating on projects hosted on platforms like GitHub not only enhances learning but also showcases your proficiency to potential employers. When you contribute to a project, or better yet, launch your own, you’re not only learning the nuts and bolts of programming but also the nuances of problem-solving in real-world scenarios.

To stay relevant, though, one must be willing to evolve. OpenGL, once the go-to API, is witnessing a gradual decline, with DirectX, Vulkan, and Metal taking the stage. This doesn’t mean you discard OpenGL from your skill set, but rather, complement it with knowledge of these newer APIs.

While it might be enticing to focus exclusively on one tool or technology, I would caution against it. Diversify your skill set: understand the principles and then learn the tools as needed. It’s about creating a balance. You want a toolbelt that’s equipped yet not excessively burdened—sophisticated enough to handle complex tasks but flexible to adapt as technologies emerge. The right tool for the job can frequently change; the readiness to learn and adapt should not.

Building Practical Skills and Creating Output

Screenshots of simple to complex graphical outputs created by a beginner

Navigating the journey to becoming a graphics programmer often feels like navigating a labyrinth, full of interconnected pathways, each offering a different facet of the expansive world of graphics. When I started on this path, I quickly realized that building practical skills and creating output were central to success in this niche field. I’ll share my insights on this process, having walked the labyrinth myself.

My early exploration taught me that understanding abstract concepts could only take you so far; it’s the application of knowledge through practical projects that cements your learning. In graphics programming, particularly, the leap from theory to practice can be vast. I found that starting with small, tangible projects not only helped me establish a strong foothold but also kept me motivated. Tasks like rendering a simple shape on the screen felt enormously rewarding and provided the drive to tackle increasingly complex challenges.

One critically important aspect I discovered was that graphics programming is as much about problem-solving and optimization as it is about mathematics and algorithms. You don’t need to write an engine from scratch to grasp these concepts. Instead, I leaned on existing game engines like Unity and Unreal Engine, which allowed me to focus more on the creative side of graphics while still understanding the underlying mechanics. This hands-on experience with high-level tools was invaluable for building a portfolio that could open doors in the industry.

The practical skills I gained from working with these engines did have some drawbacks, though. Getting comfortable with high-level abstractions sometimes made it daunting to delve into lower-level programming when the need arose. Furthermore, job listings often require knowledge of specific tools, and my experience differed from these prerequisites on occasion.

Despite these challenges, a key realization dawned on me: in modern graphics programming, adaptability is paramount. While specializing in a particular API or toolset can be career-limiting, as some Reddit and Hackernews discussions I’ve combed through point out, an adaptable skill set underpinned by solid principles can prepare you for the future. It’s much like GitHub repos that evolve over time — the foundations remain, but the implementation adapts to new technologies and standards.

Today, when stackoverflow comes up with discussions around new techniques like wavefronts or hardware-driven optimizations, I confidently contribute, wielding both high-level insights from Unity scripting and the low-level understanding gleaned from my early forays into C++ and OpenGL. This dual understanding has served me well.

Another valuable lesson centered around community and open-source contributions. Platforms like GitHub are gold mines for pushing practical boundaries. Contributing to projects introduced me to industry veterans and kept me updated on cutting-edge practices. It’s awe-inspiring to see real-world applications of graphics programming across diverse fields like VR, scientific visualization, and interactive media.

In sum, while laying a strong theoretical foundation in graphics programming is crucial, I advocate for an immediate dive into practical development. Start with well-defined objectives: build something, learn through the experience, and iterate. From scripting in game engines to delving into algorithm optimizations, practical involvement ensures your growth as a modern graphics programmer. The obstacles encountered along the way? They form the stepping stones to a versatile, ever-evolving career in this dynamic field.

Understanding the Modern Graphics Pipeline

A flowchart depicting the stages of the modern graphics pipeline from application code to pixel rendering

Understanding the nuances of the modern graphics pipeline is crucial for any aspiring graphics programmer. I’ve been through the trenches of learning graphics programming and can attest to the value of knowing what happens under the hood, even if your day-to-day doesn’t require it.

Starting with raw, low-level APIs such as OpenGL or Vulkan can be daunting. I remember when I first dabbled in OpenGL, piecing together the complex jigsaw of buffers, shaders, and state management was overwhelming. However, the understanding I gained from it was immense. Learning about vertex buffers, index buffers, and the various shader stages led me to grasp what modern GPUs are optimized for and why certain practices lead to better performance. For those looking for hands-on learning, and Vulkan Tutorial are fantastic resources.

It’s important to note that modern graphics APIs are less forgiving than their predecessors. Vulkan, for example, assumes you know exactly what you’re doing, offering minimal hand-holding. This approach can improve efficiency but may initially slow down the learning process.

High-level tools like Unity and Unreal Engine are often debated in learning circles. I’ve seen arguments that these tools abstract away too much, potentially restricting deeper learning. My experience, though, is that they provide a simpler entry point into graphics programming. They let you see results quickly, which is motivating. Then, as you grow more curious, you can dive into the lower levels at your own pace. Unreal Engine’s source available on GitHub, for example, is a gold mine for anyone ready to go beyond blueprint scripting.

Shader languages, despite being high-level, still require a solid understanding of the graphics pipeline. I highly recommend The Book of Shaders ( for those wishing to learn GLSL. This site helped me develop a nuanced appreciation for GPU programming, and creating visual effects became far more intuitive.

A major drawback of starting at a lower level is the time commitment. Balancing the intricacies of API calls, buffer management, and shader debugging can detract from actual content creation, which is often the goal for many graphics programmers. Plus, as the first commenter explained, industries vary greatly in their tech stack requirements, and being overly specialized can be limiting.

On the positive side, the skills you develop can be highly transferable. As the third commenter mentioned, graphics principles can pivot nicely into fields like AI through GPU compute shaders. Indeed, many core concepts like parallelism and efficient data structures are applicable across cutting-edge tech fields.

In retrospect, grappling with the details of the graphics pipeline has made me a more adaptable developer. Yes, it’s a niche, with its own learning curve and set of challenges, as a few commenters pointed out. But this is technology we’re talking about - it’s constantly evolving, and so must we.

For those daunted by the thought of diving into low-level graphics programming, I recommend starting with higher level tools and working your way down. This way, you gradually build a comprehensive understanding of the pipeline without feeling overwhelmed. Remember, the goal is not just to become a coding machine but a creative problem solver who truly understands the machinery of graphical representation.

Future-Proofing Your Skills in a Changing Landscape

An evolving landscape imagery with visual metaphors for adaptation and growth

In pivoting towards a career in graphics programming, I’ve come to realize that durability in this field hinges on a mix of core skills and the flexibility to ride the waves of technological change. The graphics programming landscape is both vast and morphing swiftly, churning out new tools and APIs at a breakneck pace. The perennial question I used to grapple with was whether deep diving into one technology would pigeonhole my career or open up new horizons.

Deliberating on the best approach, I can say with a measure of confidence that the answer isn’t straightforward. There’s certainly merit to specializing; it’s undeniable that depth in a particular area, be it Vulkan, Direct3D, or OpenGL, can set you apart. However, specializing also runs the risk of obsolescence—just look at OpenGL’s waning popularity in the wake of modern graphics APIs. That said, the core principles gleaned from any of these APIs do carry over and can be foundational in understanding new platforms.

I’ve observed that broad technical adaptability, rather than singular expertise, often steers a sustained career trajectory. Mastery in a specific technology is temporary; the real craft consists in the capacity to assimilate new ones rapidly. The developers I’ve met who had transitioned seamlessly from 3D graphics to GPU compute for AI tasks confirmed this. Their underlying knowledge about hardware realities and performance optimization was translatable and valued across sectors.

In my journey, the importance of building a strong mathematical foundation became clear. It’s essential for digesting concepts that permeate the graphics world, from simple linear transformations to complex shading algorithms. Universities like MIT and Stanford offer open courseware that’s been tremendously helpful in strengthening these areas. Moreover, participating in community-driven projects, such as those found on GitHub, provided practical experience and exposure to different coding styles and problem-solving approaches.

Nevertheless, I can’t discount the drawbacks. Broadening one’s skill set can feel like skirting the surface, leading to the dreaded ‘jack of all trades, master of none’ scenario. Focusing too much on generalization may inhibit the depth of challenge that comes with specialization, leading to a plateau in problem-solving sophistication.

As I conclude, my advice to those entering the field is to uphold curiosity and a learner’s mindset above all else. Chart a course that balances specialized knowledge with a breadth of experience. Aim to understand the why behind the tools and technologies you use, and when it comes time to adapt, you’ll find the undercurrents of change are less a riptide to resist and more a new current to ride. Remember that at its core, graphics programming is about creating and optimizing visuals; maintaining a panoramic view of technologies and industry trends will ensure you remain an asset no matter where your career takes you. Keep abreast of industry news through forums, and don’t forget the wealth of knowledge available in research papers—sites like arXiv and Google Scholar are my go-to for the latest in academic findings.

In the rapidly evolving domain of graphics programming, the only surefire investment is in oneself—your ingenuity, adaptability, and unending inquisitiveness are what will future-proof your place in this exciting field.