Press 1 - 6 to select/launch/reset any of the examples
Press Space to download screenshot
Apart from the raster bars and lissajous curve all other demos can be interacted with via mouse
Open the browser console to see the (already transpiled) source code of all examples
Example #1: Scribble & color cycling
Hold down left mouse button to cycle the colors (the current palette is also always shown in bottom-left corner). Nice, powerful oldskool effect, which is actually easier to do with these indexed, non-RGB pixel buffers[1]
Example #2: Lissajous bobs
The spheres are actually 2x2 tiles of 8x8 pixel sprites with one color slot chosen as transparency. Drawing 100 spheres here, but could be a lot more...
Example #3: Raster bars
This oldskool effect is achieved via HSYNC interrupts only, i.e. no lines are being drawn — for every single pixel row we simply change the color value of the first palette entry. The text is also only being drawn once, at startup...
Example #4: Particle system
Simple particle system (2k particles) with the emitter position linked to the mouse. 6% probability for larger particles.
Example #5: Random pattern
Classic oldskool generative art, here by defining 4 custom bitmap font characters and then drawing a single randomly chosen char per frame
Example #6: Bitmap font editor
Select a character on the RHS to edit in the left box. Left click to set a pixel, right click to clear it. Press Delete to clear the char entirely. The system supports proportional width fonts and the little red triangle can be moved horizontally to adjust the width of each char... Clicking on the Save button will download a JSON file of the font's binary data (9 bytes per char: width + 8 data bytes)
In preparation for teaching a 3-day "Computing within limits" workshop @ University of Applied Sciences in Augsburg, almost exactly a year ago (next week) I created a little fantasy console (heavily inspirered by TIC80) to introduce students to:
the idea of virtual machines / computing environments
the freedom to design & control any aspect of that environment (and how this relates to the overall idea of personal computing these days)
designing & building a small (virtual) env from the bottom up (incl. defining opcodes, memory limits, maps/regions, device control registers, interrupts (hsync/vsync), device I/O, comms & multi-tasking possibilities, various retro-computing inspired graphics techniques)
defining a small low-level API/language for creative coding
learning about binary/hex and how that knowledge translates visually
The short video gives an overview of five small examples & tools (incl. a bitmap font editor) I had prepared for the workshop — the entire system was built within a couple of days with http://thi.ng/umbrella and incl. examples is only 12KB (gzipped). In the workshop we later ended up mostly using the TIC80 instead, since we covered quite a few other wider perma- & retro-computing related topics too... The 3 days were barely enough to provide an overview and have some exploration time...
If anyone is interested in a similar workshop, please do let me know, I'm keen to repeat it/extend it...
(Ps. I will post a link to the interactive version later too)
The road ahead is long. It may take years but victory ✌️ is coming to #Ukraine from the sky. It's gonna suck to be an orc 🇷🇺 for eons to come . #SlavaUkraine 💪🇺🇦
Repost from @strawbridge_aviation
•
Incoming gifts 🎁 for #Muscovy
In this blog post we will try to demystify what exactly occupancy is, which factors limit occupancy, and how to use tools to identify occupancy-limited workloads.
Probably the biggest problem with ATS2 is the very steep learning curve associated with it. Very few programmers were able to ever overcome it to reach the point where they could truly start enjoying the tremendous power of (advanced) type-checking and (embeddable) templates.
When DML (the predecessor of ATS) was designed nearly 20 years ago, a two-layered approach to type-checking was taken: ML-like type-checking first and dependent type-checking second. This approach was later abandoned in the design of ATS. Instead, there is only dependent type-checking in ATS1 and ATS2. In ATS3, DML's two-layered approach is to be adopted. In particular, a program in ATS3 that passes ML-like type-checking can be compiled and executed. So one can skip dependent type-checking in ATS3 if one so chooses. In this way, the learning curve is expected to be greatly leveled. But there is much more than just leveling the learning curve.
ML-like types are algebraic (involving no explicit quantifiers). Such types are so much friendlier than dependent types (which often involve explicit quantifiers) for supporting type-based meta-programming. It seems that a chance has finally arrived to properly address the problem of template instance resolution that causes so much annoyance in ATS2 (due to the very use of dependent types for template selection).
In short, ATS3 adds an extra layer to ATS2 for supporting ML-like algebraic type-checking. Type-based meta-programming in ATS3 solely uses algebraic types (while ATS2 uses dependent types)."
Occupancy explained (gpuopen.com)
In this blog post we will try to demystify what exactly occupancy is, which factors limit occupancy, and how to use tools to identify occupancy-limited workloads.