Node Graph Compiler for Real-Time Graphics Development

The program enables direct machine instruction use through node graphs, enhancing code reuse and speeding up compilation.

### Building a Custom Programming Environment for Real-Time Graphics with Node Graphs
* 🎨 The developer has created a program that allows them to use machine instructions through node graphs, providing benefits like **easier code reuse** and **fast compilation times**.
* 🎓 They plan to use this tool for their Master's thesis on real-time computer graphics, aiming to **implement everything from basic arithmetic to light simulations on a graphics card** by the end of 2024.
* 📅 The developer will release a **weekly devlog series** every Wednesday at noon, starting with **technical content** before moving on to more exciting topics like **video game development**.
* 🕹 While the initial focus will be on implementing basics, the ultimate goal is to create a video game, which is the **main motivation** behind the thesis topic.
* 🧠 The program's node editor is similar to those used in game engines for shaders, but instead of GPU-optimized code, it writes **sequences of bytes to a file**.
* 🔢 The compiler works by **traversing the node graph** and outputting the resulting **byte sequence**, with **custom nodes** allowing for **easy reuse of completed work**.
* ⚙ Millisecond compilation times are achieved by **detecting changes in node inputs**, skipping recompilation when **no changes are detected**.
* 🎓 The developer will explain more about compiler usage and core mechanics in future devlogs, starting by tackling the most fundamental type of data: **integers**.

[Music] I've built a program that lets me use machine instructions directly without typing a single line of code. Instead, I can build my own abstractions using node graphs, which comes with multiple benefits such as easier code reuse and millisecond compilation times. The only downside is that I now have to implement absolutely everything from scratch. I'm not just talking about some basic utility functions here; I'm talking about concepts like the binary encoding of instructions and executable file formats. And to top it all off, I want to use this tool for my Master's thesis at the end of this year, a thesis about real-time computer graphics. So, before 2024 is over, I'll have to work my way from basic arithmetic all the way up to light simulations running on a graphics card. Perfect conditions for a weekly devlog series, if you ask me. To get started, I'll release one short video per week every Wednesday at noon. A shorter format makes consistent uploads less stressful for the next months, which also helps with faster development. The content will be very technical for now.

since I'll implement all the basics before focusing on anything more exciting. I'll obviously work on a video game eventually. It's actually the main motivation behind my thesis topic. There's no point in talking about those plans right now, so I'll get back to that once everything else is set up properly. So if you're not really interested in non-graphic stuff, I'd recommend coming back a bit later. But if you're curious how x64 instructions and the Vulkan API are used behind the scenes, this channel might be for you. Node editors are a popular choice for hiding complexity to benefit user experience. Most game engines utilize node networks to represent shaders, which are little programs that describe the appearance of a surface. They then compile the graphical representation into optimized code for the GPU. My version of such a compiler is very similar, but unlike the specific use cases other software aims for, my editor simply writes sequences of bytes to a given file. It can technically be used to build anything from image and sound files to text documents, and as I've

already mentioned I'll be using it for programming. An executable is just another sequence of bites after all, but before I dive into the first proper implementation, a surface-level introduction might help you follow along. [Music] This is a note. It has a title, a color, and an array of sockets. A socket can either be an input or an output. Inputs can have five different types, four of which allow input of a certain format. Data from other nodes can be provided to a socket through connection, which can only be created between outputs and inputs. The compiler provides built-in nodes that can be categorized into two groups: those that manipulate data and those that define a node's behavior. These built-in nodes can be used to define custom nodes, which effectively hide underlying complexity behind a simple user interface. Custom nodes can then be instantiated like any other node, allowing for easy reuse of completed work. In the end, all the actual compilation algorithm does is traverse a node graph and output the resulting bite sequence into a file. When the compiler encounters a custom node, the defining

node network is traversed recursively until the underlying built-in fixed function nodes are discovered. Since the results of built-in nodes are determined programmatically, recursive compilation eventually ends. We can achieve the millisecond compilation times mentioned earlier by determining which node inputs have changed. If no change is detected, that instance doesn't need to be recompiled, allowing us to skip a lot of work. But details about core mechanics like this are a topic for another video. I'll explain my compiler usage in other devlogs as we go along, so don't worry if this all still appears a bit confusing. So let's start by tackling the most fundamental type of data, the integer.

Writing software without a programming language

Kronark

Building a Machine Instruction Program from Scratch

The program allows for direct use of machine instructions through node graphs, offering benefits like code reuse and fast compilation.

The creator must implement everything from basic functions to complex concepts for their Master's thesis on real-time computer graphics.

A weekly devlog series will document the journey, with a focus on technical content and eventual plans for a video game.

Nodes have a title, color, and an array of sockets, which can be inputs or outputs.

Inputs have five types, with four allowing specific data formats, and connections are made between outputs and inputs.

The compiler offers built-in nodes for data manipulation and behavior definition, enabling the creation of custom nodes for easy reuse and hiding complexity.

Recursive Node Network Traversal in Compilation

The node network is traversed recursively to discover built-in fixed function nodes, with programmatic results leading to the end of recursion.

Millisecond compilation times are achieved by detecting changes in node inputs, allowing instances without changes to be skipped.

The core mechanics of this process will be discussed in future devlogs, starting with the fundamental data type: the integer.