Spent a bit working on doing more on the “shader lathe”.

Some things are missing:

  • FFTs
  • LUTs
  • Post processing (DoF/AA)

Meanwhile, GNU Rocket and widget integration was added. Now its possible to edit shader variable by GUI elements or by a script.

Been spending more hours on CSGO….

Yeah…been spending more time on my casual matches than deathmatch. Been avoiding competitive due to not wanting long matches and not having a decent amount of friends to play it with. Been playing it just to spend time on something at least after work.

That and Doom. Doom runs so well and plays so well too. Tiago Sousa and the rest of the people at iD are gods.



Spent a bit working on doing up a small shader editing tool, has the fundamentals of realtime shader editing.

Many things are missing:

  • Audio (FFT, playback, 4klang playback)
  • Widgets (progressbar, shader uniform editing)
  • Post processing (DoF/AA)
  • GNU Rocket integration

Update: The original developer noticed my IL level hacks and made them official in the next Monochrome version (and current private beta), with a configurable and hidden blacklist. Thanks to Piotr Pawlowski (foobar2000/ex official Winamp plugin dev) for this!

The following tutorial shows the very basics of .NET hacking.

This time, a practical real world application is used: modifying IL to self-censor content that is said and received on IRC. This was done by me to help eradicate possible sources of drama in my life (thus saving myself from an early death). Plus it gives people a possible relief from my ranting.

This tutorial will go through the basics of editing a .NET executable on a IL level using code decompilation/recompilation.

First of all, acquire dnSpy. It is a excellent debugger for .NET with extra capabilities for recompilation of CLR code.

The target used is Monochrome : I am well aware its GPL, but its good for a tutorial such as this, plus where is the fun in just recompiling the app?

Secondly, load up Monochrome in dnSpy:

You can see the various namespaces in use by Monochrome, thankfully its not protected. Various .NET based protections will scramble code making it harder to debug such applications, just like Denuvo and VMProtect with native C/C++ apps.

Next will take some time, to find some code that relates to what we want: basically we want to just limit what we can say and what we can receive. I did some looking around and funnily enough there is a C# class called “InputBox” in the code…

Suspiciously, there is some methods in there that look, well, suspicious :). sendinput() looks like a dead giveaway for something, so lets find out….

Press “Start” and click “OK” to start the debugging process.

To debug a class method, simply double click on the method. You can select breakpoints by double clicking the code line in the decompile.

To check if this method is responsible, I just typed into monochrome’s inputbox “test test test”. Instantly, the breakpoint is hit and….

We found our line. Now lets try editing the code of Monochrome so that it filters out what we type according to a filter list. Right click the code listing in dnSpy and click “Edit Class (C#)”

Here we see a decompiled listing of the code in the InputBox class. From here we can do edits to the source code.

Here I added a line so we can use the regular expression namespace and classes in .NET, which could be useful for text filtering.

In the sendInput method, I did some extra code which will be appended. The code basically looks for any mention of keywords in a list that are in the entered text. If they exist, they are rejected, otherwise, the sentences are rejected. Then click “Compile” to recompile the code. You may need to clean up any code errors the recompiler picks up, which are listed in the log.

To test our code injection, we save the module by going to File -> “Save Module”.

Then we just run the debugging process again, with the patched executable to test.

As you can see, the new code is in the executable, now time to test…..

No matter how hard I try, I cannot enter anything with the word “byuu” in it. It is not registered in the log, and thus, never sent.

Next is finding the code responsible for recieving entries in the channel view, ironically there is a class called “ChannelView” with the “addline” entries.

Which seems to fit the format of the text in the main log box shown earlier. Now is just a matter of adding code to filter lines based on content.

To make the job easier, just right click the code and click “Edit Method (C#)”. This will allow editing of just the code relevant for that particular function.

From there….

Make your alterations and then click “Compile”. Don’t forget to save the module again to save your patched code changes.

One thing I wasn’t sure of, is whether dnSpy allows realtime code editing and then rerunning of recompiled code. Feel free to correct me if it can, which will make imo, a great .NET assembly editor even better.



What happened:

  • Acquired a 3DS again for homebrew development.          
  • Did some work on foo_dsp_effect. GUIs for changing effect parameters are now fully non modal and accessible in two clicks or a keyboard button press. Also, the pitch effects have been rewritten to have smooth changes instead of the clunky effects in the past. This is coming in a future WIP, and I have no release date set.
  • While noticing members saying garbage about a friend of mine……noticed the following:    
  • Well, I appreciate the sentiment after about 9 years I guess. That’s a rather nice thing to say, that I can be talented if I put my whole mind to it. Definitely changes my whole perspective of what I think about byuu :). Which leaves me wondering what to think about Kakashi….


Worked on proper reflections these time, doesn’t seem to be that intensive on framerate. Ideally the floor should be something of a fluid.

Got a vague idea of what the next prod will be, but either:

  1. Don’t want to spoil things too much
  2. Don’t want to make things too ambitious.
  3. Conversely, don’t make it too plain to fall into common tropes these days.

To be quite honest, I don’t know anymore if I’ll make it to Syntax this year. I hope I do but currently some things happened that are way out of my hands and I don’t know if trips will be possible this year.

So, I got a new GPU:


Not sure what to do next. I still have the notes for Dune written down, could go do some more stuff in regards to that and pray the demo machine is a 1080 based setup or something. Or I shot myself in the foot and should have went with AMD instead.

At least now games like Metro 2033 and Doom run properly now. I should go ahead with that idea to make a lemon PC for coding though I suppose.

Spent the last few days writing up some code for Dune.

Mainly spent time trying to find optimizations here and there. Main optimizations were found regutting using OGL4 functions. For instance:

And the mainloop as:

Much more simplified than before, which means space savings (yay). Had to make a external texture for post processing though, due to some effects being impossible to do purely in the raymarch (which is too restrictive). I have some ideas on what to do for the demo though, just need to sit down and prototype some. And then work with a musician to slap it all together with some sync and stuff into one neat package.