Daily Log's

Day 100 Tuesday, April 23, 2024 🎉

Yesterday, I spent some time working on my terminal web browser, nothing too exciting. As I reflect on the past 100 days, I realize I've been quite productive, working on various projects and exploring new ideas:

New Projects:

1. Pixel Editor 🦀
2. NeoLisp programming language 🦀
3. An unfinished game "engine" 🦎 private repo
4. Top down unfinished game 🦎 private repo
5. Side scroller unfinished game 🦀 private repo

Revisited Projects:

1. Text Editor 🦀
2. A-Lang 🦀
3. Snow 🦀
4. Snack 🦀

I also delved deeper into Emacs, refining my configuration to suit my needs config. Additionally, I revisited Neovim and revamped my configuration using Kickstarter config with Kickstarter.

While I haven't completed a game yet, I have a deadline set for myself, which is 252 days away. I want to express my gratitude to all who have followed my daily logs and supported my journey. Thank you! 🙏

Day 99 Update, (4/22/2024)

Yesterday, continued to work on my browser and did a little research. Found a library that parsers HTLM and CSS that seemed pretty good. The structure shape they used is the same as mine so I didn't need to change anything.

Hope your day is epic and I will talk to you tomorrow!

Day 98 Update, (4/21/2024)

Yesterday, I spent a few hours working on my Lisp language. Later, I revisited a terminal-based browser project I started a while back, but didn't make much progress on it as I got sidetracked. I also worked on a parser for HTML, which is mostly complete, although there might be some cleanup work left. Next, I plan to focus on rendering the DOM, followed by possibly implementing a CSS layout engine and a JavaScript interpreter. However, I might not get around to doing any of it. Hope your day is going well!

Catch you tomorrow!

Day 97 Update (4/20/2024)

Yesterday, I mostly spent my time worked on my computer. Unfortunately, the CPU fan wasn't working, which meant I couldn't do much work as the system quickly overheated without proper cooling. I've ordered a new fan, but it will take a few weeks to arrive. In the meantime, I've pulled down my Lisp project from GitHub onto my work laptop and started making some progress. I managed to fix a few bugs last night, which was a win. Hope you're having an awesome day, as always!

Catch you tomorrow!

Day 96 Update, (4/19/2024)

Yesterday, worked on moving some old patterns to a new pattern I'm using in my game. I also did some small changes to some shader code. The thing I am kinda excited about is next thing, because I will be implementing a system for chunk loading. The idea is when a chunk is called to be loaded the system will check if it has been saved and if not then it will generate a new chuck. There is also need to see what data format I am going to be using to save the game. For the start I will most likely use the zon file format which is a lot like the json file format, human readable but in the Zig syntax. It is based on the ron file format that was created for Rust. The more advanced format would be some sort of binary type, like Minecraft uses NBT. That will do it for me today!

Hope y'all have a fantastic day and I'll be see'n ya tomorrow!

Day 95 Update, April 18, 2024

Yesterday, worked on some shaders and cleaned up some code last night and did some brain storming on where I am going with this game. Short one today!

Hope your day is epic as always! See ya tomorrow!

Day 94 Update, (4/17/2024)

Yesterday, I worked on creating some basic animations for the game I'm developing. Although I managed to implement them last night, upon reflection, I think my initial attempt could be improved. Tonight, I plan to refine and enhance these animations.

I hope you had a fantastic day!

Day 93 Update, (4/16/2024)

Yesterday, I spent considerable time developing one of my games. I focused particularly on refining the game mechanics, including implementing a method to load the world by chunks rather than by blocks. This, among a few other adjustments, occupied my attention last night.

Till tomorrow.

Day 92 Update, (4/15/2024)

Yesterday, I spent some time working on my notes in Obsidian and created Python scripts to format them. I was reminded of how Python simplifies tasks like these, making the process quite enjoyable. Additionally, I managed to retrieve all the data from my wife's computer and performed a fresh install. I also tackled my taxes, which was less enjoyable.

I hope your day is filled with awesomeness—until tomorrow!

Day 91 Update (4/14/2024)

Yesterday was a mixed bag of productivity and troubleshooting. I spent some time working on my Text Editor project where I picked up quite a few insights. Interestingly, I realized I had been approaching several aspects of it incorrectly before (aka, I was doing it flat out wrong 🤣)!

The bulk of my day, however, was dedicated to debugging my wife's laptop. It turned out to be more challenging than expected but was a good learning experience nonetheless.

Hope your day is epic and I will see you tomorrow!

Day 90.9 Update (4/13/2024)

Yesterday, I found myself jumping around between projects again. I dedicated most of my time to fixing up all my notes using Obsidian, and implemented a few small scripts to aid in this task. I'm hopeful that this will streamline my workflow for both programming and other projects. Work a little on my Text Editor as well.

That's all I got! Hope your day is going great! See you tomorrow!

Day 90.8 Update (4/12/2024)

Yesterday, I got sidetracked as often happens! I engage extensively in digital note-taking and have explored various tools like OneNote, Notion, Norg, Org mode in Emacs, and Obsidian, to name a few. So far, I've been sticking to markdown files and neovim—what more could one need? Well, it turns out Obsidian does! It offers an array of plugins to enhance its capabilities, including an amazing plugin for chord charts. However, I have too many notes to manually transfer, so I crafted a few small Python scripts last night to automate the process. Hope you have an awesome day as always!

Day 90.7 Update (4/11/2024)

In my recent session with the text editor project, I integrated some fundamental functionalities typical of text editors. The core functionality was already in place; my task was essentially to link it with the new UI framework. Later in the evening, I explored tree-sitter, a widely recognized library for syntax highlighting. By leveraging the syntax tree that tree-sitter generates, I aim to enhance the editor's features, such as more intelligent cursor movement and more context-aware highlighting of code blocks. This is a step beyond the capabilities of Vim, which, for example, uses simple newline characters to delineate text blocks rather than understanding the structured scope of code blocks like those defined by curly braces in C. I'm optimistic about the progress and looking forward to breaking new ground. Hope you all have a splendid day!

Day 90.6 Update (4/10/2024)

Yesterday, I made progress on my text editor project. Initially, I had developed my own Text User Interface (TUI) library, which was functional but didn't quite meet my requirements in terms of API design. However, after discovering Ratatui, I found it to be exactly what I had been looking for. Transitioning to Ratatui was smooth, and I was able to set up a TUI for the editor rapidly last night. I'm excited to see how this project progresses with Ratatui's capabilities. Hope your day is awesome and full of progress! Till tomorrow!

Day 90.5 Update (4/9/2024)

Yesterday, I worked on small projects here and there but didn't do anything new or significant. Worked on my old text editor for a bit last night. I made new branch and started ripping out my tui i lib and trying to use a popular one called ratatui. Didn't make a hole lot of progress but eh it was fun. I hope you're having an awesome day!

Day 90.4 Update (4/8/2024)

Yesterday, I spent some time tidying up various projects, but I didn't manage to complete as much as I had hoped. Despite this, there were no significant developments with any of the projects. Regardless, I wishing you all an epic day! See you tomorrow!

Day 90.3 Update (4/7/2024)

Yesterday, I dedicated my time to further enhancing my old compiler, "snack." Notably, I undertook a complete rewrite of the compiler's back end, opting to replace the outdated assembly generation method. In the previous back end, code generation relied on string manipulation, whereas the new approach leverages enum types. This shift allows me to harness the compiler's type checking mechanism, thereby minimizing errors.

Anyway, I hope you're having an awesome day! As always, I'll catch you tomorrow!

Day 90.2 Update (4/6/2024)

Yesterday, I delved into one of my oldest programming languages. It's an inspirational language created by another developer I used to follow. He crafted a Forth-like language called Porth, initially in Python but later made it self-hosted. Being a compiled language, it immediately caught my attention. At the time, I had only dabbled with interpreted languages and wanted to explore the compiling aspect further. While I didn't quite reach the self-hosted stage like Porth did, the project taught me a great deal. One of the key takeaways was understanding x86_64 assembly, and I even managed to create a simple assembler. It was undeniably one of the most challenging projects I've tackled, and it likely ranks among my worst, but the learning experience was invaluable. Anyway, I hope you're having an awesome day! See you tomorrow!

Day 90.1 Update (4/5/2024)

Yesterday, worked on more language things for a bit and after a bit of struggling realized I need sleep went to bed. I hope your day is awesome and see you tomorrow!

Day 90.0 Update (4/4/2024)

Yesterday, worked on one of my languages implementing better data to feed into the test to make things much easier to read and understand if it is correct. Nothing really more then that. Depending on how preceptive you are you may be wondering why today is 90.0. Well if you scroll back to the beginning of my post you may notice there isn't a 1-9. I really didn't understand the challenge when I started I just was going to see I writing a bit about my previous day would help me stay on topic. Well that didn't help as you noticed but I still enjoy it. To set my days to the correct count this will add my missing days. Anyway hope your day is awesome as usual!

Day 89 Update (4/3/2024)

Yesterday, I worked on the language a bit and did some research on other aspects of lang dev. Another short post hope your day is awesome see ya tomorrow!

Day 88 Update (4/2/2024)

Yesterday, I messed with a bunch of vim things. Learned a lot but nothing super interesting. Short post today! Hope your day is awesome and thanks for reading!

Day 87 Update (4/1/2024)

Yesterday, I dedicated time to crafting a symbol table for one of my languages. I've been delving into understanding their functionality and relevance within compiler stages. I successfully implemented one during the previous session. Symbol tables are typically constructed either during parsing or in the Semantic Analysis Phase. Their primary role is to map the initial defined names of entities such as functions, structures, enumerations, etc., collecting their scope, symbol type (e.g., constant, variable, function, parameter), location in the source code, and data type. This comprehensive mapping aids in type checking and facilitates machine code generation. Although I've created a symbol table, I've yet to utilize it extensively for its intended purpose. Regardless, I'm making progress. Hope your day went well, and I look forward to our next interaction!

Day 86 Update (3/31/2024)

Yesterday, I worked on my Functional Programming Language project called snow. It has been a hot minute since I last opened the project up. Most of my projects are broken and I would like to get in a working state so I can show off to others. I also noticed I have a lot of project I do not have on github. I chose to not put it on github cause it was not a complete project but I would hate to lose that project. Anyway on my snow project I was working on hooking up my virtual machine to the language. I made a VM a year or so ago for it but never hooked it up as it is not complete but honestly there is no time like the present. Well I hope your day is awesome and epic! Thanks for reading as always.

Day 85 Update (3/30/2024)

Yesterday, worked on zmax but didn't really make any notable progress. Learn a lot about the C Lua API and I think it would be worth looking into the neovim's use of lua to gain a better understand of how to integrate Lua into my own projects. Hope your day is epic, and hope to talk at ya tomorrow.

Day 84 Update (3/29/2024)

Yesterday, worked on the pixel editor project... I think I have a name for it! It going to be more then just a pixel editor at some point! But the name is going to zmax. LOL so funny! I added Lua to the project so plugins can be used but you cant do any thing yet with it. I added a status bar to the screen as well. Welp that's going to do it for me today! Hope your day is awesome, and see yeah tomorrow!

Day 83 Update (3/28/2024)

Yesterday, I worked on make the keybinding parsing for the pixel editor. That took up pretty much all the time. I probably should get back to the game as this project is a bit ambitious. Eh I'll just not think about that right now LOL. We ended on starting the main code to parse raw key presses and give a command but I ran out of time. Hopefully that will be wrapped up today and start on something a bit more visual. Welp hope your day is awesome! Until tomorrow.

Day 82 Update (3/27/2024)

Yesterday, I streamed working on a Trie data structure in Zig. If you're interested in watching me fumble around with it, here's the link. The overall summary is that we built the data structure, but it remains unfinished. Our last task was to implement a method in the data structure to retrieve all possible words that start with a given prefix. Well that's about it for now! Thanks for checking in, and I'll catch up with you tomorrow!

Day 81 Update (3/26/2024)

Yesterday, I resumed work on the pixel editor, focusing on code cleanup and implementing keyboard-driven functionality. There are two approaches to this task: the easy way and the hard way.

The easy way involves hardcoding all the key bindings to their respective commands or functions. On the other hand, the hard way requires developing a mechanism to parse key presses and match them against predefined combinations to determine the corresponding command or function. Additionally, it's essential to handle scenarios where a combination like abc might trigger foo, but ab should trigger bar. It's definitely a challenging task.

In my experience, I've found that utilizing a Trie data structure is highly effective for managing key bindings and parsing key combinations efficiently.

And with that you guessed it! HARD MODE!

Hope you're having a fantastic day, and I'll catch up with you tomorrow!

Day 80 Update (3/25/2024)

Yesterday, I worked on a top down concept game. There are some bugs with collision detection but I'm confident that will be fixed with a few minor adjustments. I also implemented player movement following the mouse when W key is pressed, I can never remember how to do this even though its really simple. Fixed a few graphical glitches here and there as well. Did a lot more but nothing really worth of noting. Next I am going to start drawing up some UI elements for the hud and player sprite (and maybe some blocks but I want to try and generate the textures for blocks but that's another days topic). So the next few days I will most likely be rewriting my pixel editor before I use it. I will probably will stream that tonight as this my take a few days to do but I will let me redo a lot of bad choice made. Anyway hope your day is epic! Thanks for stopping by and reading!

Day 79 Update (3/24/2024)

Yesterday, I experimented with Raylib and Zig, working on a top-down game concept that I had in mind. I also worked on other projects as well such as the lisp interpreter but the raylib one took most of my time. Hope your day is epic and thanks for reading!

Day 78 Update (3/23/2024)

Yesterday, I dabbled a bit in my Lisp language project and then shifted focus to another project I've been experimenting with for a few days. This one involves Common Lisp and raylib, though I hesitate to call it a full-fledged project at this point. I've mainly set it up and started capturing some key presses, but haven't delved much deeper yet. I found myself a bit frustrated with the lack of documentation for the raylib Lisp library, and perhaps some of that frustration stemmed from my own skill level. Consequently, I ended up exploring other avenues. It was a bit of a scattered day, to be honest. Well, here's to hoping your day is fantastic! Thanks for taking the time to read this update.

Day 77 Update (3/22/2024)

Yesterday, I continued to work on my Lisp language. I'm very excited to see what happens next! Also been messing with getting better at common lisp. Short one today! Happy Friday and talk at ya tomorrow!!!!!

Day 76 Update (3/21/2024)

I continue to be increasingly impressed by Lisp each day! Experimenting with how it integrates with other languages has been quite enlightening. This has sparked an idea that I plan to delve into for a future blog post. Yesterday, I also introduced a new Neovim plugin yesterday called winshift. This plugin enables me to rearrange my windows/panes in Neovim, akin to a tiling window manager. Interestingly, I hadn't considered this until stumbling upon an Emacs plugin for the same purpose!

It's worth noting that unlike Emacs, Neovim/Vim lacks a direct method to create a new "mode." In Emacs, modes refer to buffer/files that prompt Emacs to perform specific actions. For instance, opening a Rust file activates rust-mode, potentially triggering the Lsp to initialize via a configured hook. Emacs modes are somewhat analogous to the considerably less potent ftplugin files in Vim. However, Emacs can mimic Vim by implementing "Vim modes," which function as states coded within Emacs and can be added as needed.

Anyway, I hope you're having an awesome day, and thanks for sticking through this lengthy post!

Day 75 Update (3/20/2024)

Yesterday, I began integrating span into my expressions to enhance error reporting for users. It led to a flurry of errors, but the outcome was rewarding! By systematically addressing each error reported by the LSP (Language Server Protocol), I effectively achieved what some call "Compiler-assisted refactoring". This approach proved aptly named.

After completing this task, I resumed work on implementing Rule 110 in my Lisp language, which surprisingly didn't pose much difficulty and quickly became operational. Overall, it was a highly productive day!

Wishing you an equally epic day ahead!

Day 74 Update (3/19/2024)

Yesterday, I dedicated all my spare time to working on the Lisp interpreter project again. It's been incredibly educational, especially in learning various evaluation techniques that I can utilize in my Snow programming language. Currently, I'm focusing on using the language to implement Rule 110. You can find the implementation here.

Last night, I encountered a problem of my own design. While the interpreter provides decent error messages at parsing time, during evaluation, the errors are just messages that don't specify where they occurred. In a small program, this isn't too bad as you can usually figure out where the issue lies. However, in a larger file, this becomes quite annoying. Therefore, I'm going back to add the span of expression on the nodes.

Well, I hope your day is going as epic as mine, and I'll catch up with you tomorrow!

Day 73 Update (3/18/2024)

Yesterday, I dedicated my time to working on my Lisp language project neolisp. Additionally, I stumbled upon a fascinating browser called nyxt, which is written in Common Lisp. It seems to offer extensive keyboard-driven features and customization options, reminiscent of qutebrowser, but with even greater power and flexibility. Although I haven't had the chance to try it out yet, I'm looking forward to exploring it in the future. Wishing you an epic day, and thanks for stopping by!

Day 72 Update (3/17/2024)

Yesterday, I delved into a new Lisp interpreter project, which I'm excited to explore further in the coming days. This endeavor has shed light on some missing pieces in my understanding of other languages. One particular area I've been grappling with is implementing TCO (Tail Call Optimization), and this project has led me to a resource that discusses it extensively. It's called Mal. Additionally, I stumbled upon a couple of other projects that might be valuable for those interested in language development. One is a Lisp implementation in Python called lispy, and the other is a Rust version inspired by the former, known as risp. Although Mal offers a plethora of examples in various languages. Hope you have a great day! As always thanks for reading.

Day 71 Update (3/16/2024)

Yesterday, I delved into the depths of my Lisp language interpreter. It never ceases to amaze me how straightforward it is to craft a program in Lisp and how effortlessly one can construct an interpreter for it. The language itself boasts minimal keywords, relying instead on built-in functions. It avoids excessive symbol usage for syntax, yet paradoxically offers the power of macros to craft one's own syntax. It truly blows my mind! Anyway, here's to a splendid Saturday ahead. Thanks for taking a moment to peruse my musings!

Day 70 Update (3/15/2024)

Yesterday, I couldn't sleep, so I woke up at 2 am and whipped up a shoddy Lisp interpreter. It's got variables, if-else statements, and lambdas, but it's missing a bunch of stuff you'd expect from a proper Lisp. But hey, what can you do in just five hours? Whether it was lack of sleep or just my perpetual itch to start new projects, I ended up scratching that itch and dove into making a text editor. Well, more than just a text editor, but it's the starting point. It'd be pretty awesome to create something akin to Emacs, but with the added muscle of multi-threading. That could really open up doors to build more cool stuff within it. Hope your day is awesome!

Day 69 Update (3/14/2024)

Yesterday, did a little work on both the emacs config and the game. This are slow but I am pushing threw. Nothing to report on either. Hope your day is epic and thanks for checking in!

Day 68 Update (3/13/2024)

Some unforeseen evens kept me from doing much but research yesterday. Emacs has shifted my focus from the game but I will soon be back on track. Not much else to say so I hope your day is awesome and I will talk at ya tomorrow, thanks for reading!

Day 67 kUpdate (3/12/2024)

Yesterday, I spent most of my time working on the Emacs configuration. I didn't get all the things fix but I did get magit installed and fixed the keybindings for Neotree. I did get most all the things with Rust working so I may try and use it tonight unless something bugs me and I will just swap back to vim. Hope your day is awesome and thanks for reading!

Day 66 Update (3/11/2024)

Yesterday, I successfully configured Emacs for debugging in JavaScript. Additionally, just before wrapping up for the night, I discovered that Emacs DAP mode can read a configuration file for VSCode. This means that if a project already has a debug profile set up in .vscode within the project, no additional setup is required in Emacs. Pretty cool! I still need to determine the best approach for Emacs to automatically pick up any debug information set for Emacs projects. Anyway, this was an enjoyable exploration, but I feel I've reached a good point with it to return to normal development using Emacs.

Day 65 Update (3/10/2024)

Yesterday, I dedicated the entire day to creating a Emacs configuration file. I've decided to integrate Emacs into my daily workflow both at home and potentially at work, provided I can address any remaining issues. My main focus was on setting up language servers, and after some effort, I managed to get them working smoothly.

Towards the end of the day, I delved into configuring the debugger, which proved to be a bit challenging. Nonetheless, I made significant progress, and overall, it was a highly productive day.

You might wonder why I chose Emacs. Well, Emacs offers far more than just text editing capabilities. It comes bundled with various built-in tools such as an email client, web browser, and much more. Additionally, Emacs can even serve as a window manager, a feature I intend to explore further down the line. Also there are an massive amount of packages out there that allow you to just do most of everything in emacs. However, for now, my focus is on mastering the fundamentals of the text editing experience.

Day 64 Update (3/9/2024)

Last night I just worked on my emacs config file. I am going give emacs a real try and not just play around with it like I have for the last few years. Of course I will need the vim keybindings because I am not insane! My end goal is to use emacs like a window manager but we shall see what comes of this adventure. Hope your day is awesome and thanks for reading!

Day 63 Update (3/8/2024)

Yesterday I was reading a lot about WGSL for about an hour or so then I started working on a new emacs config. Probably going to use emacs all weekend and hopefully get something to show. WGSL is a very nice language is all I have to say! Hope your day is awesome and thanks for reading!

Day 62 Update (3/7/2024)

Yesterday I mostly just read about wgsl and how bevy works with it. ShadPlay has been extremely helpful in this regards. Short post today! As always though hope your day is full of amazingness, and thanks for reading!

Day 61 Update (3/6/2024)

Yesterday, I stumbled upon the missing puzzle piece in my quest for shader mastery: a sneaky little plugin provided by Bevy. With this newfound knowledge, I finally managed to coax a shader into conjuring up a texture. It was one of those "Eureka!" moments that made me wonder how I ever missed it in the first place. Now, armed with this shader sorcery, I'm gearing up to tackle the enigmatic realm of Perlin noise algorithms. It's like venturing into uncharted territory, except with a GPS... made of code. WGSL, the language of shaders, has a Rust-like charm to it, with just the right blend of familiarity and mystery. Let's hope my journey into Perlin noise doesn't turn into a noisy mess! Here's to epic adventures and the joy of coding! Thanks for tuning in! 🚀🎨

Day 60 Update (3/5/2024)

Yesterday, I achieved camera tracking for the player and implemented block placement functionality. Although these features are not polished yet, progress is underway. I plan to focus on terrain generation next. Hope your day is awesome, thanks for taking the time for reading!

Day 59 Update (3/4/2024)

We've made some progress! Simple jump, gravity, and collisions are all up and running, although the jump still needs refinement. Next on the agenda is getting the camera to follow the player. Exciting times ahead! Hope you're having an epic day, and thanks for tuning in, till tomorrow!

Day 58 Update (3/3/2024)

Yesterday, I began implementing game movement and experimented with jumping mechanics and other interesting features. I encountered some obstacles while working with Rapier, spending about an hour troubleshooting. To take a break, I shifted my focus to my other task for the day, setting up OctoPrint. It surprisingly turned out to be straightforward and immensely useful. It allows me to monitor my prints remotely and control the printer if any issues arise. After resolving my Rapier issue, I resumed development and started working on despawning and spawning blocks to create an infinite walkway ahead of the player. However, as the day progressed and fatigue set in, my progress became a bit chaotic. I plan to tidy up my work today and then implement camera follow functionality for the player. As always, have an awesome day, and thanks for reading!

Day 57 Update (3/2/2024)

Yesterday, I focused solely on enhancing the blogging website. I implemented metadata for the blog posts, which is a step forward in improving the overall structure of the site. My next objective is to transform the site into a single-page application (SPA) rather than relying on a static site generator. Considering my current workload, achieving all the items on my checklist today might be challenging. Nonetheless, if time permits, I'll start working on the SPA transition. Hope your day is full of success and awesomeness, thanks for reading!

Day 56 Update (3/1/2024)

Welcome to a new month! Yesterday, I spent some time dreaming and doing a bit of research for the game. As the weekend approaches, I'm gearing up to tackle some tasks on my to-do list. I'm determined to make progress and move forward with the project. Hope your day is awesome and thanks for reading!

Day 55 Update (2/29/2024)

Exciting news! Yesterday, I stumbled upon a Bevy plugin that offers a basic debug console – just what I needed! I swiftly integrated it into my project and delved into some more research.

A short and sweet update, but a significant step forward in enhancing the debugging capabilities of the project.

Day 54 Update (2/28/2024)

Yesterday, I delved into Rapier and various Bevy plugins and resources, stumbling upon two particularly intriguing finds:

1. Bevy Noise Map
2. Bevy Design Patterns

Exploring these projects has been both enlightening and inspiring. However, the real treasure trove lies in the Bevy Assets section. There's a wealth of exciting possibilities waiting to be uncovered!

I've been toying with the idea of creating an infinite block line for the player to traverse a simple yet effective exercise that would involve generating blocks ahead and behind the player dynamically. This will serve as a great starting point for implementing the camera and player controller functionalities.

Although work-related commitments may limit my hands-on coding time today and tomorrow, I recognize the importance of research in paving the way for future progress. So, while I may not be diving deep into development just yet, I'm embracing the opportunity to gather valuable insights and ideas.

Day 53 Update (2/27/2024)

Yesterday, I managed to fix the gravity issue. It turned out that the player controller code was inadvertently removing gravity from the player. I had been using a RigidBody::Dynamic, which allows the physics engine to apply outside forces such as gravity or other entities to affect the RigidBody. However, I discovered that I need to use a KinematicBody, although they don't seem to be affected by anything at the moment. More research is required. There's so much to do and so little time to do it.

Day 52 Update (2/26/2024):

Exciting news – collision is now implemented! Utilizing Rapier has proven to be incredibly helpful. I successfully reintegrated all the previous components of the system and updated them to version 0.13.0. Despite the constant allure of distractions, maintaining focus becomes much easier when tangible progress is made.

Yesterday, my focus shifted towards incorporating gravity using the capabilities provided by the Rapier plugin. However, despite my efforts, I couldn't manage to trigger it successfully. Nevertheless, I remain determined and confident that today will bring the solution I seek.

Day 51 Update (2/25/2024):

Yesterday, I dedicated a considerable amount of time to crafting a keymap for my keyboard. Alongside this endeavor, I made notable progress in advancing the development of my game. Specifically, I delved into integrating physics mechanics into the game world. In this pursuit, I stumbled upon the Bevy plugin known as Rapier, which perfectly catered to my requirements. While I successfully implemented Rapier into my project, achieving this milestone necessitated a significant refactor of the existing codebase, followed by a gradual reintroduction of essential components.

One of the standout features of Rapier is its comprehensive debugging capabilities, particularly its ability to visualize hit boxes. This functionality proved invaluable, aligning seamlessly with my development objectives.

Furthermore, I capitalized on the opportunity to upgrade to Bevy 0.13.0 during the refactoring process, ensuring that my project remains up-to-date with the latest enhancements.

Towards the latter part of the day, I pivoted my focus towards implementing a gaming layer on my keyboard. However, I encountered a challenge wherein my a key doubles as my ctrl key. Holding down the a key triggers a ctrl press, complicating movements to the right. while this is really nice for typing on a 40% or 36 key keyboard it is not nice for gaming as you can imagine. Despite investing time into understanding the ZMK approach, I found myself unable to fully integrate it effectively before running out of time.

Despite these challenges, I remain optimistic about the progress made and am hopeful that your day is equally rewarding and productive!

Day 50 Update (2/24/2024): I spent my available time drawing today. Experimenting with animation has been quite enjoyable lately.

Day 49 Update (2/23/2024):

Spent what time I had yesterday working on shaders and art again. Still not great at pixel art, but I'm confident improvement will come with time. Short and sweet update for today! Hope your day if awesome!!!

Day 48 Update (2/22/2024)

Yesterday, I spent some time doing art and working on the Perlin Noise algorithm for terrain generation. However, I encountered an issue while attempting to create a texture from a shader for 2D rendering. It's not a major setback, but I'll need to dive into the documentation to resolve it. Additionally, I experimented with shader code, which was enjoyable. This was my first time using WGSL in a project.

Day 47 Update (2/21/2024)

Unfortunately, I didn't make much progress yesterday as I had limited time available. However, I did create a computer mount for under the desk while at work, which was a neat project. As for the game development front, there's nothing new to report at the moment.

Day 46 Update (2/20/2024)

Yesterday, I experimented with various noise algorithms to determine which one would be best suited for terrain generation. After some testing, I've decided to go with Perlin noise. Additionally, I'm considering exploring GPU-based noise algorithms or creating one myself to have full control over this aspect of the game.

This week's goal is to implement terrain generation, even if it's basic(just working on shape), and work on developing a player controller.

Until tomorrow, thanks for reading, and let's make this week productive!---

Day 45 Update (2/19/2024)

Yesterday, I delved into terrain generation, focusing initially on a single chunk. I began experimenting with its generation and ensuring alignment with other chunks. Given the game's 2D nature, a chunk size of 64x64 blocks seems reasonable. Additionally, I explored animation in Bevy, which proved quite successful. However, I recognize the need to dedicate time to drawing characters and tiles soon. Currently, I'm utilizing some free character art that Adam sent me. Although I didn't complete any specific tasks yesterday, I'm still adjusting to some aspects of Bevy that I either haven't touched before or have changed since the last time I used it. Until tomorrow, thanks for reading, and I hope your day is epic!

Day 44 Update (2/18/2024)

Yesterday was incredibly productive! I started my day as usual, tinkering with Zig code and made some progress. However, a thought crossed my mind: "How challenging would it be to migrate all of this to Rust?" Well, the process itself isn't too difficult, but considering that raylib crate is not up to date and I was relying on the C interface in Zig, I might need to explore alternative libraries.

Then, another idea struck me! What if, for today, I explore Bevy? While working with Bevy, I had an epiphany: I don't want to build a game engine or any similar tool. My primary objective is to create a game within a year, not to develop both a game and an engine! Typically, I undertake projects for the sake of learning, so whether or not I complete them doesn't bother me. However, this time is different. The game is the goal, and I need to utilize the most suitable tools to achieve it. Bevy seems to fit the bill perfectly! It feels invigorating to be working with Rust again!

Despite all the talk about using the right tool for the job, I've decided to stick with my own pixel editor until I outgrow it. Eventually, I know I'll need to switch, but for now, it remains the best solution for ensuring success. Apologies if this decision disappoints anyone, but I believe it's the most pragmatic approach for achieving my goals.

Day 43 Update (2/17/2024)

Well, this week turned out to be a bit of a wash for game development... Oops! Yesterday, I spent most of my free time trying to get GitHub Actions working.

• ✅ Successfully triggered an action when pushing to the master branch.
• ✅ Set up Go and compiled the project.
• ❌ SSH into my server and copying the binary created from Go onto it.

However, amidst this, I stumbled upon a cool project called act, which allows you to test GitHub Actions locally. Unfortunately, it didn't provide any new insights into why I can't SSH into my server. No worries, though. Today, it's back to game development. Hope your day is epic!

Day 42 Update (2/16/2024)

Yesterday morning, I spent some time working on my blog site, although I didn't manage to make any progress on the engine. Since Saturday, things have been moving slowly. The 3D printing project I've been working on has been taking up a significant amount of my time. I've made promises to a few people regarding parts, so I had to prioritize that. Once these commitments are fulfilled, I'll be able to refocus on the engine project. While the blog site is now up, it still needs some improvement in terms of appearance. I've decided to keep it under wraps until day 100.0.

Until next time.

Day 41 Update (2/15/2024)

Yesterday just worked on resetting my server and getting the blog site up. Its up but not really ready to be seen. Did some 3d printing and but no game dev was done. I hope to get back to that today, there are some problems I will highlight if I cant figure them out tomorrow. Would talk about them more today but I cant really remember what they are . I have to many irons in the fire! Anyway hope your day is awesome!

Day 40 Update (2/14/2024)

The week is flying by! Yesterday was a bit of a struggle—I didn't manage to get much done. I've been working on setting up a blog site so I'll have it ready once the 100 days are up. However, I ran into some issues with the server. The site is written in Go, but the server didn't have the Go compiler installed. When I tried to download it, I realized the server had a lot of problems, most of which were caused by me, haha! It's running Ubuntu Server, so using the apt package manager is essential, but it's currently not functioning correctly, and despite my efforts, I couldn't fix it. So, I spent the night moving all my files, which include a few Minecraft and Terraria worlds, along with some config files. I think there's more to do, but I'll try to tackle that tonight. Additionally, I spent some time trying to get my 3D printer working—it wasn't performing well. It turns out the nozzle was old and oversized, so a simple replacement solved the issue.

Day 39 Update (2/13/2024)

Last night, I dedicated my time to reworking the GUI, with a primary focus on completing the drawing portion. Tonight, my goal is to implement the functionality for clicking a button. Navigating this process without dynamic memory allocation has proven to be quite challenging. I've found myself heavily relying on comptime to generate much of this functionality, which, while beneficial for performance, can be somewhat cumbersome to manage. I eagerly anticipate reaching a point where I can set this code aside for a while and shift my focus to other aspects of the game.

Day 38 Update (2/12/2024):

I'm really loving the transition to ECS (Entity Component System)! Yesterday, I began moving code to the ECS architecture and delved deeper into understanding how it works. The process of migrating the old GUI code is underway, although I'll need to tweak it to better align with the new design flow. Overall, the new approach feels much cleaner compared to the previous setup. While there are occasional quirks with the ECS that I'm not accustomed to, they're nothing too outlandish.

My goal for this week is to focus on adding state management and implementing a debug console into the game. With the groundwork laid by integrating ECS, these tasks seem quite feasible now. I'm excited about the progress and potential ahead!

I hope your day is awesome!

Day 37 Update (2/11/2024):

Yesterday was productive as I delved into exploring the zig-ecs to understand its functionality better. I encountered a blocker with zig-ecs when using my custom implementation of a Vector as a component, resulting in runtime crashes. It turned out that zig-ecs uses the Type as the component, and aliased types were not recognized properly. I resolved this issue by encapsulating Vector2 within a struct, resolving the underlying type mismatch. This experience prompted me to reconsider the GUI structure, which was previously tailored to the old update-then-draw methods. Overall, it's been a stimulating journey with new insights to ponder.

Day 36 Update (2/10/2024):

Today's update brings some challenges with Zig-Ecs. It seems the library isn't quite ready for use. When attempting to integrate it with my custom Vector2 implementation, which includes additional helper methods for casting, I encountered issues. Zig-Ecs appears to favor a simpler struct approach with x and y members. Unfortunately, attempting to use my custom implementation resulted in ECS crashes due to size assertion errors.

Despite this setback, I'm not giving up. Today, I'll delve into the source code of Zig-Ecs to understand the issue better. Additionally, I'll explore other ECS libraries in search of a more suitable option. So far, nothing has stood out, but I'm determined to find the right fit for the project. Onward with the search!

Day 35 Update (2/9/2024):

Yesterday yielded some exciting breakthroughs for the project. Chief among them is the discovery of the zig-ecs library, a tool I'm eager to integrate. This library boasts the potential to greatly streamline data organization, which will undoubtedly prove invaluable.

Regarding the search for a GUI library, the quest continues. However, I'm increasingly inclined to stick with my own implementation. While this may initially seem like a fallback option, it's important to recognize that my current implementation isn't lacking. The primary issue lies in how the existing engine structure limits its flexibility. By transitioning to an ECS architecture, I anticipate a marked improvement in the usability of the GUI components.

Overall, I'm filled with optimism regarding these developments and am eager to witness how they enhance the project. I'd like to extend my gratitude to Axel for their encouraging words and to Adam for their assistance yesterday. As always, onward and upward!

Day 34 Update (2/8/2024):

I've reached a crucial decision point regarding the development of the ECS (Entity-Component-System) or GUI (Graphical User Interface) components of the game engine. If significant progress isn't made on these fronts soon, I'll need to consider making major changes to the engine.

My goal is to release a game on Steam by the end of this year. While I'm not implying it will be flawless, that's the target. However, if I find that the current engine development is impeding game development progress, I may need to explore alternative options.

I've always believed in the mantra: "If you want to make a game, use an engine! If you want to make an engine, try building a game without one." Given the time constraints, building a game from scratch without an engine seems unfeasible. Therefore, I may need to consider utilizing stable libraries to piece together an engine or opt for an existing engine cough ... cough ... Bevy.

While a year may seem like a generous time frame, it's important to acknowledge the reality of sporadic development hours. Some days, I can only spare an hour or so, and even that time is partially consumed by tasks like writing this post.

This consideration has been on my mind since day one, and while it represents a significant shift in direction, it may ultimately be the most pragmatic solution. As always, thank you for taking the time to read this, and I hope you have an awesome day!

Day 33 Update (2/7/2024):

I mostly spent my time reading on other implementation of ECS's and GUI libs. Nothing of note to talk about. Also messed around with 3d printing stuff but I have no more filament, sad day. Hope y'all have an epic day!

Day 32 Update (2/6/2024):

Yesterday, I primarily addressed some existing system issues and managed to overcome a few blockers. One of the blockers involved widget placement, which wasn't behaving as expected, but I found a workaround that might suffice for now. Additionally, I began exploring how to give focus to a widget and prevent events from occurring with other widgets when one is in focus. It's a bit tricky to handle, but I made some progress. While I did delve into the ECS and worked on the query functionality, there weren't any major breakthroughs. Nonetheless, I achieved some small victories here and there, and I'll continue pushing forward. Hope your day is epic!!!!!

Day 31 Update (2/5/2024):

Yesterday, I delved into making progress on fictionalizing a Query call in terms of syntax and user interaction. There's still much to be done in that regard. Next on the agenda is setting up a simple Entity-Component-System (ECS) and integrating the query call. I had a realization recently about the nature of ECS—it's essentially an in-memory database. It revolves around breaking down entities and components in a way that allows querying on components. Moreover, components are essentially ID numbers with names, constituting the foundation of data-oriented programming. It's a fascinating realization and an exciting journey into the intricacies of ECS. Looking forward to the next steps!

Day 30 Update (2/4/2024):

Design poses a considerable challenge, and I find myself wrestling with the decision to either overhaul existing structures or patch up gaps and press on. The allure of an Entity-Component-System (ECS) architecture is apparent, offering elegant solutions, but my current knowledge and time constraints make its proper implementation in Zig a daunting task. Nevertheless, I've decided to dedicate the next few days to exploring ECS designs, hoping to uncover insights that may influence my project positively. Simultaneously, I will persist with the ongoing development, recognizing the importance of continuous progress.

On a different note, I've been actively engaged in 3D printing recently. My wife has delved into sewing, and I crafted a speed limiter for her pedal, among other projects. OpenSCAD, the software I use for creating models, stands out for its ingenuity, allowing model generation through a built-in scripting language. The journey continues, embracing both the challenges of software development and the tangible outcomes of 3D printing adventures.

Thanks for reading and hope your day is amazing!

Day 29 Update (2/3/2024):

Yesterday's progress was quite satisfactory. I managed to implement bottom and right padding, resulting in a cleaner and more organized codebase. While I initiated work on a textarea like widget, no substantial developments were made in that area. Today, my focus is on implementing the debug console. Stay tuned for further updates! Hope your day is awesome!

Day 28 Update (2/2/2024):

Not much to update on but I did get padding to work and I started on a widget that is for input text. It going well so are. Only thing different for this widget is it needs a function that will update the widget's text. As far as drawing goes I just need to add to the switch statement to handle how to draw the widget. Hopefully that will get done today or early tomorrow morning.

Day 27 Update (2/1/2024):

Limited time available yesterday! Managed to invest a short duration into GUI enhancements. Once the padding functionality is sorted out, the focus will shift towards implementing a Text Box for the debug console—a feature that I'm eagerly anticipating. The debug console will serve as a space where users can employ commands to manipulate the game or trigger specific actions without natural triggering. Hope your day is fantastic!

Day 26 Update (1/31/2024):

Yesterday, I addressed a couple of minor issues. The grid is now correctly centered, and resizing the window maintains the UI's position. Additionally, I began enhancing the GUI's customization by incorporating padding options. Although it wasn't fully completed by the end of the day, I plan to wrap it up today. Hope your day is epic!

Day 25 Update (1/30/2024):

I identified the cause of the memory leak issue. It was an oversight on my part. In the engine state is stored as structs in an EnumArray. To access an item, you can't use myarray[.Enum] directly; you have to use a method, myarray.get(.Enum), which returns a copy of the item.

The issue was that I was getting a copy of the true state every time I swapped states, and deallocation wasn't happening for that state. The fix was simple—I needed to call myarray.getPtr(.Enum).

As for what I accomplished yesterday, I started working on additional styling options for the UI, such as width and height overriding. I'm also exploring a way to add a texture to buttons, which might be a bit tricky. Reflecting on the past, we created a texture loader that, at compile time, looked into a folder, grabbed all the images, and organized them in one area for access using an enum generated at compile time.

While this setup works well, I'm now considering more control. It would be nice to have images sorted by type in directories, but I'm unsure about how to handle the distribution of textures. Should I have a single master Texture struct, or should I break it down into multiple? My current plan is to try a master struct and pass it in as a parameter to obtain details. We'll see how it goes. Anyway, I hope your day is awesome!

Day 24 Update (1/29/2024):

Yesterday was quite successful, I'd say! It's just some buttons—nothing groundbreaking, but it achieved the goal! While drawing was functional, I needed a way to check if a particular button was pressed. Initially, this seemed straightforward, but with the newly introduced draw function that takes in widgets and dynamically places them on the screen, the calculations for button positions were only done on-the-fly and not stored.

To address this, I extracted the code responsible for calculating widget placement into its own function. Now, when creating buttons, you can retrieve the boundary of that widget and pass it into a function called isClicked. This function detects if any widget, including text, is clicked. It turned out to be a cool side effect.

I then started adding functionality to the buttons in the main menu. There's a Start button that swaps the state of the program to the game and an Exit button that, well, exits the game. After that, I began reintegrating terrain generation with camera movement but encountered a peculiar memory leak. Unfortunately, I couldn't resolve it before calling it a night, but I plan to address it today.

The current goal is to enhance the UI by getting a few more things working, such as the player HUD and a debug console. The latter will be particularly useful for debugging during runtime. Creating a text box will be a bit challenging, but the overall experience has been enjoyable so far.

Again, hope your day is blessed, and thanks for taking the time to read!

Day 23 Update (1/28/2024):

Almost forgot ... Yesterday, I made some progress. While I did manage to get the previously shown code working, I encountered unforeseen annoyances using that approach. For those unfamiliar with Rust or Zig, let me explain. Rust and Zig do not throw errors conventionally; instead, they use a Result type that the function returns. In Zig, this is typed like so: fn foo() !void {, where the ! indicates that the function could fail. In Rust, if a function returns a Result, it means it could fail. Zig's errors are tightly integrated into the compiler, while Rust treats errors more as a type in the STD.

Why do you need to know this? I'm getting to that . In Rust, you can method chain Type::new().one().two(). If the method one returns a Result, there wouldn't be a method two on Result because our type would be wrapped in Result. To address this, Rust provides a nice syntax feature with the ?. So, to fix the Rust code, we would do Type::new().one()?.two(). If the Result was an error, the function holding this code would fail and return the error. Likewise, in Zig, there is the try operator for handling the Result, but it's a prefix operator. So, without the try, the translated Rust code to Zig would look like Type.init().one().two(), and with the use of try, it would look like this (try Type.init().one()).two()... not a fan.

After all that, I've decided to keep it more in the spirit of Raylib and just create a few functions that do what I need, with the data handled by the user. I'll provide a Button struct, and you maintain the data, but when you need to draw it, you can call a drawButton function. If you have more integrated needs, you can call just draw, and it will take any Widget the UI library has. That would look like:

draw(mouse, boundary,
 .{ .align_x = .Center, .align_y = .Center, .layout = .Column },
 .{ button0, button1 }
);

Hope your day is awesome!

Day 22 Update (1/27/2024):

Yesterday was all about the UI! I jumped into various approaches for interacting with the UI and believe I've nailed down a solid plan. My strategy involves first getting a smaller example working smoothly before integrating it into the main project.

container(.{"Hello", "World!"}).column(.Center).row(.Center).into()

This is the ideal user-side code structure I'm aiming for, though adjustments might be necessary once all components are integrated. Hopefully, by the end of today or tomorrow, there'll be a tangible progress update. Exciting times ahead!

Day 21 Update (1/26/2024):

Yesterday, my focus remained on UI work, and I believe I've devised a more elegant solution to handle UI elements. The challenge lies in ensuring responsiveness, especially during resizing events. Unlike the pixel editor, I'm avoiding hard coding UI elements to accommodate the dynamic nature of game development. Responsive UI is crucial, and I'm excited to see how this approach unfolds. Hope your day is awesome!

Day 20 Update (1/25/2024):

Never enough time in the day, but I managed to make progress on a small part of the UI. Instead of detailing what I accomplished (which was minimal), I'll share the plan. In the past, I've developed UIs that function similarly to how elm (a programming language for front-end web dev) abstracts CSS in a programmatic way. For instance, if you wanted to vertically and horizontally center something, you'd wrap your Element in a Row and a Column, and add center alignment to each to achieve the desired output.

So, my plan is to create a Row and a Column using a union to handle this job. I could use an interface-like approach in Zig, but since this isn't a library and I might need to add more element types, I'll do so within my union. That's the current idea. Things might evolve, but that's the story, and I'm sticking to it!

Day 19 Update (1/24/2024):

Well, I made progress with the UI aspect of the game engine. My main focus was on how events would be triggered, especially when a button is pressed. In Zig, there are no closures, making it a bit challenging to implement callbacks for buttons. So, I settled on having an update function that returns an event set for when a mouse button of your choice is mapped to an event. Something like Button(enum { ThisIsAnEvent }).init(......some args...., .{ .Left = .ThisIsAnEvent }) is how you would initialize the function. Therefore, you'd need to switch on the return type of the update function.

It's important to note that I'm not aiming to create a generic engine for everyone to use. This is, once again, For Me (FM) software, tailored to my specific needs. This has been a blast so far. I imagine I will be on this same part of the engine the remainder of the week. Hope you all have an awesome day and keep programming!

Day 18 Update (1/23/2024):

Yesterday involved further research and programming for the engine. I successfully implemented a state machine to facilitate smooth transitions between menus and the game itself. Following this, I initiated the development of a UI library for the engine—a crucial component of the game. The goal is to create interactive UI elements that are user-friendly on the back end. The previous method proved to be somewhat cumbersome and didn't fulfill all the requirements of the pixel editor.

While grappling with the best approach, I'll continue iterating through ideas to determine the most effective solution. Additionally, I recognized the need for more compile-time magic to enable Zig to iterate over all raylib enums and create Zig equivalents. This aims to streamline the process, as C enums are globally accessible once defined, lacking any namespace. For example, in C, enum members are not prefixed with the enum name, so A is simply A, while in Zig, it might be beneficial to have it as Letters.A.

Until tomorrow, have an awesome day! Thanks for taking the time to read this update.

Day 17 Update (1/22/2024):

I successfully automated the generation and loading of textures in a directory through enum in Zig during compile time – a significant achievement for the day. Given my relatively new venture into Zig, a substantial amount of time has been dedicated to learning the language. At this point, I've made the decision to stick with Zig and Raylib for the time being.

Progress has been made on the engine's interface, with a focus on prioritizing game mechanics over elaborate engine design. For this project, I've decided not to delve into creating an Entity Component System (ECS) for now.

Drawing inspiration from my experience with Rust and a game library called GGEZ (similar to Raylib), I'm structuring the interface, which itself is heavily influenced by LOVE2D – a Lua game engine. While these upcoming days might not showcase significant visual progress, numerous developments are occurring on the backend.

Excitement levels remain high as the project continues to unfold!

Day 16 Update (1/21/2024):

Yesterday wasn't as productive as I had hoped, but it was still a productive day. My initial plans were to delve into other aspects of game development, but I found myself immersed in resolving a minor string-related issue with the compiler.

In Zig, strings resemble those in C, functioning as arrays of bytes or u8 with a known length. There isn't a specific string type; it's either []const u8 or []u8, similar to C. Despite encountering a memory leak due to some sloppy string allocation, I successfully implemented a shading tool in the pixel editor. Right-clicking on the pencil tool now enables you to darken your work by 5 on the RGB scale.

After addressing these challenges, I shifted my focus to the game engine, contemplating the user interface. One particular aspect was interfacing with Textures. During Pixel Editor development, I initially had to manually add image files to the assets folder and handle loading them. Subsequently, I automated this process by iterating over an array of strings. However, this led me to ponder whether I could streamline the process further by loading all images in a directory and generating an enum at compile time. The answer? Yes, indeed!

The current interface for textures in the Pixel Editor is textures.get(.ImageName), where .ImageName corresponds to an enum I updated. The concept is to accomplish all this at compile time, making it as simple as .get(.WhateverImageIHave) after adding the image. While I haven't fully realized this idea, I now know it's possible. Special thanks to Adam for providing invaluable assistance in navigating these complexities; he's like having a cheat sheet!

Day 15 Update (1/18/2024):

Today, I delved into the world of shaders, watching videos and reading the shader pipeline wiki to grasp some concepts. Experimented with drawing in the pixel editor and implemented the following features:

Introduced the ability to use the + and - buttons to adjust values such as colors, frame count, current frame (as before), opacity of the previous frame, and a new setting called step, indicating how much the + and - buttons increment or decrement.

Improved image loading: When your canvas is set to 32 x 32 and you load a 64x32 image, the program now assumes you want to load two frames. Future enhancements may include smarter loading options.

Explored terrain generation, and I was pleasantly surprised to discover a built-in Perlin noise function in raylib for generating 2D images.

Day 14 Update (1/19/2024):

In this concise update, the Pixel Editor is largely completed to meet my current requirements. Looking ahead, the focus shifts to generating small, modular pieces of code that can be integrated into the game. Over the next month, I plan to explore various programming patterns and delve into aspects of game development that are either new to me or in need of significant brushing up. Two key areas of emphasis will be shaders and procedural generations.

There's also some uncertainty regarding the technology stack for this project. While the Pixel Editor was initially crafted using Zig and Raylib, I remain uncertain if this combination is the optimal choice. Presently, the inclination is to continue with Zig and Raylib, but decisions may evolve as the project progresses.

Day 13 Update (1/18/2024):

Here's a summary of the recent developments:

Opacity Feature: Introduced opacity to the last frame for easier tracing and animating of subsequent frames. Some might refer to this as the "onion" technique.

Color Picking Enhancement: Modified the color picking mechanism. Now, holding down r, g, b, or a while scrolling the mouse wheel allows for seamless color changes. This functionality, while improved, might undergo further refinement in the future.

Camera Addition: Implemented a camera feature, enabling users to navigate the canvas with the right mouse button. Additionally, the scroll wheel can be used for zooming in and out.

Save Functionality Enhancement: When saving, if there are multiple frames, they are now arranged next to each other, forming a sprite sheet for convenient use.

Other minor improvements may have been made, but these are the notable highlights.

This weekend or tonight, a release will be made available on GitHub for Windows, Mac, and Linux. Users interested in exploring the tool can download and experiment with it. Additionally, simple build instructions will be provided in the updated Readme for those who prefer building from source.

Looking ahead, the focus will shift towards starting work on a game. While the initial attempt may undergo revisions, hashing out ideas is essential before delving into the actual development process. Exciting times ahead—LET'S GOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! I'm pumped!!!!!!

Day 12 Update (1/17/2024)

Got animations working last night in the pixel editor! Almost done with it to be able to use it for what I need. There probably will be a lot of messing with the code to get thing working but this program is just a FM project aka a For Me program. Probably on Saturday I will be able to start on the game. LETS GO!!!!!!!!!!!!!!

Day 11 Update (1/16/2024)

Hot reloading of icons and save and loading with a system dialog file manager. When loading in an image you can make edits to it and re-save it. Updated the icons and had a freaking blast!!!!!!!

Day 10 Update (1/15/2024)

Started working on a game about 10 days ago in zig using raylib, and as I do, I found an excuse to make a "tool" that already existed but doesn't have my name in the commit messages. SOO I am working on a pixel editor that is about 80% done for what I need then I am going to make a game to put out on steam this year. Crappy as it may be and probably unsuccessful I think its really just about competing something rather then being successful I just have fun regardless.