The final demo slide for &active-slides is done. And that's a wrap for my jam project. Originally my idea was to have an actual editor for slides but I didn't really get enough time this week to finish something like that. so I just decided to see how easily I could make slides with many dynamic elements using the project

&active-slides
Putting together a small demonstration was fun! My test slides now include implementation of LERP as well as BILERP. That'll probably be it for the jam project, but there's loads more I could add. I just didn't get as much time this week as I had initially hoped.
The bilerp slide fits in 120 lines of lua code, to be expected since there's actual interactivity in this

&active-slides
Finally able to show the interactivity in one of these slides. Dragging around objects, and super easy to program in lua!
The small test is also running at ~0.7 millisecond frame times, (2x better than my previous attempt at an ui engine). Ofcourse the test doesn't really mean anything big about the performance since it's such a small demo, but it's nice to see I'm doing something better than last time, at least for myself.

Finished almost all the lua bindings for &active-slides and also implemented switching between slides! Smoothely

&active-slides Starting with my "Interactive Slideshow Program" project. Off to quite a late start, but I've finally got a few lua bindings for drawing UI things. Lua will be the way to specify slides, and as it's an actual programming language, interactivity should be quite easy to write

Made Pong with my custom Nintendo DSi language.
153 Lines of code in total and runs awfully slow on an actual Nintendo DSi because it's an unoptimizing compiler

A lot of time later, I finally have a hello world program running on my NDS (8x8 Bitmap font)
The program is 142 lines of code total.

&dsilang

Finally got something visual to show for the project I've been working on for the past three to four months.

• Custom language compiling to arm assembly
• Packed in a .nds file getting loaded on an nds emulator (As well as my DSi)
• Displaying a blue screen via a bitmap

&dsilang

Finally finished (At least for now) my mini-compiler frontend. https://github.com/PixelRifts/mini-frontend
Took 2 months, we'll see if it was worth it.

Goal of this project was NOT to make yet another language, it was to make a compiler frontend so that I can dive into compiler backends. I'm excited for that to be honest, much of this was just elbow grease, which I am glad to be done with (cough typechecker cough)

&dsilang

Been working on a game/video project for the past month or so. Pretty close to completing a VERY rough demo

Been working on my SoME#3 entry for the past two months and it's finally out now!
It's about the basics of lexing parsing and evaluating mathematical expressions.
https://www.youtube.com/watch?v=myZcNjKcVGw

Made a working Chip-8 emulator
(running the glitch ghost game)

Been working on supporting Linux for my c codebase.
Same Code, different OS-es and graphics api backends, but all of them get same outputs!

I made a video about my two year long journey of using C for various projects!
https://youtu.be/lMvFWKHhVZ0

Been working on my C-Codebase.
It now has swappable backends. Just define a macro and it'll switch the underlying implementations of functions.
So for a demo, I rendered a multicolored triangle with the 3 backends I have implemented currently: OpenGL 3.3, OpenGL 4.6 and D3D11

(You won't see a difference between the 3 multicolored triangles, which is good for my codebase but bad for the demo :kekw:)
Repository: https://github.com/PixelRifts/c-codebase

I've made a repository for a very simple C OpenGL renderer API.
It looks this simple to use:

Render_Begin_Frame(&renderer);
Render_Push_Quad_T(&renderer, rect_init(400, 400, 100, 100), Color_Magenta, white_texture);
Render_Push_String(&renderer, &inconsolata_font, str_lit("Text Rendering!"), vec2_init(500, 100), Color_Yellow);
Render_End_Frame(&renderer);

It fits in precisely 300 Lines of code, and is super easy to extend
https://github.com/PixelRifts/easy-renderer
For a nice demo: I made a little tetris clone... so enjoy my terrible gameplay 😛

&multiedit Just to see how easy it is to convert anything to a multiedit plugin, I ported my old solid state visualizer into a plugin.
Also showcases you can do literally anything with plugins here.

&multiedit a basic particle system plugin in 183 LOC. Yes it's very barebones, but it works!

&multiedit Multiple plugins and Window resizing done. key events, mouse button events and resize events are now accessible through plugins
Now for the fun part (Trying to make a particle system editor as a demonstration)

&multiedit Quite a bit of progress since yesterday, added proper plugins and rendering via them is super easy

&multiedit Had to rescope a bit, panels were causing quite a pain for rendering for plugins. so wasted a day on that.
In other news, I got the file explorer bit working today, with queries!

&multiedit Got basic panels working. Should be easy to attach plugins to them which is the next step

Me and my friend made this game for SoME#2 (Math exposition "competition" by 3blue1brown)
https://voxelrifts.itch.io/graphit

Made a little visualization application for solid state geometry using C/OpenGL

https://github.com/PixelRifts/Rift I've been working on a C-Like Language for the past few months. It aims to be C but a few improvements to it that I would like to have. I'm by no means an expert in making programming languages, rather this was my first actual language that wasn't off a tutorial or book.

Its features:

• A lot of stuff carried over from C
• Nested Comment blocks
• A better syntax for function pointers
• Lambdas
• Function overloading and Late-Binding
• Match-Case statements (so people like me who forget writing breaks after switch cases. don't have to)
• Operator overloading
• Namespaces (Like C++)
• Simple References (Like C++)
• A Tags system that replaces #define and #ifdef/#ifndef
• Namespaced Enums
• Flag Enums (for nicer bitfield declarations)
• Imports and "Modules"
• Transpiles to a single c file. You can check the examples folder in the github repo. it has examples for everything in this list that C doesn't have.

For a "demo" I got a triangle up and running with OpenGL in it (with some simple "native" declarations for functions from glad and glfw)