Welcome to my website!

Hey there, random internet dweller, welcome to my website! My name is Michal Procházka, and I'm a student currently living in the Czech Republic.

36 days, 12 hours, 30 minutes & 5 seconds without an accident!

I tend to focus primarily on computer-related projects either just for fun, or because I somehow have an actual need for the thing that I'm working on and there isn't any other viable solution available (that, or because I'm just cheap and doing things myself is, well, cheaper). Either way, I find the results of my development work rather cool. Don't be afraid to scroll down and explore!

If you find any of my online accounts, they will likely have this profile picture.

It's a Terraria character I made many years ago, and I've been playing with it a fair bit. Well, until I was dumb enough to migrate to a new computer, erase the old drive and forget to back up my Terraria saves (because Terraria for some reason does not sync to Steam Cloud by default, and the saves were in ~/.local, a directory which I deliberately wanted not to migrate over).

Luckily, I did not lose any of the worlds that I actually played on, as I primarily played on a LAN server. So the loss was not really that devastating (other than for all the gear that I had in my inventory).

I have since implemented a robust backup system, and created a new Terraria character (which looks basically identical to the old one which I use in my profile pictures, other than the fact that it's now wearing full armor and a cool wizard hat).

Please keep in mind that this site is still under construction and is subject to change! (Don't worry, I'm talking about just adding new content, I don't have any intentions to turn this site into the stereotypical soydevvy JS-riddled infinitely scrolling unusable garbage that is so common on the web nowadays.)

What I'm trying to say is that if you visit this site every couple of months, there may be new stuff to explore. That's it.

corrodedbar

Written in Rust

A simple text-based statusbar for your X11 window manager. It can easily interface with services such as PulseAudio or NetworkManager, it is easily extensible and wildly configurable.

Yes, I'm one of those freaks who still use an old X11 tiling window manager (more specifically, dwm). And no, I am probably not switching to anything else anytime soon. After I had used dwm for several years now, everything else (especially full-blown desktop environments) feels clunky by comparison.

Essentially, I have reached the Linux nirvana, when you figure out that you do not need more than a simple window manager (and preferably a compositor) for using your graphical applications.

My current setup (Arch Linux + dwm + an old build of compton) and the way I have everything currently configured is, for lack of a better term, quite comfy for me.

...except for one thing. Before creating this project, I was using a simple shell script to update the status text in dwm. That was far from ideal: it ate up too much CPU time, often the clock would skip seconds, sometimes it would inexplicably crash etc. So at one point I finally decided to bite the bullet and write my status bar in something more sensible.

Also, I wanted to start learning Rust, and needed a good first project. 🦀

Apple I Emulator

Written in MATLAB

I very much dislike MATLAB with its absolutely proprietary & commercial nature. That said, I am kind of proud of this one. At the end of the mandatory MATLAB university course, we were tasked to make something in MATLAB (and it had to be a GUI application). I was switching between a few ideas, before I ultimately settled on emulating the Apple I. After all, the Apple I hardware is incredibly primitive - you have a 6502 CPU, many kB of RAM, a terminal interface and ROM. How hard could that be?

Actually, not that much. Within a few days, I had a semi-working 6502 implemented in MATLAB that was able to boot the WozMon and manipulate the memory, even launch simple programs. (And after running some standard 6502 emulation tests and further improving the emulator, I was able to boot Integer BASIC).

There was just one problem: the emulator was insanely slow (as in slower than real hardware running at 1 MHz). I started benchmarking MATLAB, and figured out that calling a function which just writes to a global variable (you know, it is kind of important for an emulator to have a function which reads/writes from/to a given memory address) is just shy of being 1000x slower than if the code had been inserted inline.

So, that's what I did! I created a simple MATLAB preprocessor (in Bash) that inlines certain functions (with the output script being a single ~15k line file). Now, the emulator (on my Ryzen 5 3500U machine) executes on average ~500k instructions per second, which is quite on par with original hardware! And to wrap the whole thing up, I added some blinkenlights. Because why not.

Retrulator

Written in iOS Shortcuts, JavaScript, powered by JSNES

There was a period of time when I used to daily drive an iPhone (more specifically, an old 1st gen iPhone SE). What made me mad the most was that I couldn't install (or "sideload") my own applications, including emulators for old 8-bit systems (which the SE could otherwise handle with breeze). Sure, I could play through a browser on some shitty website, but I wanted to play my old NES library offline. What else would I do when I'd be stuck in the middle of the woods?

Introducing Retrulator, a solution for your offline 8-bit needs. Coding such large projects in iOS Shortcuts is a complete clusterfuck (remember, iOS Shortcuts are officialy meant to do simple tasks, once you add >100 blocks to your project, the Shortcuts editor goes to shit performance wise), but I managed to pull off a half-decent UI with which you can add downloaded NES games to your library and play them through Safari.

But didn't I say that it worked offline, when it still requires Safari? Well, what Retrulator does is that it embeds all required emulator code and game data into an enormous URL string, which Safari can parse, even offline.

Here's how to install it: first, create a "Retrulator" folder in the root of your iPhone (through the Files app), then install the shortcut from this link, Start it, give it the permission to access the created folder and also to connect to the internet (emulator code is not stored in the Shortcut and needs to be downloaded on first launch). Then, add your ROMs (do not use 50 Hz games, they are not implemented yet), turn your phone to landscape and enjoy!

Coachium (and its pre-cached variant)

Written in JavaScript, HTML, CSS

Web-based data logger software compatible with devices by CMA Amsterdam (currently only supports the CMA €Lab interface and CMA intelligent sensors). Coachium is a free and open source modern alternative for the official (expensive) CMA Coach software, which can run just about anywhere (Win/Mac/Lin/CrOS tested), provides a friendly and easy to use user interface and enhances the hardware capabilities in certain instances compared to Coach 6 (which is what our school still uses).

For deployment, it is advised to use the cached build of the program, as it is much faster to load (after initial install process) and even works offline. Updates are also handled correcly, as the cached build completely avoids the browser's cache and implements its own.

This is the result from our (group of 3) school project. I did all of the development on the program itself (as part of my IT graduation thesis), while the other two were busy creating a very nice homepage/portfolio for the project.

Of course we made a silly promotional video about it (no, the school didn't burn down, don't worry).

tinyWatch

Firmware written in AVR assembly, shell designed in OpenSCAD

My old analog watch broke down (partly due to my fault), so instead of buying a new one, I decided to find out if I was capable of cobbling a half-functional wristwatch together from random crap that I already had lying around at home. The result of that is a reasonably stylish ATtiny1614-powered watch with a 128x64 monochrome OLED screen and a not-too-thick 3D printed housing. And the bloody thing works!

A picture of the tinyWatch showing time somewhat accurately

The firmware was originally written in C, but around the end of July 2022, I managed to rewrite the entire firmware to AVR assembly (using avra syntax). Thanks to that, I was able to squeeze the firmware size down from ~3 kB to ~2 kB. Impressive, right?

No, but really, I am planning to add more functionality to the watch (such as a stopwatch & timer, perhaps a serial terminal with Morse code input (as the watch already has a UART), user storage for viewing text etc.), I just didn't manage to get around doing all of this.

As a side note, the watch clock currently runs from the ATtiny's integrated 32.768 kHz crystal, which is utter crap. From the datasheet, it can actually run anywhere from 31.5 all the way to 36 (!) kHz, wildly depending on the voltage and temperature. A revision 2 is going to use an external, good 32.768 kHz crystal instead (if such revision ever comes to light).

MODPlay (and its web-based GUI wrapper)

Library written in C, web app written in JavaScript, HTML, CSS

Being in line with tracker-related projects, here is another one of mine. It is an easy-to-use MOD file player library written in C which is near-100% compatible with the original ProTracker (except for a few weird effects which behave quirky in most trackers anyway). While only being a player (compared to a full editor, such as the previously mentioned Polytone), it was still a journey to get it to a state which I am now happy with.

Then, I got the brilliantly dumb idea to compile the library into WebAssembly using Emscripten and build a web-based GUI around it. And not just any GUI. A Windows 3.11-themed one! Because why not. It took me about a week of pure suffering (as I had to finish it for a deadline as an IT class homework), but the result (in my humble opinion) speaks for itself.

More info about the history of MODPlay is available in my blog post about it.

Want to try it out and hear how it sounds? Just click here!

PainDoctor and its Android companion app

Firmware written in C/C++, app written in Java

As many of my projects go, this one also stems from a teacher giving us a homework task. This time, it was our English teacher, who split us into pairs and tasked us to make a video advertisement for some fictional product. Our product, however, was not fictional. It was real, and the best part: it actually worked.

Powered by 2 AA batteries and an accelerometer mounted on a spring stolen from a ball-point pen, this thing managed to track your running motion, and if for whatever reason you stop, after a few seconds, it will give you a nasty electric shock in the belly (mounted on a belt). That's right, it literally shocks you back into motion. Does this sound a bit familiar?

This device hosts its own WiFi hotspot, from which you can download an .apk file (straight from the PainDoctor, even if you're in the middle of the woods without any connection) and install it. After running it, you will set how long you wish your exercise session to last and how strong of a shock you want. After hitting "Go", tighten the belt, drop the phone and run!

Here is a link to the video we made about this project (enjoy my awful accent). I know that it doesn't show the hardware all that much, but trust me, it worked shockingly well (pun intended). This is one of those projects which I think deserves a sequel, whose design & development time will not be limited to a single week.

Polytone (and PTPlayer)

Written in C

My modern implementation of the Monotone tracker, a square-wave only music editor/player intended to be played on old PCs using the beeper speaker. It uses SDL2, so it runs on all major platforms (Linux, macOS and Windows). It uses its own file format for expanded effect values & pattern packing, but it still has the ability to import your old Monotone files with 100% compatibility.

I'd say that it is quite well-featured for what it needs to be. Compared to MONOTONE, it has proper clipboard support (it just uses the system clipboard, so you can copy parts of a song from one Polytone instance into another), infinitely easier UI (thanks in part to the fact that it is not subjected to the same limitations of CGA graphics with keyboard input only), multiple export options (MIDI, WAV, CSV containing raw frequencies) etc. That said, I cannot rule out the possibility of Polytone gaining new functionality (mainly programmable oscillators which are not only square wave). We'll see what the future holds for this project ;)

PTPlayer is the backend for Polytone, as it does the actual file loading and audio rendering. I made it into a separate project, so that it can also be used as an independent player program (supplied in the repo), or that you can even incorporate it into your own productions, should you choose.

Here is a primitive web-based player built using PTPlayer. Nothing particularly exciting about it, really (at least compared to my MODPlay frontend, with its flashy retro GUI).

Kahút for the Sony PlayStation®

Written in C

Have you ever wanted to play Kahoot in class by bringing in the original Sony PlayStation® from 1995, hooking it up to the classroom projector and running it on that? Well, I sure did, and the will to make this happen was boosted thanks to our French teacher (of all people) who split us into pairs and tasked each one to make a Kahoot quiz on a particular topic that we have gone through in our French class.

As many of you already know, the PlayStation® has only 2 controller ports, thus only 2 players can play at one given time (unless you own 2 multitaps and up to 8 controllers, which I don't, or you engineer some kind of custom solution, which I didn't have time for), so the flow of Kahút had to be altered from the original Kahoot.

If you're interested in how I achieved this, please visit my blog post about it (including detailed game rules).

MichalOS

Written in x86 assembly

A fork of MikeOS 4.5 with many enhancements (too many to list, you'll just have to try it out for yourself and see). It's the project that has kept me busy since ~2018 (started on SourceForge) and has taught me how computers actually work (machine code, memory mapping, CPU modes, I/O access etc.). If you squint hard enough, you may consider it as a modern alternative to DOS-like operating systems for old computers (MichalOS requires a 386 CPU & 80-ish kB of RAM to run) to give them a second life.

Unfinished projects

To encourage myself to work on my old projects again and actually finish them, I decided to make the list of my unfinished projects public – below should be most of them. Consider this as a sort of "to-do list", just more shameful (and without the projects already listed above, which I still might be working on).