Running the Lil UEFI example, which boots up a simple "operating system" that just fills the display with a changing color.

Lil UEFI Git Repository: https://git.mr4th.com/Mr4th/lil_uefi

https://www.rfleury.com/p/more-languages-wont-fix-the-computing

https://www.rfleury.com/p/ships-icebergs-game-engines

Stress testing atlas sub-allocator for a texture & font glyph atlas cache!

https://www.rfleury.com/p/table-driven-code-generation

https://www.rfleury.com/p/ui-bonus-1-simple-single-line-text

https://www.rfleury.com/p/the-gullible-software-altruist

https://www.rfleury.com/p/ui-part-7-where-imgui-ends

https://ryanfleury.substack.com/p/computers-ownership-agency

https://ryanfleury.substack.com/p/ui-part-6-rendering

https://ryanfleury.substack.com/p/ui-part-5-visual-content

Blog https://ryanfleury.substack.com/p/ui-part-4-the-widget-is-a-lie-node

https://ryanfleury.substack.com/p/ui-part-3-the-widget-building-language

New prototype Notepad-esque editor, prepared over my last few streams. It's our goal to start with very basic editors for the Dion Format, so anything smarter we do falls back on something rock-solid. We want it to be easy to write something like this, so it's easy to push onto something more complicated.

I animated the cursor because I am physically incapable of writing an editor that doesn't interpolate the cursor position.

&dion

https://github.com/Dion-Systems/metadesk/releases/tag/v1.0

Featuring full documentation for the Metadesk library at https://dion.systems/metadesk_reference.

&dion &metadesk

Dynamically sized thumbnails; Metadesk-encoded help menu and command history; filtering based on tag.

[posted on behalf of @neo on the IRC]

https://gitlab.com/-/snippets/2135217#LC263

Communication has become very important to the Dion project. So, a huge priority for us was building a new website that allowed us to communicate.

The new site has a blog, project information, a gallery, FAQ, and more. https://dion.systems/

We've got our first blog post up, outlining our roadmap for the Dion project moving forward. https://dion.systems/blog_0002_roadmap

&dion

Early experiments of an editor on top of new format ideas. Certainly less pretty than the old demo (for now, just using developer debug rendering), but with much clearer thoughts about what the format's role is in the compute system. Here's an example of storing visual layout hints inside of the format and altering it on a per-subtree basis.

One important detail of Dion's goals is that it needs to be much easier to build tools than it ever has been with text. This WIP viewer/editor took 2 hours to make today (on top of our internal base layer). That includes the node structure itself, rendering, and layout.

https://cdn.discordapp.com/attachments/729080610995437578/830219331869736980/fJheFPddiR.gif

Metadesk-based static site generator being used for docs generation (in this case, docs for Metadesk 🙂). &metadesk

Working on new shared developer layer for Dion development, including UI, tweak variables, and plugins for prototyping our new tools.

Quick tool I wrote for 4coder yesterday evening, LOC breakdown for buffers in 4coder. Breaks things down by file (all), section (comments starting with //~, forming divider lines), and sorts by size. Accounts for { lines and empty lines too. Intended for figuring out what parts of a big codefile are actually the bottleneck in size quickly.

4coder fun: Syntax highlighting "visors"

Some debug visualizations that might give some insight into how entities are working.

Messing around with graph-based crafting systems.

Turns out trees are also great for making tables.

Turns out trees are pretty good at making trees. https://cdn.discordapp.com/attachments/729080610995437578/794112580024533012/XnoxdrXxaX.mp4

Jai code indexing and stuff in 4coder.

School project for one of my last university classes, but it was actually one I had fun with. https://cdn.discordapp.com/attachments/703366926981922830/783554263284056064/Wuyw6toxmS.mp4

Tooltips, basic profiler UI

Line edits

Brief demo of the state of my new UI experiment, up until this point in time.

Infinite list with a scrollbar, adjusting the maximum number of items (notice how the number of actual reserved widgets remains ~constant once the list area is full)

"Infinite" list in the new immediate-mode UI experiment

Window sorting with completely immediate-mode UI, and no input-handling deferring. Works hierarchically---this can happen for any widget sub-tree.

New IMGUI experiment I cranked out this morning. Unlike my previous IMGUI experiments with Dion, this doesn't defer input handling, but still allows for smart autolayout.

Should be clear, but it works both ways too (+ short editing sample):

https://cdn.discordapp.com/attach...94/763214182959022120/unknown.png

I may or may not have stolen this idea from @rxi

https://cdn.discordapp.com/attach...741416464698834965/q1ZthySPgx.gif

Quick demo of the internal developer system that has been really useful in working through a provably correct/functional cursor movement/editing scheme.

Editing at various granularities

Checkbox and collapsable juice

https://cdn.discordapp.com/attach...725481746480496752/OeUQN6Irhb.gif

Procedure types.

Some work with inputting type expressions.

https://cdn.discordapp.com/attach...715661986733490272/ohaUMGy3TA.gif

Immediate-mode UI keyboard navigation. Traverses any widget tree, discounts groups (only targets leaf-nodes in the widget tree), skips non-interactive widgets, remembers which widget was last selected in a group and recalls it.

Automatic HTML documentation generation from metatags on C code. Still need parameter linking up (see @Parameter thing in doc string), but overall it's working! Implemented by doing an approximate parse on the C code, forming a Data Desk AST, and traversing it and generating HTML (which uses a Data Desk helper function to transpile out to the C displayed in the docs), which is then fed into my static site generator.

Example of a very strict size specified on the left column

Working on expression editing.

Auto-resolving unresolved references

Made a prototype in a few hours today because I am stuck on The Melodist and wanted to test out my "off-the-ground" pace in Telescope. Turned out interesting, made a little "electricity" simulation thing

Plotting multiple functions, and plotting data (soon to be extended to C arrays as data), with graph metadata customization. All custom inside my 4coder custom layer, available here: https://github.com/ryanfleury/4coder_fleury

Graphing with calculator expressions in 4coder! (heavy WIP, very early showcase!)

One of the features in my 4coder custom layer: calculator comments! They are comments that begin with //c, followed by a mathematical expression. I just implemented variables and functions.

Spent today working on some 4coder beta 4.1.0 customizations... https://www.youtube.com/watch?v=bawpr3nzT68

&melodist https://www.youtube.com/watch?v=DuFQkRBbGpc

https://www.youtube.com/watch?v=9gX7kMP8tSc

&melodist https://www.youtube.com/watch?v=PVkRii0riH0

&melodist Developer terminal improvements. Now I have all formerly only stdout directing to: stdout, the Windows debug output, and also the developer terminal. Warnings and errors are logged as such, so warnings are yellow and errors are red. Builds for programmers have notifications for warnings/errors. I implemented this because I was spending far too much time trying to debug shaders when they were just failing to compile. Now I'll be notified of it so I won't waste my time thinking I wrote my shader code right. :) (Also has the benefit of catching slow spots)

https://www.youtube.com/watch?v=eHDf_Jii_Kk

&melodist https://www.youtube.com/watch?v=SqWZqaq3E6g

&melodist Reflective surfaces back in the game. https://www.youtube.com/watch?v=DxQiq6Q205M

Demonstration of the custom scripting language in The Melodist, and how that works with development flow. I run into some compile errors, still need to work on getting those errors reported in the editor. Nevertheless hot-reloading and runtime compilation (for developer builds) on a worker thread is working pretty well. :) An experiment happening soon: Visual script editing inside the editor! https://www.youtube.com/watch?v=YXrgB3AnZFI

Got the new intro music and title screen in! https://www.youtube.com/watch?v=S4icVcEgnT4

The Melodist developer tools tablet integration.

Title says it all. https://www.youtube.com/watch?v=jG5yNgc1BPw

Recently got my Wavefront OBJ parser to a much more usable state. There are two APIs you can use: (1) A low level API where you provide your own parsing memory buffer, error callbacks, loaded file contents and where you manually load in MTL files, and (2) A high level API, which basically does all of that for you using the CRT, and automatically loads MTL files (less shippable, but nice for getting something working quickly). The parser will spit out a list of renderables, which correspond one-to-one with the materials in the OBJ file, so you can directly pipe those to your renderer as renderable model subsets. It will also merge renderables with the same material. Currently, vertex buffers are interleaved, just XYZUVNNN (position, UV, then normals); let me know if you want API support for other output formats. Adding in other formats should be pretty easy to do.

The low level API does not allocate any memory, so you don't need to call any freeing functions if you provide your own parsing memory.

Here's the parser: https://gist.github.com/ryanfleury/0062f2ffdec07bcda8a4a0ef5c7f8f37. It's a single file, and you use it STB-style, e.g. with #define OBJ_PARSE_IMPLEMENTATION then #include "obj_parse.h".

Here's Sponza with all materials loaded in!

Handmade-style development is often seen as producing higher quality results, but ultimately being impractical in practice because of how much longer things take. To an extent, this is true; writing things yourself does take more up-front cost. However, once you've built up your own tech stack that serves the kinds of projects you work on, there are several benefits that provide a net win:

• Complete control
• Ability to make reasoned decisions about the requirements of a system
• Knowledge that allows you to choose between your existing tech, a library, or a new solution
• Using that knowledge to save you time while keeping quality high

As an example, I was recently approached to do a video collaboration jam game. I've used my own tech to make the game, and in <24 hours of development, I have the following:

https://youtu.be/IptM20CIAr4

A quick video showing a bunch of different code-generation and IMGUI features I've been working on, including: Arbitrarily-ordered windows, nested dropdowns, and automatic UI generation from introspection (the Static Object Editor UI is auto-generated from the definition of a Static Object)

https://www.youtube.com/watch?v=v5C38sDNKLU

New devlog which goes a bit more in-depth on Data Desk: https://www.youtube.com/watch?v=rR79AGmExq0

Below demonstrates some basic UI code generation functionality that can be implemented using Data Desk (https://github.com/ryanfleury/data_desk). All of the UI calls are directly generated from the structure parse.

https://www.youtube.com/watch?v=5TstiBqWcyk

On the left: Custom data description format with compile-time introspection and project-specific custom code generation support.

On the right: C code generated by a custom layer, which would exist specifically for a project.

Random experimentation with real-time CPU-side 2D ray tracing!

https://www.youtube.com/watch?v=bdFdZe9CA30

https://www.youtube.com/watch?v=yAogNqJhShE

The Melodist scripting system improvements! Messages can now have dynamically changing speeds and colors, and also choices! The player's selected choice can be queried inside of the scripting language to make decisions about which options were chosen.

https://cdn.discordapp.com/attachments/518236585133867009/539853785057722399/unknown.png https://cdn.discordapp.com/attachments/518236585133867009/539853826166095882/unknown.png

The Melodist event scripting language! Test script source code in the top left, result in the bottom left, C program that compiles and runs the script on the right.

The scripting language allows calling into native functions. These native functions just receive the parameters as a big buffer, and then they take it from there.

https://www.youtube.com/watch?v=XRl5WEHTXks

https://www.youtube.com/watch?v=Bpf2QasREmM

Writing a little scripting language parser for cutscenes/events in The Melodist. First time successfully writing a language recursive descent parser that generates an abstract syntax tree; this has been notoriously difficult in the past for me, for whatever reason. The text on the left is generated from the abstract syntax tree, which is created from the text passed into the parse_script function.

The code on the left is generated from the code on the right, using a bit of custom code that plugs into the prebuild program (custom code would be project-specific)

Basic C prebuild program with introspection, inspired by Handmade Hero's initial implementation of introspection. Allows custom code to hook into, calling that custom code as it parses new introspected types, so that the custom code can do whatever it wants with that information (generate functions based on that type, etc.)

Fun little projectile test for the Handmade Network stream today.

Software rendering! Experimenting a bit for the next Handmade Network stream.

https://www.youtube.com/watch?v=uWXCClj0bN0

Camera focus regions allow map developers to force the game camera to target particular positions in the map, with varying zoom levels and strengths. Not only does this allow the map developer to ensure that something in particular is seen by the player (irrespective of their screen resolution), it allows certain parts of maps to be tied with a particular "focus point", which is great for indoor/cave maps https://www.youtube.com/watch?v=qhEt71_bvpM

https://www.youtube.com/watch?v=ZSm3ink4iTs

Re-added dynamic shadows.

Got layered rendering back in. Game is finally starting to look like itself again! https://www.youtube.com/watch?v=RKKTRzM4hS0

https://www.youtube.com/watch?v=GdmRuPui3EM

https://www.youtube.com/watch?v=1GupU20ISeM

https://www.youtube.com/watch?v=uFDh3eqeqM0

(Upgraded) developer console https://www.youtube.com/watch?v=XdjKK8z3SoE

https://youtu.be/tg_qg8wTWBU

Website code block syntax highlighting (rolled it myself)

Wrote a C program to take my own blog file format and generate HTML from it, looking something like:

@Title: A Theoretical Examination of the Abstraction

It is without doubt that all software developers...

(...)

@Image: some_path.png

@Code: {
    // stuff
}

I then integrated it into my personal website so that all blogs are automatically shown as lists, etc. :)

More voxel experimentation. Been working with real-time world modification and chunking.

More marching cubes experimentation. Just exported a mesh generated from voxel data to a .obj and viewed it in Windows 10's thingy

Marching cubes experimentation, on a whim...

Apologies for the lag... Recording on a laptop. It's smooth as butter in person. :) Note how the third background option is added with the modification of a text file! https://www.youtube.com/watch?v=kSfc2FHgDQ4

(~1.5 months of Vulkan)

https://www.youtube.com/watch?v=gTlbJDc8rFc

Asset-tag hot reloading (modifying the use of certain textures at runtime)

https://youtu.be/gOCw11EHbrk

Working on a new renderer for The Melodist (abstracting out for different backends, making it more performant)--having some fun with it:

https://www.youtube.com/watch?v=Q-h5d8R5lLo

https://www.youtube.com/watch?v=gg7bOmYJAus

https://www.youtube.com/watch?v=P7fdhZvh3uQ

https://www.youtube.com/watch?v=uucOzSWKqQg

https://www.youtube.com/watch?v=NFRdrwMJ4v8

The Melodist is a game where you are told how to feel.

https://www.youtube.com/watch?v=bUTQ9cGRn18 Much better! Still have a lot of visual improvements to make, but it's working.

https://www.youtube.com/watch?v=kpQZ80bLalk

Getting particles in the game so that I can work on weather. The weather will react to musical changes in the world. https://youtu.be/GxN248peHZc

https://www.youtube.com/watch?v=ASS0Ujnv9UI

https://www.youtube.com/watch?v=2iBehndssOM

https://www.youtube.com/watch?v=lsV7OfHK-0w

https://www.youtube.com/watch?v=zBEel65UU6A

Short side project...

https://www.youtube.com/watch?v=25G4O915rPY

https://www.youtube.com/watch?v=LNRfbZlppLo

https://www.youtube.com/watch?v=hXOEV5zFO54