
This is a comprehensive collection of resources for the complete game development pipeline. These tools work together to create modern games - from 3D modeling in Blender, to texturing in Substance Painter, to final implementation in Unreal Engine.

## 🎮 Unreal Engine

### Getting Started & General Resources

- [Ari's UE Notes](https://flassari.notion.site/Ari-s-Unreal-Engine-Notes-1a75e43f4014464984d4fae0617e5cef)
- [SylarAtomic UE Notes](/posts/sylaratomic-unreal-engine-notes)
- [Epic's C++ Coding Standard](https://dev.epicgames.com/documentation/en-us/unreal-engine/epic-cplusplus-coding-standard-for-unreal-engine?application_version=5.3)
- [Unreal Garden - UI Focused](https://unreal-garden.com/)

### Tutorials & Courses

- [UE5 Blueprints Course](https://www.udemy.com/share/1024Wa3@wtuI16mQlHc9Bm0bsjU-Yxgln6p1dJF7htUVgEAv6_VUErLaF9hCNjmTlvT71Cg6/)
- [UE5 C++ Course (GameDev.tv)](https://www.udemy.com/share/101XRs3@CrJ05jIFZIEEKcJtUDa6sPXHheknza0Ly2sLsmVpQ2XdAbB7C4tuaHgMw8vsG8HG/)
- [UE5 C++ Course (Alternative)](https://www.udemy.com/share/107vg03@uUbSFTAyEBDs6__rWjtRINa_U_W1PyrK1dZDrFD0J-Fhdsw5AwiqKlOWQZJMnI14/)

### Advanced Topics

- [Multithreading in UE5](https://inoland.net/unreal-engine-5-multithreading/)
- [HTTP JSON Requests](https://www.tomlooman.com/unreal-engine-async-blueprint-http-json/)
- [CVAR System](https://www.youtube.com/watch?v=dj4kNnj4FAQ&ab_channel=UnrealEngine)

> **💡 Pro Tip:** Start with Unreal Engine basics, then gradually incorporate 3D modeling (Blender) and texturing (Substance Painter) as your projects become more complex. These tools form a powerful pipeline for modern game development!

### Visual Effects & UI

**Niagara (VFX)**

- [RedefineFX Channel](https://www.youtube.com/@RedefineFX)

**User Interface**

- [UMG Layouts Tips and Tricks](https://joyrok.com/UMG-Layouts-Tips-and-Tricks)
- [Game UI Database](https://www.gameuidatabase.com/)

**UI Icons & Assets**

- [Game Icons](https://game-icons.net/)
- [Kenney](https://kenney.nl/assets/)

---

## 🎨 3D Modeling & Animation

### Blender - General

- [Essential Blender Addons](https://www.youtube.com/shorts/_koEQejv4t8)

### Blender - Rigging & Animation

- [Rigging for Impatient People](https://www.youtube.com/watch?v=DDeB4tDVCGY&ab_channel=JoeyCarlino)
- [Complete Rigging Playlist](https://www.youtube.com/watch?v=m-Obo_nC3SM&list=PLzg4_2BrWAVwkQvVPJoNaXNN4dXY0Xjkl&ab_channel=JoeyCarlino)

**Rigging Series:**

- [Part 1: Rigging Basics](https://www.youtube.com/watch?v=vZaNZhAoMts)
- [Part 2: Advanced Rigging](https://www.youtube.com/watch?v=ZkAk-GYpcvs)
- [Part 3: Rigging Workflow](https://www.youtube.com/watch?v=HjGOeg2PO8Q)
- [Part 4: Final Techniques](https://www.youtube.com/watch?v=6BUgz7Lr1Ig)

### Blender - Specialized Tools

**Texturing**

- [Blender Texturing Tutorial](https://www.youtube.com/shorts/noInRltAsXo)

**Hard Ops**

- [Hard Ops Workflow](https://www.youtube.com/watch?v=vfxG9c2Ogow&t=1443s&ab_channel=JoshGambrell)

**Geometry Nodes**

- [Erindale's Geo Nodes Series](https://www.youtube.com/watch?v=xBM4BPpfbUg&list=PLVm7O9OzjT6EIDtFGC67QxGsHkz3_RbIw&ab_channel=Erindale)

---

## 🖌️ Texturing & Materials

### Substance Painter

- [Substance Painter Complete Guide](https://www.youtube.com/watch?v=d9hHn1Dk0us&ab_channel=ProductionCrate)

---

## 💻 Programming

### C++

- [C++ Cheat Sheet PDF](https://hackr.io/blog/cpp-cheat-sheet-pdf)

---

## 🤖 AI & Machine Learning

### AI for Game Development

- [Deep Reinforcement Learning Course](https://huggingface.co/learn/deep-rl-course/unit4/hands-on)
- [3D AI Generation Tool](https://hyperhuman.deemos.com/)

### Machine Learning Resources

- [Machine Learning Course (freeCodeCamp)](https://www.youtube.com/watch?v=i_LwzRVP7bg&ab_channel=freeCodeCamp.org)
- [Data Science with Python](https://www.youtube.com/watch?v=29ZQ3TDGgRQ&ab_channel=DataProfessor)
- [ML in 100 Seconds](https://www.youtube.com/watch?v=PeMlggyqz0Y&ab_channel=Fireship)

---

## 🌱 Environment

- [Mr. Hollt](https://www.youtube.com/@MrHollt)
- [UNF Games](https://www.youtube.com/@unfgames)

---

## 🌍 Localization & Tools

### Translation

- [Game Translation Spreadsheet Template](https://docs.google.com/spreadsheets/d/17f0dQawb-s_Fd7DHgmVvJoEGDMH_yoSd8EYigrb0zmM/edit?gid=310116733#gid=310116733)

---

## 🎥 Recommended YouTube Channels

- [TheRoyalSkies](https://www.youtube.com/@TheRoyalSkies)
- [CodeLikeMe](https://www.youtube.com/@CodeLikeMe)
- [Unreal Sensei](https://www.youtube.com/@UnrealSensei)
- [Gorka Games](https://www.youtube.com/@GorkaGames)
- [Mr. Hollt](https://www.youtube.com/@MrHollt)
- [UNF Games](https://www.youtube.com/@unfgames)

---

## Other

### Git

- [Learn Git Branching](https://learngitbranching.js.org/)


Game Development Learning Resources


This is a collection of Game Dev notes I've made along my journey. I hope they provide you with some good knowledge. I'll try to keep this updated the best I can.

## Start with Blueprints

If you are starting out with Unreal Engine, **start with Blueprints**. Please don't get sucked into the whole Blueprint vs C++ debate. It should never be looked at as Blueprint vs C++ but rather **Blueprints AND C++**. Best practice dictates using them both.

> **Important:** You can release games with Blueprints only!

Take a look at these examples:

- **Born of Bread** - A Paper Mario-inspired RPG made entirely with Blueprints
- **CIRCULATION** - A puzzle-platformer built primarily with Blueprints
- Many indie games being released on Steam using Blueprint-only workflows

So when starting out, start with Blueprints, figure out how to use them and what their role is.

## My Learning Recommendations

### 1. Start with Blueprints

[Game Dev TV's Blueprint Course](https://www.udemy.com/course/unrealblueprint/) on Udemy is fantastic for getting you up and running with the engine. They keep their courses updated with each new engine version.

### 2. Add C++ Later

If you feel you want to explore the C++ side, and get a better understanding of how to use Blueprints WITH C++, check out [Game Dev TV's C++ Course](https://www.udemy.com/course/unrealcourse/). It goes over all the basics.


Getting Started With Unreal Engine 5


https://github.com/codecrafters-io/build-your-own-x



https://www.potion8.com/post/some-info-on-editing-scalability-settings-in-ue5

Dev Resources


## C++

Unreal Engine programming is done with C++, therefore it is important to have some C++ notes.
I found the C++ Cheat Sheet from Hackr.io is a great start.

- [C++ Cheat Sheet](https://hackr.io/blog/cpp-cheat-sheet-pdf)

## Ari's Unreal Engine Notes

If you haven't heard about Ari, Ari is an Evangelist at Epic Games. He is EPIC ;-) (See what I did there?)
Ari has a set of notes for Unreal Engine and is where I got the idea to start making my own set.

- [Ari's Unreal Engine Notes](https://flassari.notion.site/Ari-s-Unreal-Engine-Notes-1a75e43f4014464984d4fae0617e5cef)

Make sure to also check out Ari's website [https://ari.games](https://ari.games). He has a wealth of industry knowledge and his vidoes are always full of passion and enthusiasm!

## Sylar's Unreal Engine Notes

Below you will find all my notes that I have made along my way. Just as Ari did for me, I would like to encourage you to make your own notes!

### Root Component

Every class that inherits from Actor has a _Root_ component already set up called _RootComponent_
Items can be attached to this by calling

```cpp
BaseMesh->SetupAttachment(RootComponent);
```

### Forward Declaring

In the _.h_ file, you forward declare by using the _class_ specifier.

```cpp
class USpringArmComponent* SpringArm;
```

Forward declaring is a way of telling the compiler about a class or function without declaring it in the header file. You want to do this for two reason, to prevent circular dependencies and reduce compile times.
Circular dependecies is when you have Class A that depends on Class B, Class B that depends on Class A and the compiler may not be able to compile the code as it can get stuck trying to always include the other file.
Forward declaring is to reduce compile times and the overall header file size.
For more information, have a look at the excellent video by _Mike Stevanovic_ [Unreal Engine C++ Guide - Forward Declarations](https://www.youtube.com/watch?v=sMKDZaszGEM)

### Casting

Casting is when you need to convert a data type from one type to another. Essentially, you have an object, but you want to call a function on its base object (The object it was derived from).

```cpp
ATank* Tank;
Tank = Cast<ATank>(UGameplayStatics::GetPlayerPawn(this, 0);)
```

```cpp
UPROPERTY()
```

### Unreal Engine C++: Macros and Reflection System

UCLASS() is a macro that declares the class as a UObject-derived class.

GENERATED_BODY() generates the necessary boilerplate code for the reflection system.

UPROPERTY(...) is a macro that declares a property with various attributes, making it visible in the UE4 editor and usable in Blueprints.

UFUNCTION(...) is a macro that declares a function with various attributes, making it callable from Blueprints.

#### UPROPERTY Macro

When working with variables inside C++ header files: If you want a variable to be declared during the Constructor and keep its variable for use later on, make sure to give it the UPROPERTY Macro.

### Spawning and attaching an Actor to another Actor

```cpp
    UPROPERTY(EditDefaultsOnly, Category = "Window Scenes")
    TSubclassOf<class AWindowActor> WindowActors_ThreeBots;

    UPROPERTY()
    AWindowActor* CurrentWindowActor;
```

```cpp
// Spawn the actor
CurrentWindowActor = (AWindowActor*) GetWorld()->SpawnActor(WindowActors_ThreeBots);

// Attach to Actor Root
CurrentWindowActor->AttachToComponent(Root, FAttachmentTransformRules::KeepWorldTransform);
```

The AWindowActor is the C++ class, and WindowActors_ThreeBots is the BP class derived from the C++ class. Make sure in the BP Class that DefaultSceneRoot is set to Movable!

AttachToComponent returns a bool value. This is useful for checking that the attach was sucessful.

Alternatively, make sure to set DefaultSceneRoot to moveable in the constructor:

```cpp
    // Get the DefaultSceneRoot component of the child actor
    USceneComponent* DefaultSceneRoot = ChildActor->GetRootComponent();


    // Set the mobility of the DefaultSceneRoot to movable
    DefaultSceneRoot->SetMobility(EComponentMobility::Movable);
```

### Characteristics of Delegates

Type-Safety: Delegates are type-safe, meaning that they can only reference functions that have a matching function signature (i.e., the same parameters and return type).
Parameters: Delegates can have parameters, allowing you to pass data to the functions they call.
Binding: You "bind" a function to a delegate, associating that function with the delegate so that it will be called when the delegate is executed.
Multicast Delegates: These are special kinds of delegates that can have multiple functions bound to them, calling all bound functions when the delegate is executed.

### Texture Streaming Pool Over Budge

1. Open the console in Unreal Engine
2. Type "r.Streaming.PoolSize 0"
   This will set the streamin pool size to use all avaiable VRAM, alternatively you can set it to a specific number such as 8000 (number is in mb)

### Profiling

- Unreal Insights - Used for _CPU_
- GPU Visualizer - Used for _GPU_

#### Stat Commands

Frame Rate: stat fps
More GPU Info: stat unit
Temporal Super Resolution: stat tsr - TSR Feed - Number of pixels per second being feed into TSR - TSR 12spp - Convergence rate
GPU statistical display: stat gpu

#### Stat Units

UI: Hamburger -> Stat -> Engine -> Unit
Console: stat unit

### Short Cuts

Open CPU profiling:
_Ctrl + Shift + ,_

Show FPS (stat fps):
_Ctrl + Shift + H_

Search for files (BP_Building) or types ('Static Mesh):
\*Ctrl + P\*

Opens Content Drawer:
_Ctrl + SpaceBar_

Open GPU Visualizer:
_Ctrl + Shift + ,_

#### Blueprints

Some text before the table.

| Action     | Shortcut        |
| ---------- | --------------- |
| Straighten | _Q_             |
| Left       | _Shift + A_     |
| Right      | _Shift + D_     |
| Top        | _Shift + W_     |
| Bottom     | _Shift + S_     |
| Centre     | ALT + Shift + S |
| Middle     | ALT + Shift + W |

Some text after the table.

| Month    | Savings |
| -------- | ------- |
| January  | $250    |
| February | $80     |
| March    | $420    |

adawd

### Miscellaneous

[Coding Principles](https://sylaratomic.com/posts/coding-principles-to-write-better-code) by SylarAtomic


SylarAtomic's Unreal Engine Notes


World
https://dev.epicgames.com/community/learning/tutorials/1GYl/unreal-engine-using-geometry-script-and-blueprints-to-quickly-replace-cesium-tiles

Resources
https://benui.ca/

Unreal Engine Community Tutorials


# Coding Principles

### Introduction

This serves as some of the tips I use when writing code, even when working by myself.

_Coding Principles_ can be broken up into two parts: _Coding Standards_ and _Coding Best Practices_.

_Coding Standards_ are a set of guidelines and rules that define how something should be written within a particular organisation. This can be enforced through tools such as linters or code reviews.

_Coding Best Practices_ are a set of recommended practices that are generally accepted as being the most effective or efficient way to write code. They are not necessarily enforced like coding standards, but they are widely used and recommended to improve the quality of code.

_For example_, a coding standard might require all functions to have a specific naming convention, while coding best practice might recommend using functions that are small and focused, with a single responsibility.

Overall, your code should be easy to read and understand, both for yourself and for others who may need to work with it in the future. This means using descriptive variable and function names, commenting your code where necessary, and following consistent formatting and style conventions.

## Coding Standards

These help make the code more readable, consistent and maintainable.

- **Naming conventions:** Names of variables, functions, and classes should be meaningful and follow a consistent naming convention. For example, use camelCase for variable names and PascalCase for class names.
- **Indentation:** Code should be properly indented to make it easier to read and understand.
- **Commenting:** Code should be adequately commented to explain its purpose and how it works. Comments are a great way of explaining your thought process and why you are doing it this way. It can also be used to provide additional relevant information. Avoid obvious comments such as explaining an if statement if it is obvious what it's doing.
- **Error handling:** Code should handle errors gracefully and have appropriate error messages.
- **Formatting:** Code should be formatted consistently, such as using a consistent number of spaces for indentation or using consistent line breaks.
- **Performance consideration:** Code should be written with performance in mind, such as avoiding unnecessary loops and optimising data structures.
- **Security considerations:** Code should be written with security in mind, such as avoiding SQL injection attacks and properly handling user authentication.
- **Version control:** Code should be properly managed using version control tools.

## Coding Best Practices

### DRY

DRY follows the principle of Don’t Repeat Yourself (DRY). This advises developers to minimise the duplication of code in their projects. This can be achieved by creating reusable functions of components that can be utilised in multiple sections of the codebase. By following this approach, developers can increase efficiency and reduce errors in their code. Use the rule of 3: if you copy and paste 3 times or more, use a function instead.

### Code Formatting

Use Consistent formatting [Prettier VS Code](https://marketplace.visualstudio.com/items?itemName=esbenp.prettier-vscode). This helps keep the code cleaner and easier to read. Use our predefined modular, we don’t want one person using 2-tab space and another using 4. With inconsistent tab space errors, it can be a nightmare to keep track of code changes because committing a single line could reformat the entire document.

### Functions

Break code into small, manageable functions. Functions should do one thing and do it well and should be as small as possible to make them easier to read, understand and test.

### Documentation

Document as you Code (DAC) This will help other programmers understand your code and make it easier to maintain.

### Version Control

This keeps track of changes to your code, and it will also make it easy to revert to a previous version if a mistake is made. A general rule for what goes into Version Control: anything made by humans such as code, images or small data (Big amount of data go into Databases). Anything that gets generated (sometimes in a folder prefixed with “.” such as “.next” ,”.vs” “.firebase”), gets ignored from being tracked by version control.

## Specific Coding Standards

- [Unreal Engine](https://dev.epicgames.com/documentation/en-us/unreal-engine/epic-cplusplus-coding-standard-for-unreal-engine?application_version=5.3)
- [C++](https://www.scaler.com/topics/cpp/cpp-coding-standards/)
- [JavaScript](https://developer.wordpress.org/coding-standards/wordpress-coding-standards/javascript/)
- [Python](https://docs.python-guide.org/writing/style/)

## Conclusion

Coding best practices are essential for writing high-quality code that is effective, efficient, and maintainable.
While it may take more time and effort to write code that adheres to these best practices, the benefits in terms of code quality, maintainability, and team productivity are well worth it. By making a commitment to coding best practices, developers can create code that is reliable, scalable, and future proof.


Coding Princiles To Write Better Code


UCLASS() is a macro that declares the class as a UObject-derived class.
GENERATED_BODY() generates the necessary boilerplate code for the reflection system.
UPROPERTY(...) is a macro that declares a property with various attributes, making it visible in the UE4 editor and usable in Blueprints.
UFUNCTION(...) is a macro that declares a function with various attributes, making it callable from Blueprints.

Characteristics of Delegates in UE4:
Type-Safety: Delegates are type-safe, meaning that they can only reference functions that have a matching function signature (i.e., the same parameters and return type).
Parameters: Delegates can have parameters, allowing you to pass data to the functions they call.
Binding: You "bind" a function to a delegate, associating that function with the delegate so that it will be called when the delegate is executed.
Multicast Delegates: These are special kinds of delegates that can have multiple functions bound to them, calling all bound functions when the delegate is executed.

More Unreal Engine


### The Problem
While working on my flappy bird remake (Rocket Robot), I came across a problem. The problem was that I need to have pillars at different heights but I was using the same mesh for each pillar. This meant I needed to stretch the entire pillar in the Z access to get an assortment of different heights.

![Streched Pillars](Stretchpng.png)

### 9-Slice Scaling
While working at one of my previous employers as a Game Developer, I was often working with UI’s and Buttons. This reminded me of a similar problem we had with the button texture not always coming out looking the same on different buttons. The solution to this was 9-slice scaling.

9-slice scaling is an image rescaling method where the 4 corners are kept in the same proportions while the middle sections are scaled. This helps keep those rounded edges no matter the side of the image.

![Streched Pillars](483px-Traditional_scaling_vs_9-slice_scaling.png)
Image *[Wikipedia](https://en.wikipedia.org/wiki/9-slice_scaling)*


### Solution
This gave me the idea for my solution. Unfortunately, in Unreal Engine you can’t scale parts of the Static Mesh, or at least I don’t know of any ways to achieve this. My method involved cutting my mesh into 3 separate sections: a top, middle and bottom.

![Pillar onstruction](Pillar_Construction.jpg)

I then created an Actor that took the three meshes and positioned them together so it looked like there were no splits in the mesh. I then wrote code that would change the scale of the middle section and keep the top piece at the correct height.

The scale of the middle section was worked out backwards. I would get a random pillar height ( within a range), subtract the top height and bottom height. Taking the current middle height, divide it by the remaining height and that gave me the scale that was needed.

```cpp
	float TopMeshHeight = MeshTopSize.Z;
	float BottomMeshHeight = MeshBottomSize.Z;
	float MiddleMeshHeight = MeshMiddleSize.Z;
	float MiddleMeshNewHeight = (PillarTotalHeight) - (TopMeshHeight + BottomMeshHeight);

	float UpdatedScale = MiddleMeshNewHeight / MiddleMeshHeight;
	MiddlePillarSize = FVector(MiddlePillarSize.X, MiddlePillarSize.Y, UpdatedScale);
```
### Conclusion
Obviously the middle section is stretched, but the top and bottom sections keep their ratios which was perfect for my use case. This could still be improved on by taking a smaller section that would scale better or using a mesh that wouldn’t be as noticeable when stretched.

![Final Image](Pillar_Out_Come.png)

Ultimately I was happy with this solution and thought I would share the idea. Maybe it will give someone else an idea.


A Better Way of Streching Meshes In Unreal Engine


Hi there! 👋

I’m SylarAtomic - Welcome to my dev blog! I’ve been a developer professionally for 3+ years. Back in 2019, when I started my first job, I worked as a game developer creating HTML5 games using JavaScript and Pixi.js. This was my first introduction into the world of creating games. After working for that company for 2 years, I moved to my current company, which focuses more on 3D architecture. I’ve worked here as a developer creating 3D webpages to help our clients sell apartments and houses. 


### Back in the day
Ever since I got my first computer, I've been interested in finding out how things worked. This didn’t always please my parents when they came home to find that I had taken my first computer apart, but I always managed to put it all back together, and it still worked, so that was good news!

As I got older, I continued to be curious and when it came time to choose a degree to study, I went with a BSc Computing. I wouldn’t say a degree is completely necessary to develop games, but as I’ve found in the software field, it's one of those things that isn't needed until it's needed. When you have a degree, no one asks for it; when you don’t, everyone wants one. Ultimately, I am glad I got my degree first.

![Developer Working](GameDev.png)
Image from *[Medium](https://miro.medium.com/max/1400/1\*KbYaeKKyTGzNTKjIiBzb3w.png)*

### Full Game Dev Mode
At the beginning of 2022, I decided that I wanted to move my career back towards game development: this time towards PC / Mobile games. Since then, I have been using my free time and weekends to improve my craft and learn as much as possible about game dev. From Youtube, podcasts, books and even Udemy courses, I have been throwing myself into the world of game dev. My goal is to become a game developer. Some could argue that I am already a game developer, but until I’m getting paid to do this, I don’t consider my goal as completed.

I know I will achieve this goal, as I have the sheer determination to get what I set my mind on. It will be a lot of hard work and many late nights, sacrificing free time but ultimately, if I have to wake up and do something in order to pay the bills, I might as well do something I enjoy!

I want to create games that are fun and that people will remember for years to come. Any gamer can answer the question, "what was one of your all time favourite games?" I want one of the games I’ve worked on to be the answer to that question.
   

![Unreal Engine 5](Unreal-5.jpg)
Image from *[Unreal Engine 5](https://cdn2.unrealengine.com/share-1200x630-a-1200x630-22326b97f383.jpg)*

### Game Engine
My game engine of choice is Unreal Engine. I chose Unreal because of my previous C++ experience from university. This blog will primarily be focused on Unreal Engine (sorry Unity Users). Nothing against Unity; I have used it previously but I had stronger  skills with C++, so I ultimately decided against it. 

You don’t need to know C++ to learn Unreal Engine. They have made it really easy to use without any C++ knowledge as you can use their visual script system called “Blueprint”.

For now, all I’ll say is that blueprints are fantastic and I have used them a bunch in the games I’ve created.

So far, I’ve created three games in Unreal Engine: one in Unreal 4, and two in Unreal 5. I even competed in my first game jam! (That was hectic). 

The game jam was a great learning experience and I would highly recommend trying one out even if you are on your own. What you can do is choose a game jam, do it along with everyone else and only sign up if you completed a game. This way, you aren’t under any stress of getting it finished if other events pop up.

![Start Line](Start.jpg)
Image from *[Medium](https://miro.medium.com/max/1060/0\*-RDfUUMDd2F1L2po.jpg)*


### Getting Started

After choosing a game engine, my next step was to start learning. Off to Udemy I went! (You could also use YouTube tutorials). If you are looking to get into Unreal Engine and want to follow some courses on Udemy, I would highly recommend Game Dev Tv courses. Game Dev Tv has multiple courses that cover a wide range of game types and styles. What I especially like about these courses is that you are building games while you learn. They take you through the process of building your own game step by step. These are the courses that I have done:
- Unreal Engine Blueprint Game Developer (Good starting point)
- Unreal Engine 5 C++ Developer: Learn C++ & Make Video Games
- Unreal C++ Multiplayer Master: Intermediate Game Development (Optional)


Podcasts are another great medium to learn about game dev. I have mostly been following these podcasts:
- Game Dev Field Guide 
- Game Dev Advice: The Game Developer’s Podcast


What has worked best for me so far has been consistency. I have found doing a little bit of game dev everyday has helped me to continue to move forward.

Ultimately, if you are on the fence about getting into game dev, the biggest mistake you can make right now is not starting.

I’ll be using this blog to share my journey as well as give advice and write guides to help others along. Stick around and let's learn new things together!


Hi, I'm SylarAtomic

Latest from the journal